From 9924ee993c8a6a3040bd6c2bced6b7c6ff2299fd Mon Sep 17 00:00:00 2001
From: Avik Pal <avikpal@mit.edu>
Date: Wed, 13 Aug 2025 19:11:24 -0400
Subject: [PATCH 01/12] fix: regression in non-fast scalar indexing support

---
 Project.toml                       |  8 +++++--
 ext/ForwardDiffGPUArraysCoreExt.jl | 36 ++++++++++++++++++++++++++++++
 test/JacobianTest.jl               | 14 ++++++++++++
 3 files changed, 56 insertions(+), 2 deletions(-)
 create mode 100644 ext/ForwardDiffGPUArraysCoreExt.jl

diff --git a/Project.toml b/Project.toml
index 9eb2914c..abbf186c 100644
--- a/Project.toml
+++ b/Project.toml
@@ -1,6 +1,6 @@
 name = "ForwardDiff"
 uuid = "f6369f11-7733-5829-9624-2563aa707210"
-version = "1.0.1"
+version = "1.0.2"
 
 [deps]
 CommonSubexpressions = "bbf7d656-a473-5ed7-a52c-81e309532950"
@@ -15,9 +15,11 @@ Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b"
 
 [weakdeps]
+GPUArraysCore = "46192b85-c4d5-4398-a991-12ede77f4527"
 StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 
 [extensions]
+ForwardDiffGPUArraysCoreExt = "GPUArraysCore"
 ForwardDiffStaticArraysExt = "StaticArrays"
 
 [compat]
@@ -26,6 +28,7 @@ CommonSubexpressions = "0.3"
 DiffResults = "1.1"
 DiffRules = "1.4"
 DiffTests = "0.1"
+GPUArraysCore = "0.2"
 IrrationalConstants = "0.1, 0.2"
 LogExpFunctions = "0.3"
 NaNMath = "1"
@@ -39,9 +42,10 @@ Calculus = "49dc2e85-a5d0-5ad3-a950-438e2897f1b9"
 DiffTests = "de460e47-3fe3-5279-bb4a-814414816d5d"
 InteractiveUtils = "b77e0a4c-d291-57a0-90e8-8db25a27a240"
 IrrationalConstants = "92d709cd-6900-40b7-9082-c6be49f344b6"
+JLArrays = "27aeb0d3-9eb9-45fb-866b-73c2ecf80fcb"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [targets]
-test = ["Calculus", "DiffTests", "IrrationalConstants", "SparseArrays", "StaticArrays", "Test", "InteractiveUtils"]
+test = ["Calculus", "DiffTests", "IrrationalConstants", "SparseArrays", "StaticArrays", "Test", "InteractiveUtils", "JLArrays"]
diff --git a/ext/ForwardDiffGPUArraysCoreExt.jl b/ext/ForwardDiffGPUArraysCoreExt.jl
new file mode 100644
index 00000000..c4a1a2d2
--- /dev/null
+++ b/ext/ForwardDiffGPUArraysCoreExt.jl
@@ -0,0 +1,36 @@
+module ForwardDiffGPUArraysCoreExt
+
+using GPUArraysCore: AbstractGPUArray
+using ForwardDiff: ForwardDiff, Dual, Partials
+
+function ForwardDiff.seed!(duals::AbstractGPUArray{Dual{T,V,N}}, x,
+                           seed::Partials{N,V} = zero(Partials{N,V})) where {T,V,N}
+    idxs = ForwardDiff.structural_eachindex(duals, x)
+    duals[idxs] .= Dual{T,V,N}.(x[idxs], seed)
+    return duals
+end
+
+function ForwardDiff.seed!(duals::AbstractGPUArray{Dual{T,V,N}}, x,
+                           seeds::NTuple{N,Partials{N,V}}) where {T,V,N}
+    idxs = ForwardDiff.structural_eachindex(duals, x)
+    duals[idxs] .= Dual{T,V,N}.(x[idxs], seeds[1:N])
+    return duals
+end
+
+function ForwardDiff.seed!(duals::AbstractGPUArray{Dual{T,V,N}}, x, index,
+                           seed::Partials{N,V} = zero(Partials{N,V})) where {T,V,N}
+    offset = index - 1
+    idxs = Iterators.drop(ForwardDiff.structural_eachindex(duals, x), offset)
+    duals[idxs] .= Dual{T,V,N}.(x[idxs], seed)
+    return duals
+end
+
+function ForwardDiff.seed!(duals::AbstractGPUArray{Dual{T,V,N}}, x, index,
+                           seeds::NTuple{N,Partials{N,V}}, chunksize = N) where {T,V,N}
+    offset = index - 1
+    idxs = Iterators.drop(ForwardDiff.structural_eachindex(duals, x), offset)
+    duals[idxs] .= Dual{T,V,N}.(x[idxs], seeds[1:chunksize])
+    return duals
+end
+
+end
diff --git a/test/JacobianTest.jl b/test/JacobianTest.jl
index 1e52f7fa..865503b5 100644
--- a/test/JacobianTest.jl
+++ b/test/JacobianTest.jl
@@ -8,6 +8,7 @@ using ForwardDiff: Dual, Tag, JacobianConfig
 using StaticArrays
 using DiffTests
 using LinearAlgebra
