diff --git a/Changelog.md b/Changelog.md
index f746fb7..1234f39 100644
--- a/Changelog.md
+++ b/Changelog.md
@@ -5,10 +5,11 @@ All notable changes to this Julia package will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [0.3.14] unreleased
+## [0.4.0] unreleased
 
 ### Changed
 
+* Switch from manual backend creation to [ADTypes.jl](https://github.com/SciML/ADTypes.jl) + [DifferentiationInterface.jl](https://github.com/JuliaDiff/DifferentiationInterface.jl)
 * Julia compat lower bound bumped from 1.6 to 1.10 (the new LTS)
 
 ## [0.3.13] November 13, 2024
diff --git a/Project.toml b/Project.toml
index cc4e002..b24a262 100644
--- a/Project.toml
+++ b/Project.toml
@@ -1,9 +1,11 @@
 name = "ManifoldDiff"
 uuid = "af67fdf4-a580-4b9f-bbec-742ef357defd"
 authors = ["Seth Axen <seth.axen@gmail.com>", "Mateusz Baran <mateuszbaran89@gmail.com>", "Ronny Bergmann <manopt@ronnybergmann.net>"]
-version = "0.3.14"
+version = "0.4.0"
 
 [deps]
+ADTypes = "47edcb42-4c32-4615-8424-f2b9edc5f35b"
+DifferentiationInterface = "a0c0ee7d-e4b9-4e03-894e-1c5f64a51d63"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 ManifoldsBase = "3362f125-f0bb-47a3-aa74-596ffd7ef2fb"
 Markdown = "d6f4376e-aef5-505a-96c1-9c027394607a"
@@ -17,18 +19,12 @@ ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210"
 ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267"
 Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f"
 
-[extensions]
-ManifoldDiffFiniteDiffExt = "FiniteDiff"
-ManifoldDiffFiniteDifferencesExt = "FiniteDifferences"
-ManifoldDiffForwardDiffExt = "ForwardDiff"
-ManifoldDiffReverseDiffExt = "ReverseDiff"
-ManifoldDiffZygoteExt = "Zygote"
-
 [compat]
+ADTypes = "1.11.0"
 ChainRules = "1"
 ChainRulesCore = "1"
+DifferentiationInterface = "0.6.23"
 DoubleFloats = ">= 0.9.2"
-ForwardDiff = "0.10"
 Manifolds = "0.10"
 ManifoldsBase = "0.15"
 RecursiveArrayTools = "2, 3"
@@ -37,8 +33,10 @@ StaticArrays = "1"
 julia = "1.10"
 
 [extras]
+ADTypes = "47edcb42-4c32-4615-8424-f2b9edc5f35b"
 ChainRules = "082447d4-558c-5d27-93f4-14fc19e9eca2"
 ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4"
+DifferentiationInterface = "a0c0ee7d-e4b9-4e03-894e-1c5f64a51d63"
 DoubleFloats = "497a8b3b-efae-58df-a0af-a86822472b78"
 FiniteDiff = "6a86dc24-6348-571c-b903-95158fe2bd41"
 FiniteDifferences = "26cc04aa-876d-5657-8c51-4c34ba976000"
@@ -52,4 +50,20 @@ Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f"
 
 [targets]
-test = ["Test", "ChainRules", "ChainRulesCore", "DoubleFloats", "FiniteDiff", "FiniteDifferences", "ForwardDiff", "Manifolds", "OrdinaryDiffEq", "RecursiveArrayTools", "ReverseDiff", "StaticArrays", "Zygote"]
+test = [
+    "Test",
+    "ADTypes",
+    "ChainRules",
+    "ChainRulesCore",
+    "DifferentiationInterface",
+    "DoubleFloats",
+    "FiniteDiff",
+    "FiniteDifferences",
+    "ForwardDiff",
+    "Manifolds",
+    "OrdinaryDiffEq",
+    "RecursiveArrayTools",
+    "ReverseDiff",
+    "StaticArrays",
+    "Zygote",
+]
diff --git a/docs/make.jl b/docs/make.jl
index fbda513..f2f15ea 100755
--- a/docs/make.jl
+++ b/docs/make.jl
@@ -28,7 +28,6 @@ end
 
 using ManifoldsBase, ManifoldDiff
 using Documenter, DocumenterCitations
-using FiniteDiff, ForwardDiff, ReverseDiff, FiniteDifferences, Zygote
 
 bib = CitationBibliography(joinpath(@__DIR__, "src", "references.bib"); style = :alpha)
 makedocs(;
@@ -36,24 +35,7 @@ makedocs(;
         prettyurls = (get(ENV, "CI", nothing) == "true") || ("--prettyurls" ∈ ARGS),
         assets = ["assets/favicon.ico", "assets/citations.css"],
     ),
-    modules = [
-        ManifoldDiff,
-        isdefined(Base, :get_extension) ?
-        Base.get_extension(ManifoldDiff, :ManifoldDiffFiniteDiffExt) :
-        ManifoldDiff.ManifoldDiffFiniteDiffExt,
-        isdefined(Base, :get_extension) ?
-        Base.get_extension(ManifoldDiff, :ManifoldDiffFiniteDifferencesExt) :
-        ManifoldDiff.ManifoldDiffFiniteDifferencesExt,
-        isdefined(Base, :get_extension) ?
-        Base.get_extension(ManifoldDiff, :ManifoldDiffForwardDiffExt) :
-        ManifoldDiff.ManifoldDiffForwardDiffExt,
-        isdefined(Base, :get_extension) ?
-        Base.get_extension(ManifoldDiff, :ManifoldDiffReverseDiffExt) :
-        ManifoldDiff.ManifoldDiffReverseDiffExt,
-        isdefined(Base, :get_extension) ?
-        Base.get_extension(ManifoldDiff, :ManifoldDiffZygoteExt) :
-        ManifoldDiff.ManifoldDiffZygoteExt,
-    ],
+    modules = [ManifoldDiff],
     authors = "Seth Axen, Mateusz Baran, Ronny Bergmann, and contributors.",
     sitename = "ManifoldDiff.jl",
     pages = [
diff --git a/docs/src/backends.md b/docs/src/backends.md
index d60253c..a524a5c 100644
--- a/docs/src/backends.md
+++ b/docs/src/backends.md
@@ -5,34 +5,15 @@ set_default_differential_backend!
 default_differential_backend
 ```
 
-## EmbeddedDiff
-
-```@autodocs
-Modules = [ManifoldDiff]
-Pages = ["embedded_diff.jl"]
-Order = [:type, :function, :constant]
-```
+## Euclidian backends
 
-## ForwardDiff.jl
+Euclidian backend objects can be taken from [ADTypes.jl](https://github.com/SciML/ADTypes.jl).
+See the documentation of [DifferentiationInterface.jl](https://github.com/JuliaDiff/DifferentiationInterface.jl) for the list of supported packages.
 
-```@autodocs
-Modules = [ManifoldDiff]
-Pages = ["forward_diff.jl"]
-Order = [:type, :function, :constant]
-```
-
-## FiniteDiff.jl
+## EmbeddedDiff
 
 ```@autodocs
 Modules = [ManifoldDiff]
-Pages = ["finite_diff.jl"]
+Pages = ["embedded_diff.jl"]
 Order = [:type, :function, :constant]
 ```
-
-## FiniteDifferenes.jl
-
-```@autodocs
-Modules = [ManifoldDiff]
-Pages = ["finite_differences.jl"]
-Order = [:type, :function, :constant]
-```
\ No newline at end of file
diff --git a/docs/src/internals.md b/docs/src/internals.md
index 74702cf..1dc209b 100644
--- a/docs/src/internals.md
+++ b/docs/src/internals.md
@@ -1,7 +1,6 @@
 ## Internal functions
 
 ```@docs
-ManifoldDiff.AbstractDiffBackend
 ManifoldDiff.CurrentDiffBackend
 ManifoldDiff._current_default_differential_backend
 ManifoldDiff._hessian
diff --git a/ext/ManifoldDiffFiniteDiffExt.jl b/ext/ManifoldDiffFiniteDiffExt.jl
deleted file mode 100644
index bec469c..0000000
--- a/ext/ManifoldDiffFiniteDiffExt.jl
+++ /dev/null
@@ -1,28 +0,0 @@
-module ManifoldDiffFiniteDiffExt
-
-using ManifoldDiff
-using ManifoldDiff: FiniteDiffBackend
-using FiniteDiff
-
-function ManifoldDiff._derivative(f, p, ::FiniteDiffBackend{Method}) where {Method}
-    return FiniteDiff.finite_difference_derivative(f, p, Method)
-end
-
-function ManifoldDiff._gradient(f, p, ::FiniteDiffBackend{Method}) where {Method}
-    return FiniteDiff.finite_difference_gradient(f, p, Method)
-end
-
-function ManifoldDiff._gradient!(f, X, p, ::FiniteDiffBackend{Method}) where {Method}
-    return FiniteDiff.finite_difference_gradient!(X, f, p, Method)
-end
-
-function ManifoldDiff._jacobian(f, p, ::FiniteDiffBackend{Method}) where {Method}
-    return FiniteDiff.finite_difference_jacobian(f, p, Method)
-end
-
-function ManifoldDiff._jacobian!(f, X, p, ::FiniteDiffBackend{Method}) where {Method}
-    return FiniteDiff.finite_difference_jacobian!(X, f, p, Method)
-end
-
-
-end
diff --git a/ext/ManifoldDiffFiniteDifferencesExt.jl b/ext/ManifoldDiffFiniteDifferencesExt.jl
deleted file mode 100644
index 0748151..0000000
--- a/ext/ManifoldDiffFiniteDifferencesExt.jl
+++ /dev/null
@@ -1,31 +0,0 @@
-module ManifoldDiffFiniteDifferencesExt
-
-using ManifoldDiff
-using ManifoldDiff: FiniteDifferencesBackend
-using FiniteDifferences
-
-function ManifoldDiff.FiniteDifferencesBackend()
-    return FiniteDifferencesBackend(central_fdm(5, 1))
-end
-
-function ManifoldDiff._derivative(f, t, backend::FiniteDifferencesBackend)
-    return backend.method(f, t)
-end
-
-function ManifoldDiff._gradient(f, p, backend::FiniteDifferencesBackend)
-    return FiniteDifferences.grad(backend.method, f, p)[1]
-end
-
-function ManifoldDiff._jacobian(f, p, backend::FiniteDifferencesBackend)
-    return FiniteDifferences.jacobian(backend.method, f, p)[1]
-end
-
-function ManifoldDiff._hessian(f, p, backend::FiniteDifferencesBackend)
-    return FiniteDifferences.jacobian(
-        backend.method,
-        q -> FiniteDifferences.grad(backend.method, f, q)[1],
-        p,
-    )[1]
-end
-
-end
diff --git a/ext/ManifoldDiffForwardDiffExt.jl b/ext/ManifoldDiffForwardDiffExt.jl
deleted file mode 100644
index 72d48ed..0000000
--- a/ext/ManifoldDiffForwardDiffExt.jl
+++ /dev/null
@@ -1,31 +0,0 @@
-module ManifoldDiffForwardDiffExt
-
-using ManifoldDiff
-using ManifoldDiff: ForwardDiffBackend
-using ForwardDiff
-
-function ManifoldDiff._derivative(f, p, ::ForwardDiffBackend)
-    return ForwardDiff.derivative(f, p)
-end
-
-function ManifoldDiff._derivative!(f, X, t, ::ForwardDiffBackend)
-    return ForwardDiff.derivative!(X, f, t)
-end
-
-function ManifoldDiff._gradient(f, p, ::ForwardDiffBackend)
-    return ForwardDiff.gradient(f, p)
-end
-
-function ManifoldDiff._gradient!(f, X, t, ::ForwardDiffBackend)
-    return ForwardDiff.gradient!(X, f, t)
-end
-
-function ManifoldDiff._jacobian(f, p, ::ForwardDiffBackend)
-    return ForwardDiff.jacobian(f, p)
-end
-
-function ManifoldDiff._hessian(f, p, ::ForwardDiffBackend)
-    return ForwardDiff.hessian(f, p)
-end
-
-end
diff --git a/ext/ManifoldDiffReverseDiffExt.jl b/ext/ManifoldDiffReverseDiffExt.jl
deleted file mode 100644
index 17ec702..0000000
--- a/ext/ManifoldDiffReverseDiffExt.jl
+++ /dev/null
@@ -1,15 +0,0 @@
-module ManifoldDiffReverseDiffExt
-
-using ManifoldDiff
-using ManifoldDiff: ReverseDiffBackend
-using ReverseDiff
-
-function ManifoldDiff._gradient(f, p, ::ReverseDiffBackend)
-    return ReverseDiff.gradient(f, p)
-end
-
-function ManifoldDiff._gradient!(f, X, p, ::ReverseDiffBackend)
-    return ReverseDiff.gradient!(X, f, p)
-end
-
-end
diff --git a/ext/ManifoldDiffZygoteExt.jl b/ext/ManifoldDiffZygoteExt.jl
deleted file mode 100644
index 9f59a0c..0000000
--- a/ext/ManifoldDiffZygoteExt.jl
+++ /dev/null
@@ -1,16 +0,0 @@
-module ManifoldDiffZygoteExt
-
-using ManifoldDiff
-using ManifoldDiff: ZygoteDiffBackend
-using Zygote
-
-function ManifoldDiff._gradient(f, p, ::ZygoteDiffBackend)
-    return Zygote.gradient(f, p)[1]
-end
-
-function ManifoldDiff._gradient!(f, X, p, ::ZygoteDiffBackend)
-    return copyto!(X, Zygote.gradient(f, p)[1])
-end
-
-
-end
diff --git a/src/ManifoldDiff.jl b/src/ManifoldDiff.jl
index 77ab67b..07813b0 100644
--- a/src/ManifoldDiff.jl
+++ b/src/ManifoldDiff.jl
@@ -20,25 +20,23 @@ using ManifoldsBase:
     _write,
     _read
 
-
 using Requires
 
+using ADTypes:
+    AbstractADType,
+    AutoFiniteDiff,
+    AutoFiniteDifferences,
+    AutoForwardDiff,
+    AutoReverseDiff,
+    AutoZygote
+import DifferentiationInterface as DI
 
-"""
-    AbstractDiffBackend
+struct NoneDiffBackend end
 
-An abstract type for diff backends. See [`FiniteDifferencesBackend`](@ref) for
-an example.
 """
-abstract type AbstractDiffBackend end
+    _derivative(f, t[, backend])
 
-struct NoneDiffBackend <: AbstractDiffBackend end
-
-"""
-    _derivative(f, t[, backend::AbstractDiffBackend])
-
-Compute the derivative of a callable `f` at time `t` computed using the given `backend`,
-an object of type [`AbstractDiffBackend`](@ref ManifoldDiff.AbstractDiffBackend). If the backend is not explicitly
+Compute the derivative of a callable `f` at time `t` computed using the given `backend`. If the backend is not explicitly
 specified, it is obtained using the function [`default_differential_backend`](@ref).
 
 This function calculates plain Euclidean derivatives, for Riemannian differentiation see
@@ -53,20 +51,14 @@ function _derivative end
 
 _derivative(f, t) = _derivative(f, t, default_differential_backend())
 
-function _derivative!(
-    f,
-    X,
-    t,
-    backend::AbstractDiffBackend = default_differential_backend(),
-)
+function _derivative!(f, X, t, backend = default_differential_backend())
     return copyto!(X, _derivative(f, t, backend))
 end
 
 """
-    _gradient(f, p[, backend::AbstractDiffBackend])
+    _gradient(f, p[, backend])
 
-Compute the gradient of a callable `f` at point `p` computed using the given `backend`,
-an object of type [`AbstractDiffBackend`](@ref ManifoldDiff.AbstractDiffBackend). If the backend is not explicitly
+Compute the gradient of a callable `f` at point `p` computed using the given `backend`. If the backend is not explicitly
 specified, it is obtained using the function [`default_differential_backend`](@ref).
 
 This function calculates plain Euclidean gradients, for Riemannian gradient calculation see
@@ -81,15 +73,14 @@ function _gradient end
 
 _gradient(f, p) = _gradient(f, p, default_differential_backend())
 
-function _gradient!(f, X, p, backend::AbstractDiffBackend = default_differential_backend())
+function _gradient!(f, X, p, backend = default_differential_backend())
     return copyto!(X, _gradient(f, p, backend))
 end
 
 """
-    _hessian(f, p[, backend::AbstractDiffBackend])
+    _hessian(f, p[, backend])
 
-Compute the Hessian of a callable `f` at point `p` computed using the given `backend`,
-an object of type [`AbstractDiffBackend`](@ref). If the backend is not explicitly
+Compute the Hessian of a callable `f` at point `p` computed using the given `backend`. If the backend is not explicitly
 specified, it is obtained using the function [`default_differential_backend`](@ref).
 
 This function calculates plain Euclidean Hessian.
@@ -104,10 +95,9 @@ function _hessian end
 _hessian(f, p) = _hessian(f, p, default_differential_backend())
 
 """
-    _jacobian(f, p[, backend::AbstractDiffBackend])
+    _jacobian(f, p[, backend])
 
-Compute the Jacobian of a callable `f` at point `p` computed using the given `backend`,
-an object of type [`AbstractDiffBackend`](@ref). If the backend is not explicitly
+Compute the Jacobian of a callable `f` at point `p` computed using the given `backend`. If the backend is not explicitly
 specified, it is obtained using the function [`default_differential_backend`](@ref).
 
 This function calculates plain Euclidean Jacobians, for Riemannian Jacobian calculation see
@@ -122,22 +112,22 @@ function _jacobian end
 
 _jacobian(f, p) = _jacobian(f, p, default_differential_backend())
 
-function _jacobian!(f, X, p, backend::AbstractDiffBackend = default_differential_backend())
+function _jacobian!(f, X, p, backend = default_differential_backend())
     return copyto!(X, _jacobian(f, p, backend))
 end
 
 """
-    CurrentDiffBackend(backend::AbstractDiffBackend)
+    CurrentDiffBackend(backend)
 
 A mutable struct for storing the current differentiation backend in a global
 constant [`_current_default_differential_backend`](@ref).
 
 # See also
 
-[`AbstractDiffBackend`](@ref), [`default_differential_backend`](@ref), [`set_default_differential_backend!`](@ref)
+[`default_differential_backend`](@ref), [`set_default_differential_backend!`](@ref)
 """
 mutable struct CurrentDiffBackend
-    backend::AbstractDiffBackend
+    backend::Any
 end
 
 """
@@ -148,22 +138,24 @@ differentiation backend.
 """
 const _current_default_differential_backend = CurrentDiffBackend(NoneDiffBackend())
 """
-    default_differential_backend() -> AbstractDiffBackend
+    default_differential_backend()
 
 Get the default differentiation backend.
 """
 default_differential_backend() = _current_default_differential_backend.backend
 
 """
-    set_default_differential_backend!(backend::AbstractDiffBackend)
+    set_default_differential_backend!(backend)
 
 Set current backend for differentiation to `backend`.
 """
-function set_default_differential_backend!(backend::AbstractDiffBackend)
+function set_default_differential_backend!(backend)
     _current_default_differential_backend.backend = backend
     return backend
 end
 
+include("differentiationinterface.jl")
+
 include("diagonalizing_projectors.jl")
 
 include("adjoint_differentials.jl")
@@ -183,44 +175,39 @@ include("embedded_diff.jl")
 function __init__()
     # There is likely no way to set defaults without Requires.jl
     @require FiniteDifferences = "26cc04aa-876d-5657-8c51-4c34ba976000" begin
+        using .FiniteDifferences: central_fdm
         if default_differential_backend() === NoneDiffBackend()
-            set_default_differential_backend!(FiniteDifferencesBackend()) #This expects a method in the inner ()?
+            set_default_differential_backend!(AutoFiniteDifferences(central_fdm(5, 1)))
         end
     end
 
     @require ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" begin
         if default_differential_backend() === NoneDiffBackend()
-            set_default_differential_backend!(ForwardDiffBackend())
+            set_default_differential_backend!(AutoForwardDiff())
         end
     end
 
     @require FiniteDiff = "6a86dc24-6348-571c-b903-95158fe2bd41" begin
         if default_differential_backend() === NoneDiffBackend()
-            set_default_differential_backend!(FiniteDiffBackend())
+            set_default_differential_backend!(AutoFiniteDiff())
         end
     end
 
     @require ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" begin
         if default_differential_backend() === NoneDiffBackend()
-            set_default_differential_backend!(ReverseDiffBackend())
+            set_default_differential_backend!(AutoReverseDiff())
         end
     end
 
     @require Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" begin
         if default_differential_backend() === NoneDiffBackend()
-            set_default_differential_backend!(ZygoteDiffBackend())
+            set_default_differential_backend!(AutoZygote())
         end
     end
 
     return nothing
 end
 
-include("finite_diff.jl")
-include("finite_differences.jl")
-include("forward_diff.jl")
-include("reverse_diff.jl")
-include("zygote.jl")
-
 export riemannian_gradient,
     riemannian_gradient!,
     riemannian_Hessian,
diff --git a/src/differentiationinterface.jl b/src/differentiationinterface.jl
new file mode 100644
index 0000000..6869102
--- /dev/null
+++ b/src/differentiationinterface.jl
@@ -0,0 +1,31 @@
+function ManifoldDiff._derivative(f, p, backend::AbstractADType)
+    return DI.derivative(f, backend, p)
+end
+
+function ManifoldDiff._derivative!(f, X, t, backend::AbstractADType)
+    return DI.derivative!(f, X, backend, t)
+end
+
+function ManifoldDiff._gradient(f, p, backend::AbstractADType)
+    return DI.gradient(f, backend, p)
+end
+
+function ManifoldDiff._gradient!(f, X, t, backend::AbstractADType)
+    return DI.gradient!(f, X, backend, t)
+end
+
+function ManifoldDiff._jacobian(f, p, backend::AbstractADType)
+    return DI.jacobian(f, backend, p)
+end
+
+function ManifoldDiff._jacobian!(f, X, p, backend::AbstractADType)
+    return DI.jacobian!(f, X, backend, p)
+end
+
+function ManifoldDiff._hessian(f, p, backend::AbstractADType)
+    return DI.hessian(f, backend, p)
+end
+
+# function ManifoldDiff._hessian!(f, X, p, backend::AbstractADType)
+#     return DI.hessian!(f, X, backend, p)
+# end
diff --git a/src/embedded_diff.jl b/src/embedded_diff.jl
index 0992c5d..8c8486e 100644
--- a/src/embedded_diff.jl
+++ b/src/embedded_diff.jl
@@ -1,5 +1,5 @@
 """
-    ExplicitEmbeddedBackend{TF<:NamedTuple} <: AbstractDiffBackend
+    ExplicitEmbeddedBackend{TF<:NamedTuple}
 
 A backend to use with the [`RiemannianProjectionBackend`](@ref) or the [`TangentDiffBackend`](@ref),
 when you have explicit formulae for the gradient in the embedding available.
@@ -16,7 +16,7 @@ where currently the following keywords may be used
 
 Note that the gradient functions are defined on the embedding manifold `M` passed to the Backend as well
 """
-struct ExplicitEmbeddedBackend{TM<:AbstractManifold,TF<:NamedTuple} <: AbstractDiffBackend
+struct ExplicitEmbeddedBackend{TM<:AbstractManifold,TF<:NamedTuple}
     manifold::TM
     functions::TF
 end
diff --git a/src/finite_diff.jl b/src/finite_diff.jl
deleted file mode 100644
index 6470635..0000000
--- a/src/finite_diff.jl
+++ /dev/null
@@ -1,15 +0,0 @@
-
-"""
-    FiniteDiffBackend <: AbstractDiffBackend
-
-A type to specify / use differentiation backend based on FiniteDiff.jl package.
-
-# Constructor
-
-    FiniteDiffBackend(method::Val{Symbol} = Val{:central})
-"""
-struct FiniteDiffBackend{TM<:Val} <: AbstractDiffBackend
-    method::TM
-end
-
-FiniteDiffBackend() = FiniteDiffBackend(Val(:central))
diff --git a/src/finite_differences.jl b/src/finite_differences.jl
deleted file mode 100644
index 63f21b3..0000000
--- a/src/finite_differences.jl
+++ /dev/null
@@ -1,8 +0,0 @@
-"""
-    FiniteDifferencesBackend(method::FiniteDifferenceMethod = central_fdm(5, 1))
-
-Differentiation backend based on the FiniteDifferences.jl package.
-"""
-struct FiniteDifferencesBackend{TM} <: AbstractDiffBackend
-    method::TM
-end
diff --git a/src/forward_diff.jl b/src/forward_diff.jl
deleted file mode 100644
index 9559d6c..0000000
--- a/src/forward_diff.jl
+++ /dev/null
@@ -1,7 +0,0 @@
-
-"""
-    ForwardDiffBackend <: AbstractDiffBackend
-
-Differentiation backend based on the ForwardDiff.jl package.
-"""
-struct ForwardDiffBackend <: AbstractDiffBackend end
diff --git a/src/reverse_diff.jl b/src/reverse_diff.jl
deleted file mode 100644
index 4eaa834..0000000
--- a/src/reverse_diff.jl
+++ /dev/null
@@ -1 +0,0 @@
-struct ReverseDiffBackend <: AbstractDiffBackend end
diff --git a/src/riemannian_diff.jl b/src/riemannian_diff.jl
index 02c0c9f..f2ee09e 100644
--- a/src/riemannian_diff.jl
+++ b/src/riemannian_diff.jl
@@ -7,8 +7,8 @@ An abstract type for backends for differentiation.
 abstract type AbstractRiemannianDiffBackend end
 
 @doc raw"""
-    differential(M::AbstractManifold, f, t::Real, backend::AbstractDiffBackend)
-    differential!(M::AbstractManifold, f, X, t::Real, backend::AbstractDiffBackend)
+    differential(M::AbstractManifold, f, t::Real, backend)
+    differential!(M::AbstractManifold, f, X, t::Real, backend)
 
 Compute the Riemannian differential of a curve $f: ℝ\to M$ on a manifold `M`
 represented by function `f` at time `t` using the given backend.
@@ -52,14 +52,13 @@ intrinsic differentiation scheme.
 Since it works in tangent spaces at argument and function value, methods might require a
 retraction and an inverse retraction as well as a basis.
 
-In the tangent space itself, this backend then employs an (Euclidean)
-[`AbstractDiffBackend`](@ref ManifoldDiff.AbstractDiffBackend)
+In the tangent space itself, this backend then employs a (Euclidean) backend.
 
 # Constructor
 
     TangentDiffBackend(diff_backend)
 
-where `diff_backend` is an [`AbstractDiffBackend`](@ref ManifoldDiff.AbstractDiffBackend) to be used on the tangent space.
+where `diff_backend` is a (Euclidean) backend to be used on the tangent space.
 
 With the keyword arguments
 
@@ -69,7 +68,7 @@ With the keyword arguments
 * `basis_val` an [AbstractBasis](https://juliamanifolds.github.io/ManifoldsBase.jl/stable/bases.html) (`DefaultOrthogonalBasis` by default)
 """
 struct TangentDiffBackend{
-    TAD<:AbstractDiffBackend,
+    TAD,
     TR<:AbstractRetractionMethod,
     TIR<:AbstractInverseRetractionMethod,
     TBarg<:AbstractBasis,
@@ -88,7 +87,7 @@ function TangentDiffBackend(
     basis_arg::TBarg = DefaultOrthonormalBasis(),
     basis_val::TBval = DefaultOrthonormalBasis(),
 ) where {
-    TAD<:AbstractDiffBackend,
+    TAD,
     TR<:AbstractRetractionMethod,
     TIR<:AbstractInverseRetractionMethod,
     TBarg<:AbstractBasis,
@@ -193,8 +192,7 @@ Then we require three tools
 
 see also [`riemannian_gradient`](@ref) and [AbsilMahonySepulchre:2008](@cite), Section 3.6.1 for a derivation on submanifolds.
 """
-struct RiemannianProjectionBackend{TADBackend<:AbstractDiffBackend} <:
-       AbstractRiemannianDiffBackend
+struct RiemannianProjectionBackend{TADBackend} <: AbstractRiemannianDiffBackend
     diff_backend::TADBackend
 end
 
diff --git a/src/zygote.jl b/src/zygote.jl
deleted file mode 100644
index 5ce6f84..0000000
--- a/src/zygote.jl
+++ /dev/null
@@ -1 +0,0 @@
-struct ZygoteDiffBackend <: AbstractDiffBackend end
diff --git a/test/differentiation.jl b/test/differentiation.jl
index 68c3268..ea0b80a 100644
--- a/test/differentiation.jl
+++ b/test/differentiation.jl
@@ -24,81 +24,80 @@ using ManifoldDiff: ExplicitEmbeddedBackend
 
 import ManifoldDiff: gradient
 
+using ADTypes
+
 struct TestRiemannianBackend <: AbstractRiemannianDiffBackend end
 function ManifoldDiff.gradient(::AbstractManifold, f, p, ::TestRiemannianBackend)
     return collect(1.0:length(p))
 end
 
-using FiniteDifferences
+using FiniteDifferences: central_fdm
 using LinearAlgebra: Diagonal, dot
 
 @testset "Differentiation backend" begin
-    fd51 = ManifoldDiff.FiniteDifferencesBackend()
+    fd51 = AutoFiniteDifferences(central_fdm(5, 1))
     @testset "default_differential_backend" begin
         #ForwardDiff is loaded first utils.
-        @test default_differential_backend() === ManifoldDiff.ForwardDiffBackend()
+        @test default_differential_backend() isa AutoForwardDiff
 
-        @test length(fd51.method.grid) == 5
+        @test length(fd51.fdm.grid) == 5
         # check method order
-        @test typeof(fd51.method).parameters[2] == 1
-        fd71 = ManifoldDiff.FiniteDifferencesBackend(central_fdm(7, 1))
+        @test typeof(fd51.fdm).parameters[2] == 1
+        fd71 = AutoFiniteDifferences(central_fdm(7, 1))
         @test set_default_differential_backend!(fd71) == fd71
         @test default_differential_backend() == fd71
     end
 
-    using ForwardDiff
+    using ForwardDiff: ForwardDiff
 
-    fwd_diff = ManifoldDiff.ForwardDiffBackend()
+    fwd_diff = AutoForwardDiff()
     @testset "ForwardDiff" begin
-        @test default_differential_backend() isa ManifoldDiff.FiniteDifferencesBackend
+        @test default_differential_backend() isa AutoFiniteDifferences
 
         @test set_default_differential_backend!(fwd_diff) == fwd_diff
         @test default_differential_backend() == fwd_diff
-        @test set_default_differential_backend!(fd51) isa
-              ManifoldDiff.FiniteDifferencesBackend
-        @test default_differential_backend() isa ManifoldDiff.FiniteDifferencesBackend
+        @test set_default_differential_backend!(fd51) isa AutoFiniteDifferences
+        @test default_differential_backend() isa AutoFiniteDifferences
 
         set_default_differential_backend!(fwd_diff)
         @test default_differential_backend() == fwd_diff
         set_default_differential_backend!(fd51)
     end
 
-    using FiniteDiff
+    using FiniteDiff: FiniteDiff
 
-    finite_diff = ManifoldDiff.FiniteDiffBackend()
+    finite_diff = AutoFiniteDiff()
     @testset "FiniteDiff" begin
-        @test default_differential_backend() isa ManifoldDiff.FiniteDifferencesBackend
+        @test default_differential_backend() isa AutoFiniteDifferences
 
         @test set_default_differential_backend!(finite_diff) == finite_diff
         @test default_differential_backend() == finite_diff
-        @test set_default_differential_backend!(fd51) isa
-              ManifoldDiff.FiniteDifferencesBackend
-        @test default_differential_backend() isa ManifoldDiff.FiniteDifferencesBackend
+        @test set_default_differential_backend!(fd51) isa AutoFiniteDifferences
+        @test default_differential_backend() isa AutoFiniteDifferences
 
         set_default_differential_backend!(finite_diff)
         @test default_differential_backend() == finite_diff
         set_default_differential_backend!(fd51)
     end
 
-    using ReverseDiff
+    using ReverseDiff: ReverseDiff
 
-    reverse_diff = ManifoldDiff.ReverseDiffBackend()
+    reverse_diff = AutoReverseDiff()
     @testset "ReverseDiff" begin
-        @test default_differential_backend() isa ManifoldDiff.FiniteDifferencesBackend
+        @test default_differential_backend() isa AutoFiniteDifferences
 
         @test set_default_differential_backend!(reverse_diff) == reverse_diff
         @test default_differential_backend() == reverse_diff
-        @test set_default_differential_backend!(fd51) isa
-              ManifoldDiff.FiniteDifferencesBackend
-        @test default_differential_backend() isa ManifoldDiff.FiniteDifferencesBackend
+        @test set_default_differential_backend!(fd51) isa AutoFiniteDifferences
+        @test default_differential_backend() isa AutoFiniteDifferences
 
         set_default_differential_backend!(reverse_diff)
         @test default_differential_backend() == reverse_diff
         set_default_differential_backend!(fd51)
     end
 
-    using Zygote
-    zygote_diff = ManifoldDiff.ZygoteDiffBackend()
+    using Zygote: Zygote
+    zygote_diff = AutoZygote()
 
     @testset "gradient" begin
         set_default_differential_backend!(fd51)
@@ -115,40 +114,40 @@ using LinearAlgebra: Diagonal, dot
 
         @testset "Inference" begin
             X = [-1.0, -1.0]
-            @test (@inferred _derivative(c1, 0.0, ManifoldDiff.ForwardDiffBackend())) ≈
-                  [1.0, 0.0]
-            @test (@inferred _derivative!(
-                c1,
-                X,
-                0.0,
-                ManifoldDiff.ForwardDiffBackend(),
-            )) === X
+            @test (@inferred _derivative(c1, 0.0, AutoForwardDiff())) ≈ [1.0, 0.0]
+            @test (@inferred _derivative!(c1, X, 0.0, AutoForwardDiff())) === X
             @test X ≈ [1.0, 0.0]
 
             @test (@inferred _derivative(c1, 0.0, finite_diff)) ≈ [1.0, 0.0]
             @test (@inferred _gradient(f1, [1.0, -1.0], finite_diff)) ≈ [1.0, -2.0]
         end
 
-        @testset for backend in [fd51, fwd_diff, finite_diff]
+        @testset "$(nameof(typeof(backend)))" for backend in [fd51, fwd_diff, finite_diff]
             set_default_differential_backend!(backend)
             @test _derivative(c1, 0.0) ≈ [1.0, 0.0]
             X = [-1.0, -1.0]
             @test _derivative!(c1, X, 0.0) === X
             @test isapprox(X, [1.0, 0.0])
         end
-        @testset for backend in [fd51, fwd_diff, finite_diff, reverse_diff, zygote_diff]
+        @testset "$(nameof(typeof(backend)))" for backend in [
+            fd51,
+            fwd_diff,
+            finite_diff,
+            reverse_diff,
+            zygote_diff,
+        ]
             set_default_differential_backend!(backend)
             X = [-1.0, -1.0]
             @test _gradient(f1, [1.0, -1.0]) ≈ [1.0, -2.0]
             @test _gradient!(f1, X, [1.0, -1.0]) === X
             @test X ≈ [1.0, -2.0]
         end
-        @testset for backend in [finite_diff]
+        @testset "$(nameof(typeof(backend)))" for backend in [finite_diff]
             set_default_differential_backend!(backend)
             X = [-0.0 -0.0]
-            @test _jacobian(f1, [1.0, -1.0]) ≈ [1.0 -2.0]
+            @test_broken _jacobian(f1, [1.0, -1.0]) ≈ [1.0 -2.0]  # scalar output??
             # The following seems not to work for :central, but it does for forward
-            fdf = ManifoldDiff.FiniteDiffBackend(Val(:forward))
+            fdf = AutoFiniteDiff()
             @test_broken _jacobian!(f1!, X, [1.0, -1.0], fdf) === X
             @test_broken X ≈ [1.0 -2.0]
         end
@@ -159,7 +158,7 @@ using LinearAlgebra: Diagonal, dot
         _jacobian!(c1, jac, 0.0, fd51)
         @test jac ≈ [1.0; 0.0]
 
-        @testset for backend in [fd51, ManifoldDiff.ForwardDiffBackend()]
+        @testset "$(nameof(typeof(backend)))" for backend in [fd51, AutoForwardDiff()]
             @test _derivative(c1, 0.0, backend) ≈ [1.0, 0.0]
             @test _gradient(f1, [1.0, -1.0], backend) ≈ [1.0, -2.0]
         end
@@ -176,11 +175,11 @@ rb_onb_default = TangentDiffBackend(
     DefaultOrthonormalBasis(),
 )
 
-rb_onb_fd51 = TangentDiffBackend(ManifoldDiff.FiniteDifferencesBackend())
+rb_onb_fd51 = TangentDiffBackend(AutoFiniteDifferences(central_fdm(5, 1)))
 
-rb_onb_fwd_diff = TangentDiffBackend(ManifoldDiff.ForwardDiffBackend())
+rb_onb_fwd_diff = TangentDiffBackend(AutoForwardDiff())
 
-rb_onb_finite_diff = TangentDiffBackend(ManifoldDiff.FiniteDiffBackend())
+rb_onb_finite_diff = TangentDiffBackend(AutoFiniteDiff())
 
 rb_onb_default2 = TangentDiffBackend(
     default_differential_backend();
diff --git a/test/runtests.jl b/test/runtests.jl
index 276eedb..6927ed2 100644
--- a/test/runtests.jl
+++ b/test/runtests.jl
@@ -2,8 +2,8 @@
 using Test
 using LinearAlgebra
 using ManifoldDiff
-using ForwardDiff
-using FiniteDifferences
+using ForwardDiff: ForwardDiff
+using FiniteDifferences: FiniteDifferences
 using Manifolds
 using ManifoldsBase
 using RecursiveArrayTools
diff --git a/test/test_jacobians.jl b/test/test_jacobians.jl
index e6cfd63..c95e238 100644
--- a/test/test_jacobians.jl
+++ b/test/test_jacobians.jl
@@ -1,5 +1,5 @@
 using Manifolds, ManifoldsBase, ManifoldDiff, Test
-using FiniteDifferences
+using FiniteDifferences: FiniteDifferences
 
 function finitedifferences_jacobian(
     M_arg::AbstractManifold,