+using JLArrays
 
 include(joinpath(dirname(@__FILE__), "utils.jl"))
 
@@ -279,4 +280,17 @@ end
     end
 end
 
+@testset "GPUArraysCore" begin
+    f(x) = x .^ 2 ./ 2
+
+    x = [1.0, 2.0, 3.0]
+    x_jl = JLArray(x)
+
+    jac = ForwardDiff.jacobian(f, x)
+    jac_jl = ForwardDiff.jacobian(f, x_jl)
+
+    @test jac_jl isa JLArray
+    @test Array(jac_jl) ≈ jac
+end
+
 end # module

From be6f8071e773458831c6a06d1f81ec6489390d18 Mon Sep 17 00:00:00 2001
From: Avik Pal <avikpal@mit.edu>
Date: Wed, 13 Aug 2025 19:14:18 -0400
Subject: [PATCH 02/12] fix: project toml for julia pre 1.9

---
 Project.toml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Project.toml b/Project.toml
index abbf186c..94ab0cd8 100644
--- a/Project.toml
+++ b/Project.toml
@@ -40,6 +40,7 @@ julia = "1.10"
 [extras]
 Calculus = "49dc2e85-a5d0-5ad3-a950-438e2897f1b9"
 DiffTests = "de460e47-3fe3-5279-bb4a-814414816d5d"
+GPUArraysCore = "46192b85-c4d5-4398-a991-12ede77f4527"
 InteractiveUtils = "b77e0a4c-d291-57a0-90e8-8db25a27a240"
 IrrationalConstants = "92d709cd-6900-40b7-9082-c6be49f344b6"
 JLArrays = "27aeb0d3-9eb9-45fb-866b-73c2ecf80fcb"

From 7957a9484197758f59106e3e0b8c6e0da0d15286 Mon Sep 17 00:00:00 2001
From: Avik Pal <avikpal@mit.edu>
Date: Wed, 13 Aug 2025 19:39:29 -0400
Subject: [PATCH 03/12] fix: support gradient + more test coverage

---
 Project.toml                       |  1 +
 ext/ForwardDiffGPUArraysCoreExt.jl | 40 ++++++++++++++++++++++++------
 test/GradientTest.jl               | 22 ++++++++++++++++
 3 files changed, 56 insertions(+), 7 deletions(-)

diff --git a/Project.toml b/Project.toml
index 94ab0cd8..b3cf9981 100644
--- a/Project.toml
+++ b/Project.toml
@@ -6,6 +6,7 @@ version = "1.0.2"
 CommonSubexpressions = "bbf7d656-a473-5ed7-a52c-81e309532950"
 DiffResults = "163ba53b-c6d8-5494-b064-1a9d43ac40c5"
 DiffRules = "b552c78f-8df3-52c6-915a-8e097449b14b"
+GPUArraysCore = "46192b85-c4d5-4398-a991-12ede77f4527"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 LogExpFunctions = "2ab3a3ac-af41-5b50-aa03-7779005ae688"
 NaNMath = "77ba4419-2d1f-58cd-9bb1-8ffee604a2e3"
diff --git a/ext/ForwardDiffGPUArraysCoreExt.jl b/ext/ForwardDiffGPUArraysCoreExt.jl
index c4a1a2d2..ddad7cd2 100644
--- a/ext/ForwardDiffGPUArraysCoreExt.jl
+++ b/ext/ForwardDiffGPUArraysCoreExt.jl
@@ -1,18 +1,18 @@
 module ForwardDiffGPUArraysCoreExt
 
 using GPUArraysCore: AbstractGPUArray
-using ForwardDiff: ForwardDiff, Dual, Partials
+using ForwardDiff: ForwardDiff, Dual, Partials, npartials, partials
 
 function ForwardDiff.seed!(duals::AbstractGPUArray{Dual{T,V,N}}, x,
                            seed::Partials{N,V} = zero(Partials{N,V})) where {T,V,N}
-    idxs = ForwardDiff.structural_eachindex(duals, x)
-    duals[idxs] .= Dual{T,V,N}.(x[idxs], seed)
+    idxs = collect(ForwardDiff.structural_eachindex(duals, x))
+    duals[idxs] .= Dual{T,V,N}.(x[idxs], Ref(seed))
     return duals
 end
 
 function ForwardDiff.seed!(duals::AbstractGPUArray{Dual{T,V,N}}, x,
                            seeds::NTuple{N,Partials{N,V}}) where {T,V,N}
-    idxs = ForwardDiff.structural_eachindex(duals, x)
+    idxs = collect(ForwardDiff.structural_eachindex(duals, x))[1:N]
     duals[idxs] .= Dual{T,V,N}.(x[idxs], seeds[1:N])
     return duals
 end
@@ -20,17 +20,43 @@ end
 function ForwardDiff.seed!(duals::AbstractGPUArray{Dual{T,V,N}}, x, index,
                            seed::Partials{N,V} = zero(Partials{N,V})) where {T,V,N}
     offset = index - 1
-    idxs = Iterators.drop(ForwardDiff.structural_eachindex(duals, x), offset)
-    duals[idxs] .= Dual{T,V,N}.(x[idxs], seed)
+    idxs = collect(Iterators.drop(ForwardDiff.structural_eachindex(duals, x), offset))
+    duals[idxs] .= Dual{T,V,N}.(x[idxs], Ref(seed))
     return duals
 end
 
 function ForwardDiff.seed!(duals::AbstractGPUArray{Dual{T,V,N}}, x, index,
                            seeds::NTuple{N,Partials{N,V}}, chunksize = N) where {T,V,N}
     offset = index - 1
-    idxs = Iterators.drop(ForwardDiff.structural_eachindex(duals, x), offset)
+    idxs = collect(
+        Iterators.drop(ForwardDiff.structural_eachindex(duals, x), offset)
+    )[1:chunksize]
     duals[idxs] .= Dual{T,V,N}.(x[idxs], seeds[1:chunksize])
     return duals
 end
 
+# gradient
+function ForwardDiff.extract_gradient!(::Type{T}, result::AbstractGPUArray,
+                                       dual::Dual) where {T}
+    # this closure is needed for gpu compilation
+    partial_fn(dual, i) = partials(T, dual, i)
+
+    idxs = ForwardDiff.structural_eachindex(result)
+    result[idxs] .= partial_fn.(Ref(dual), 1:npartials(dual))
+    return result
+end
+
+function ForwardDiff.extract_gradient_chunk!(::Type{T}, result::AbstractGPUArray, dual,
+                                             index, chunksize) where {T}
+    # this closure is needed for gpu compilation
+    partial_fn(dual, i) = partials(T, dual, i)
+
+    offset = index - 1
+    idxs = collect(
+        Iterators.drop(ForwardDiff.structural_eachindex(result), offset)
+    )[1:chunksize]
+    result[idxs] .= partial_fn.(Ref(dual), 1:chunksize)
+    return result
+end
+
 end
diff --git a/test/GradientTest.jl b/test/GradientTest.jl
index 4f46c167..5c2c0938 100644
--- a/test/GradientTest.jl
+++ b/test/GradientTest.jl
@@ -9,6 +9,7 @@ using ForwardDiff
 using ForwardDiff: Dual, Tag
 using StaticArrays
 using DiffTests
+using JLArrays
 
 include(joinpath(dirname(@__FILE__), "utils.jl"))
 
@@ -255,4 +256,25 @@ end
     end
 end
 
+@testset "GPUArraysCore" begin
+    fn(x) = sum(x .^ 2 ./ 2)
+
+    x = [1.0, 2.0, 3.0]
+    x_jl = JLArray(x)
+
+    grad = ForwardDiff.gradient(fn, x)
+    grad_jl = ForwardDiff.gradient(fn, x_jl)
+
+    @test grad_jl isa JLArray
+    @test Array(grad_jl) ≈ grad
+
+    cfg = ForwardDiff.GradientConfig(
+        fn, x_jl, ForwardDiff.Chunk{2}(), ForwardDiff.Tag(fn, eltype(x))
+    )
+    grad_jl = ForwardDiff.gradient(fn, x_jl, cfg)
+
+    @test grad_jl isa JLArray
+    @test Array(grad_jl) ≈ grad
+end
+
 end # module

From b7d501989c86bb6c62e139481cefe8c3e486ff18 Mon Sep 17 00:00:00 2001
From: Avik Pal <avikpal@mit.edu>
Date: Wed, 13 Aug 2025 19:40:36 -0400
Subject: [PATCH 04/12] chore: relax version

---
 Project.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Project.toml b/Project.toml
index b3cf9981..933d951c 100644
--- a/Project.toml
+++ b/Project.toml
@@ -29,7 +29,7 @@ CommonSubexpressions = "0.3"
 DiffResults = "1.1"
 DiffRules = "1.4"
 DiffTests = "0.1"
-GPUArraysCore = "0.2"
+GPUArraysCore = "0.1, 0.2"
 IrrationalConstants = "0.1, 0.2"
 LogExpFunctions = "0.3"
 NaNMath = "1"

From eec599fe39ddf9d5eb529076cf0ef673cdb64aa2 Mon Sep 17 00:00:00 2001
From: Avik Pal <avikpal@mit.edu>
Date: Fri, 15 Aug 2025 20:33:19 -0400
Subject: [PATCH 05/12] chore: remove 1.6 support and bump min version to 1.10

---
 Project.toml | 1 -
 1 file changed, 1 deletion(-)

diff --git a/Project.toml b/Project.toml
index 933d951c..77913d55 100644
--- a/Project.toml
+++ b/Project.toml
@@ -6,7 +6,6 @@ version = "1.0.2"
 CommonSubexpressions = "bbf7d656-a473-5ed7-a52c-81e309532950"
 DiffResults = "163ba53b-c6d8-5494-b064-1a9d43ac40c5"
 DiffRules = "b552c78f-8df3-52c6-915a-8e097449b14b"
-GPUArraysCore = "46192b85-c4d5-4398-a991-12ede77f4527"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 LogExpFunctions = "2ab3a3ac-af41-5b50-aa03-7779005ae688"
 NaNMath = "77ba4419-2d1f-58cd-9bb1-8ffee604a2e3"

From 6d608d1e85bbd739bd73e21d3980081172d40117 Mon Sep 17 00:00:00 2001
From: Avik Pal <avik.pal.2017@gmail.com>
Date: Fri, 15 Aug 2025 20:35:41 -0400
Subject: [PATCH 06/12] fix: apply suggestions from code review

Co-authored-by: David Widmann <devmotion@users.noreply.github.com>
---
 ext/ForwardDiffGPUArraysCoreExt.jl | 36 +++++++++++++++++-------------
 1 file changed, 21 insertions(+), 15 deletions(-)

diff --git a/ext/ForwardDiffGPUArraysCoreExt.jl b/ext/ForwardDiffGPUArraysCoreExt.jl
index ddad7cd2..1f8856e9 100644
--- a/ext/ForwardDiffGPUArraysCoreExt.jl
+++ b/ext/ForwardDiffGPUArraysCoreExt.jl
@@ -4,34 +4,37 @@ using GPUArraysCore: AbstractGPUArray
 using ForwardDiff: ForwardDiff, Dual, Partials, npartials, partials
 
 function ForwardDiff.seed!(duals::AbstractGPUArray{Dual{T,V,N}}, x,
-                           seed::Partials{N,V} = zero(Partials{N,V})) where {T,V,N}
+                           seed::Partials{N,V}) where {T,V,N}
     idxs = collect(ForwardDiff.structural_eachindex(duals, x))
-    duals[idxs] .= Dual{T,V,N}.(x[idxs], Ref(seed))
+    duals[idxs] .= Dual{T,V,N}.(view(x, idxs), Ref(seed))
     return duals
 end
 
 function ForwardDiff.seed!(duals::AbstractGPUArray{Dual{T,V,N}}, x,
                            seeds::NTuple{N,Partials{N,V}}) where {T,V,N}
-    idxs = collect(ForwardDiff.structural_eachindex(duals, x))[1:N]
-    duals[idxs] .= Dual{T,V,N}.(x[idxs], seeds[1:N])
+    idxs = collect(Iterators.take(ForwardDiff.structural_eachindex(duals, x), N))
+    duals[idxs] .= Dual{T,V,N}.(view(x, idxs), getindex.(Ref(seeds), 1:length(idxs)))
     return duals
 end
 
 function ForwardDiff.seed!(duals::AbstractGPUArray{Dual{T,V,N}}, x, index,
-                           seed::Partials{N,V} = zero(Partials{N,V})) where {T,V,N}
+                           seed::Partials{N,V}) where {T,V,N}
     offset = index - 1
     idxs = collect(Iterators.drop(ForwardDiff.structural_eachindex(duals, x), offset))
-    duals[idxs] .= Dual{T,V,N}.(x[idxs], Ref(seed))
+    duals[idxs] .= Dual{T,V,N}.(view(x, idxs), Ref(seed))
     return duals
 end
 
 function ForwardDiff.seed!(duals::AbstractGPUArray{Dual{T,V,N}}, x, index,
-                           seeds::NTuple{N,Partials{N,V}}, chunksize = N) where {T,V,N}
+                           seeds::NTuple{N,Partials{N,V}}, chunksize) where {T,V,N}
     offset = index - 1
     idxs = collect(
-        Iterators.drop(ForwardDiff.structural_eachindex(duals, x), offset)
-    )[1:chunksize]
-    duals[idxs] .= Dual{T,V,N}.(x[idxs], seeds[1:chunksize])
+        Iterators.take(
+            Iterators.drop(ForwardDiff.structural_eachindex(duals, x), offset),
+            chunksize,
+        ),
+    )
+    duals[idxs] .= Dual{T,V,N}.(view(x, idxs), getindex.(Ref(seeds), 1:length(idxs)))
     return duals
 end
 
@@ -41,8 +44,8 @@ function ForwardDiff.extract_gradient!(::Type{T}, result::AbstractGPUArray,
     # this closure is needed for gpu compilation
     partial_fn(dual, i) = partials(T, dual, i)
 
-    idxs = ForwardDiff.structural_eachindex(result)
-    result[idxs] .= partial_fn.(Ref(dual), 1:npartials(dual))
+    idxs = collect(Iterators.take(ForwardDiff.structural_eachindex(result), npartials(dual)))
+    result[idxs] .= partial_fn.(Ref(dual), 1:length(idxs))
     return result
 end
 
@@ -53,9 +56,12 @@ function ForwardDiff.extract_gradient_chunk!(::Type{T}, result::AbstractGPUArray
 
     offset = index - 1
     idxs = collect(
-        Iterators.drop(ForwardDiff.structural_eachindex(result), offset)
-    )[1:chunksize]
-    result[idxs] .= partial_fn.(Ref(dual), 1:chunksize)
+        Iterators.take(
+                    Iterators.drop(ForwardDiff.structural_eachindex(result), offset),
+            chunksize,
+        )
+    )
+    result[idxs] .= partial_fn.(Ref(dual), 1:length(idxs))
     return result
 end
 

From e9e44325e3c7ac7f3393970523bcbcaa9e8ca42a Mon Sep 17 00:00:00 2001
From: Avik Pal <avikpal@mit.edu>
Date: Fri, 15 Aug 2025 20:39:13 -0400
Subject: [PATCH 07/12] fix: use a struct instead of closure

---
 ext/ForwardDiffGPUArraysCoreExt.jl | 19 +++++++++++--------
 1 file changed, 11 insertions(+), 8 deletions(-)

diff --git a/ext/ForwardDiffGPUArraysCoreExt.jl b/ext/ForwardDiffGPUArraysCoreExt.jl
index 1f8856e9..e4db766e 100644
--- a/ext/ForwardDiffGPUArraysCoreExt.jl
+++ b/ext/ForwardDiffGPUArraysCoreExt.jl
@@ -3,6 +3,13 @@ module ForwardDiffGPUArraysCoreExt
 using GPUArraysCore: AbstractGPUArray
 using ForwardDiff: ForwardDiff, Dual, Partials, npartials, partials
 
+struct PartialsFn{T,D<:Dual}
+    dual::D
+end
+PartialsFn{T}(dual::Dual) where {T} = PartialsFn{T,typeof(dual)}(dual)
+
+(f::PartialsFn{T})(i) where {T} = partials(T, f.dual, i)
+
 function ForwardDiff.seed!(duals::AbstractGPUArray{Dual{T,V,N}}, x,
                            seed::Partials{N,V}) where {T,V,N}
     idxs = collect(ForwardDiff.structural_eachindex(duals, x))
@@ -41,19 +48,15 @@ end
 # gradient
 function ForwardDiff.extract_gradient!(::Type{T}, result::AbstractGPUArray,
                                        dual::Dual) where {T}
-    # this closure is needed for gpu compilation
-    partial_fn(dual, i) = partials(T, dual, i)
-
+    fn = PartialsFn{T}(dual)
     idxs = collect(Iterators.take(ForwardDiff.structural_eachindex(result), npartials(dual)))
-    result[idxs] .= partial_fn.(Ref(dual), 1:length(idxs))
+    result[idxs] .= fn.(1:length(idxs))
     return result
 end
 
 function ForwardDiff.extract_gradient_chunk!(::Type{T}, result::AbstractGPUArray, dual,
                                              index, chunksize) where {T}
-    # this closure is needed for gpu compilation
-    partial_fn(dual, i) = partials(T, dual, i)
-
+    fn = PartialsFn{T}(dual)
     offset = index - 1
     idxs = collect(
         Iterators.take(
@@ -61,7 +64,7 @@ function ForwardDiff.extract_gradient_chunk!(::Type{T}, result::AbstractGPUArray
             chunksize,
         )
     )
-    result[idxs] .= partial_fn.(Ref(dual), 1:length(idxs))
+    result[idxs] .= fn.(1:length(idxs))
     return result
 end
 

From a5b5298d38ee9d6395bbae8b38233c80fa1ea54b Mon Sep 17 00:00:00 2001
From: Avik Pal <avikpal@mit.edu>
Date: Fri, 15 Aug 2025 20:48:41 -0400
Subject: [PATCH 08/12] fix: sizecheck

---
 ext/ForwardDiffGPUArraysCoreExt.jl | 16 ++++++----------
 1 file changed, 6 insertions(+), 10 deletions(-)

diff --git a/ext/ForwardDiffGPUArraysCoreExt.jl b/ext/ForwardDiffGPUArraysCoreExt.jl
index e4db766e..bf63da00 100644
--- a/ext/ForwardDiffGPUArraysCoreExt.jl
+++ b/ext/ForwardDiffGPUArraysCoreExt.jl
@@ -10,6 +10,8 @@ PartialsFn{T}(dual::Dual) where {T} = PartialsFn{T,typeof(dual)}(dual)
 
 (f::PartialsFn{T})(i) where {T} = partials(T, f.dual, i)
 
+_take(itr, N::Integer) = Iterators.take(itr, min(length(itr), N))
+
 function ForwardDiff.seed!(duals::AbstractGPUArray{Dual{T,V,N}}, x,
                            seed::Partials{N,V}) where {T,V,N}
     idxs = collect(ForwardDiff.structural_eachindex(duals, x))
@@ -19,7 +21,7 @@ end
 
 function ForwardDiff.seed!(duals::AbstractGPUArray{Dual{T,V,N}}, x,
                            seeds::NTuple{N,Partials{N,V}}) where {T,V,N}
-    idxs = collect(Iterators.take(ForwardDiff.structural_eachindex(duals, x), N))
+    idxs = collect(_take(ForwardDiff.structural_eachindex(duals, x), N))
     duals[idxs] .= Dual{T,V,N}.(view(x, idxs), getindex.(Ref(seeds), 1:length(idxs)))
     return duals
 end
@@ -36,10 +38,7 @@ function ForwardDiff.seed!(duals::AbstractGPUArray{Dual{T,V,N}}, x, index,
                            seeds::NTuple{N,Partials{N,V}}, chunksize) where {T,V,N}
     offset = index - 1
     idxs = collect(
-        Iterators.take(
-            Iterators.drop(ForwardDiff.structural_eachindex(duals, x), offset),
-            chunksize,
-        ),
+        _take(Iterators.drop(ForwardDiff.structural_eachindex(duals, x), offset), chunksize)
     )
     duals[idxs] .= Dual{T,V,N}.(view(x, idxs), getindex.(Ref(seeds), 1:length(idxs)))
     return duals
@@ -49,7 +48,7 @@ end
 function ForwardDiff.extract_gradient!(::Type{T}, result::AbstractGPUArray,
                                        dual::Dual) where {T}
     fn = PartialsFn{T}(dual)
-    idxs = collect(Iterators.take(ForwardDiff.structural_eachindex(result), npartials(dual)))
+    idxs = collect(_take(ForwardDiff.structural_eachindex(result), npartials(dual)))
     result[idxs] .= fn.(1:length(idxs))
     return result
 end
@@ -59,10 +58,7 @@ function ForwardDiff.extract_gradient_chunk!(::Type{T}, result::AbstractGPUArray
     fn = PartialsFn{T}(dual)
     offset = index - 1
     idxs = collect(
-        Iterators.take(
-                    Iterators.drop(ForwardDiff.structural_eachindex(result), offset),
-            chunksize,
-        )
+        _take(Iterators.drop(ForwardDiff.structural_eachindex(result), offset), chunksize)
     )
     result[idxs] .= fn.(1:length(idxs))
     return result

From 7a8828a25141472859512282937c9b7e7ca132f8 Mon Sep 17 00:00:00 2001
From: Avik Pal <avik.pal.2017@gmail.com>
Date: Mon, 18 Aug 2025 18:59:08 -0400
Subject: [PATCH 09/12] chore: remove GPUArraysCore

Co-authored-by: David Widmann <devmotion@users.noreply.github.com>
---
 Project.toml | 1 -
 1 file changed, 1 deletion(-)

diff --git a/Project.toml b/Project.toml
index 77913d55..1e1969e6 100644
--- a/Project.toml
+++ b/Project.toml
@@ -40,7 +40,6 @@ julia = "1.10"
 [extras]
 Calculus = "49dc2e85-a5d0-5ad3-a950-438e2897f1b9"
 DiffTests = "de460e47-3fe3-5279-bb4a-814414816d5d"
-GPUArraysCore = "46192b85-c4d5-4398-a991-12ede77f4527"
 InteractiveUtils = "b77e0a4c-d291-57a0-90e8-8db25a27a240"
 IrrationalConstants = "92d709cd-6900-40b7-9082-c6be49f344b6"
 JLArrays = "27aeb0d3-9eb9-45fb-866b-73c2ecf80fcb"

From c722819a19f91af044a7d9b53578ccba62e93e3e Mon Sep 17 00:00:00 2001
From: Avik Pal <avikpal@mit.edu>
Date: Mon, 18 Aug 2025 18:59:58 -0400
Subject: [PATCH 10/12] fix: revert _take

---
 ext/ForwardDiffGPUArraysCoreExt.jl | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/ext/ForwardDiffGPUArraysCoreExt.jl b/ext/ForwardDiffGPUArraysCoreExt.jl
index bf63da00..a881dc4d 100644
--- a/ext/ForwardDiffGPUArraysCoreExt.jl
+++ b/ext/ForwardDiffGPUArraysCoreExt.jl
@@ -10,8 +10,6 @@ PartialsFn{T}(dual::Dual) where {T} = PartialsFn{T,typeof(dual)}(dual)
 
 (f::PartialsFn{T})(i) where {T} = partials(T, f.dual, i)
 
-_take(itr, N::Integer) = Iterators.take(itr, min(length(itr), N))
-
 function ForwardDiff.seed!(duals::AbstractGPUArray{Dual{T,V,N}}, x,
                            seed::Partials{N,V}) where {T,V,N}
     idxs = collect(ForwardDiff.structural_eachindex(duals, x))
@@ -21,7 +19,7 @@ end
 
 function ForwardDiff.seed!(duals::AbstractGPUArray{Dual{T,V,N}}, x,
                            seeds::NTuple{N,Partials{N,V}}) where {T,V,N}
-    idxs = collect(_take(ForwardDiff.structural_eachindex(duals, x), N))
+    idxs = collect(Iterators.take(ForwardDiff.structural_eachindex(duals, x), N))
     duals[idxs] .= Dual{T,V,N}.(view(x, idxs), getindex.(Ref(seeds), 1:length(idxs)))
     return duals
 end
@@ -38,7 +36,7 @@ function ForwardDiff.seed!(duals::AbstractGPUArray{Dual{T,V,N}}, x, index,
                            seeds::NTuple{N,Partials{N,V}}, chunksize) where {T,V,N}
     offset = index - 1
     idxs = collect(
-        _take(Iterators.drop(ForwardDiff.structural_eachindex(duals, x), offset), chunksize)
+        Iterators.take(Iterators.drop(ForwardDiff.structural_eachindex(duals, x), offset), chunksize)
     )
     duals[idxs] .= Dual{T,V,N}.(view(x, idxs), getindex.(Ref(seeds), 1:length(idxs)))
     return duals
@@ -48,7 +46,7 @@ end
 function ForwardDiff.extract_gradient!(::Type{T}, result::AbstractGPUArray,
                                        dual::Dual) where {T}
     fn = PartialsFn{T}(dual)
-    idxs = collect(_take(ForwardDiff.structural_eachindex(result), npartials(dual)))
+    idxs = collect(Iterators.take(ForwardDiff.structural_eachindex(result), npartials(dual)))
     result[idxs] .= fn.(1:length(idxs))
     return result
 end
@@ -58,7 +56,7 @@ function ForwardDiff.extract_gradient_chunk!(::Type{T}, result::AbstractGPUArray
     fn = PartialsFn{T}(dual)
     offset = index - 1
     idxs = collect(
-        _take(Iterators.drop(ForwardDiff.structural_eachindex(result), offset), chunksize)
+        Iterators.take(Iterators.drop(ForwardDiff.structural_eachindex(result), offset), chunksize)
     )
     result[idxs] .= fn.(1:length(idxs))
     return result

From 11540a067a29ca05d7e8c18b3b5bf72fab51667d Mon Sep 17 00:00:00 2001
From: Avik Pal <avikpal@mit.edu>
Date: Mon, 18 Aug 2025 19:02:25 -0400
Subject: [PATCH 11/12] chore: remove 1.8 checks

---
 src/dual.jl      | 2 --
 test/DualTest.jl | 1 -
 2 files changed, 3 deletions(-)

diff --git a/src/dual.jl b/src/dual.jl
index 179c48d3..e5375601 100644
--- a/src/dual.jl
+++ b/src/dual.jl
@@ -298,8 +298,6 @@ Base.copy(d::Dual) = d
 Base.eps(d::Dual) = eps(value(d))
 Base.eps(::Type{D}) where {D<:Dual} = eps(valtype(D))
 
-# The `base` keyword was added in Julia 1.8:
-# https://github.com/JuliaLang/julia/pull/42428
 Base.precision(d::Dual; base::Integer=2) = precision(value(d); base=base)
 function Base.precision(::Type{D}; base::Integer=2) where {D<:Dual}
     precision(valtype(D); base=base)
diff --git a/test/DualTest.jl b/test/DualTest.jl
index bd50c37c..5ac9a3e1 100644
--- a/test/DualTest.jl
+++ b/test/DualTest.jl
@@ -118,7 +118,6 @@ ForwardDiff.:≺(::Type{OuterTestTag}, ::Type{TestTag}) = false
         @test precision(typeof(FDNUM)) === precision(V)
         @test precision(NESTED_FDNUM) === precision(PRIMAL)
         @test precision(typeof(NESTED_FDNUM)) === precision(V)
-        
         @test precision(FDNUM; base=10) === precision(PRIMAL; base=10)
         @test precision(typeof(FDNUM); base=10) === precision(V; base=10)
         @test precision(NESTED_FDNUM; base=10) === precision(PRIMAL; base=10)

From 0b9132abffc1a399fcbd3908a71b92295112ef3e Mon Sep 17 00:00:00 2001
From: Avik Pal <avik.pal.2017@gmail.com>
Date: Tue, 19 Aug 2025 18:27:10 -0400
Subject: [PATCH 12/12] chore: remove 0.1

Co-authored-by: David Widmann <devmotion@users.noreply.github.com>
---
 Project.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Project.toml b/Project.toml
index 1e1969e6..abbf186c 100644
--- a/Project.toml
+++ b/Project.toml
@@ -28,7 +28,7 @@ CommonSubexpressions = "0.3"
 DiffResults = "1.1"
 DiffRules = "1.4"
 DiffTests = "0.1"
-GPUArraysCore = "0.1, 0.2"
+GPUArraysCore = "0.2"
 IrrationalConstants = "0.1, 0.2"
 LogExpFunctions = "0.3"
 NaNMath = "1"