diff --git a/ext/AcceleratedKernelsMetalExt.jl b/ext/AcceleratedKernelsMetalExt.jl
index 326429a..7d191dd 100644
--- a/ext/AcceleratedKernelsMetalExt.jl
+++ b/ext/AcceleratedKernelsMetalExt.jl
@@ -38,73 +38,4 @@ function AK.accumulate!(
     )
 end
 
-
-function AK.cumsum(
-    src::AbstractArray, backend::MetalBackend;
-    init=zero(eltype(src)),
-    neutral=zero(eltype(src)),
-    dims::Union{Nothing, Int}=nothing,
-
-    # CPU settings - not used
-    max_tasks::Int=Threads.nthreads(),
-    min_elems::Int=1,
-
-    # Algorithm choice
-    alg::AK.AccumulateAlgorithm=AK.ScanPrefixes(),
-
-    # GPU settings
-    block_size::Int=256,
-    temp::Union{Nothing, AbstractArray}=nothing,
-    temp_flags::Union{Nothing, AbstractArray}=nothing,
-)
-    AK.accumulate(
-        +, src, backend;
-        init=init,
-        neutral=neutral,
-        dims=dims,
-        inclusive=true,
-
-        alg=alg,
-
-        block_size=block_size,
-        temp=temp,
-        temp_flags=temp_flags,
-    )
-end
-
-
-function AK.cumprod(
-    src::AbstractArray, backend::MetalBackend;
-    init=one(eltype(src)),
-    neutral=one(eltype(src)),
-    dims::Union{Nothing, Int}=nothing,
-
-    # CPU settings - not used
-    max_tasks::Int=Threads.nthreads(),
-    min_elems::Int=1,
-
-    # Algorithm choice
-    alg::AK.AccumulateAlgorithm=AK.ScanPrefixes(),
-
-    # GPU settings
-    block_size::Int=256,
-    temp::Union{Nothing, AbstractArray}=nothing,
-    temp_flags::Union{Nothing, AbstractArray}=nothing,
-)
-    AK.accumulate(
-        *, src, backend;
-        init=init,
-        neutral=neutral,
-        dims=dims,
-        inclusive=true,
-
-        alg=alg,
-
-        block_size=block_size,
-        temp=temp,
-        temp_flags=temp_flags,
-    )
-end
-
-
 end   # module AcceleratedKernelsMetalExt
\ No newline at end of file
diff --git a/ext/AcceleratedKernelsoneAPIExt.jl b/ext/AcceleratedKernelsoneAPIExt.jl
index e7d5b48..1746ca7 100644
--- a/ext/AcceleratedKernelsoneAPIExt.jl
+++ b/ext/AcceleratedKernelsoneAPIExt.jl
@@ -12,20 +12,12 @@ function AK.any(
 
     # Algorithm choice
     alg::AK.PredicatesAlgorithm=AK.MapReduce(),
-
-    # CPU settings
-    max_tasks=Threads.nthreads(),
-    min_elems=1,
-
-    # GPU settings
-    block_size::Int=256,
+    kwargs...
 )
     AK._any_impl(
         pred, v, backend;
-        alg=alg,
-        max_tasks=max_tasks,
-        min_elems=min_elems,
-        block_size=block_size,
+        alg,
+        kwargs...
     )
 end
 
@@ -35,20 +27,12 @@ function AK.all(
 
     # Algorithm choice
     alg::AK.PredicatesAlgorithm=AK.MapReduce(),
-
-    # CPU settings
-    max_tasks=Threads.nthreads(),
-    min_elems=1,
-
-    # GPU settings
-    block_size::Int=256,
+    kwargs...
 )
     AK._all_impl(
         pred, v, backend;
-        alg=alg,
-        max_tasks=max_tasks,
-        min_elems=min_elems,
-        block_size=block_size,
+        alg,
+        kwargs...
     )
 end
 
diff --git a/src/accumulate/accumulate_1d_cpu.jl b/src/accumulate/accumulate_1d_cpu.jl
index eda07ae..ce03c0c 100644
--- a/src/accumulate/accumulate_1d_cpu.jl
+++ b/src/accumulate/accumulate_1d_cpu.jl
@@ -36,8 +36,7 @@ function accumulate_1d!(
             if itask == 1
                 _accumulate_1d_cpu_section!(
                     op, @view(v[irange]);
-                    init=init,
-                    inclusive=inclusive,
+                    init, inclusive,
                 )
             else
                 # Later sections should always be inclusively accumulated
diff --git a/src/arithmetics.jl b/src/arithmetics.jl
index 18f85e1..790db06 100644
--- a/src/arithmetics.jl
+++ b/src/arithmetics.jl
@@ -44,28 +44,12 @@ s = AK.sum(m, dims=2, temp=temp)
 function sum(
     src::AbstractArray, backend::Backend=get_backend(src);
     init=zero(eltype(src)),
-    dims::Union{Nothing, Int}=nothing,
-
-    # CPU settings
-    max_tasks=Threads.nthreads(),
-    min_elems=1,
-
-    # GPU settings
-    block_size::Int=256,
-    temp::Union{Nothing, AbstractArray}=nothing,
-    switch_below::Int=0,
+    kwargs...
 )
     reduce(
         +, src, backend;
-        init=init,
-        dims=dims,
-
-        max_tasks=max_tasks,
-        min_elems=min_elems,
-
-        block_size=block_size,
-        temp=temp,
-        switch_below=switch_below,
+        init,
+        kwargs...
     )
 end
 
@@ -116,28 +100,12 @@ p = AK.prod(m, dims=2, temp=temp)
 function prod(
     src::AbstractArray, backend::Backend=get_backend(src);
     init=one(eltype(src)),
-    dims::Union{Nothing, Int}=nothing,
-
-    # CPU settings
-    max_tasks=Threads.nthreads(),
-    min_elems=1,
-
-    # GPU settings
-    block_size::Int=256,
-    temp::Union{Nothing, AbstractArray}=nothing,
-    switch_below::Int=0,
+    kwargs...
 )
     reduce(
         *, src, backend;
-        init=init,
-        dims=dims,
-
-        max_tasks=max_tasks,
-        min_elems=min_elems,
-
-        block_size=block_size,
-        temp=temp,
-        switch_below=switch_below,
+        init,
+        kwargs...
     )
 end
 
@@ -188,28 +156,12 @@ m = AK.maximum(m, dims=2, temp=temp)
 function maximum(
     src::AbstractArray, backend::Backend=get_backend(src);
     init=typemin(eltype(src)),
-    dims::Union{Nothing, Int}=nothing,
-
-    # CPU settings
-    max_tasks=Threads.nthreads(),
-    min_elems=1,
-
-    # GPU settings
-    block_size::Int=256,
-    temp::Union{Nothing, AbstractArray}=nothing,
-    switch_below::Int=0,
+    kwargs...
 )
     reduce(
         max, src, backend;
-        init=init,
-        dims=dims,
-
-        max_tasks=max_tasks,
-        min_elems=min_elems,
-
-        block_size=block_size,
-        temp=temp,
-        switch_below=switch_below,
+        init,
+        kwargs...
     )
 end
 
@@ -260,28 +212,12 @@ m = AK.minimum(m, dims=2, temp=temp)
 function minimum(
     src::AbstractArray, backend::Backend=get_backend(src);
     init=typemax(eltype(src)),
-    dims::Union{Nothing, Int}=nothing,
-
-    # CPU settings
-    max_tasks=Threads.nthreads(),
-    min_elems=1,
-
-    # GPU settings
-    block_size::Int=256,
-    temp::Union{Nothing, AbstractArray}=nothing,
-    switch_below::Int=0,
+    kwargs...
 )
     reduce(
         min, src, backend;
-        init=init,
-        dims=dims,
-
-        max_tasks=max_tasks,
-        min_elems=min_elems,
-
-        block_size=block_size,
-        temp=temp,
-        switch_below=switch_below,
+        init,
+        kwargs...
     )
 end
 
@@ -338,29 +274,13 @@ c = AK.count(m, dims=2, temp=temp)
 function count(
     src::AbstractArray, backend::Backend=get_backend(src);
     init=0,
-    dims::Union{Nothing, Int}=nothing,
-
-    # CPU settings
-    max_tasks=Threads.nthreads(),
-    min_elems=1,
-
-    # GPU settings
-    block_size::Int=256,
-    temp::Union{Nothing, AbstractArray}=nothing,
-    switch_below::Int=0,
+    kwargs...
 )
     mapreduce(
         x -> x ? one(typeof(init)) : zero(typeof(init)), +, src, backend;
-        init=init,
+        init,
         neutral=zero(typeof(init)),
-        dims=dims,
-
-        max_tasks=max_tasks,
-        min_elems=min_elems,
-
-        block_size=block_size,
-        temp=temp,
-        switch_below=switch_below,
+        kwargs...
     )
 end
 
@@ -368,29 +288,13 @@ end
 function count(
     f, src::AbstractArray, backend::Backend=get_backend(src);
     init=0,
-    dims::Union{Nothing, Int}=nothing,
-
-    # CPU settings
-    max_tasks=Threads.nthreads(),
-    min_elems=1,
-
-    # GPU settings
-    block_size::Int=256,
-    temp::Union{Nothing, AbstractArray}=nothing,
-    switch_below::Int=0,
+    kwargs...
 )
     mapreduce(
         x -> f(x) ? one(typeof(init)) : zero(typeof(init)), +, src, backend;
-        init=init,
+        init,
         neutral=zero(typeof(init)),
-        dims=dims,
-
-        max_tasks=max_tasks,
-        min_elems=min_elems,
-
-        block_size=block_size,
-        temp=temp,
-        switch_below=switch_below,
+        kwargs...
     )
 end
 
@@ -437,28 +341,13 @@ function cumsum(
     src::AbstractArray, backend::Backend=get_backend(src);
     init=zero(eltype(src)),
     neutral=zero(eltype(src)),
-    dims::Union{Nothing, Int}=nothing,
-
-    # Algorithm choice
-    alg::AccumulateAlgorithm=DecoupledLookback(),
-
-    # GPU settings
-    block_size::Int=256,
-    temp::Union{Nothing, AbstractArray}=nothing,
-    temp_flags::Union{Nothing, AbstractArray}=nothing,
+    kwargs...
 )
     accumulate(
         +, src, backend;
-        init=init,
-        neutral=neutral,
-        dims=dims,
+        init, neutral,
         inclusive=true,
-
-        alg=alg,
-
-        block_size=block_size,
-        temp=temp,
-        temp_flags=temp_flags,
+        kwargs...
     )
 end
 
@@ -505,27 +394,12 @@ function cumprod(
     src::AbstractArray, backend::Backend=get_backend(src);
     init=one(eltype(src)),
     neutral=one(eltype(src)),
-    dims::Union{Nothing, Int}=nothing,
-
-    # Algorithm choice
-    alg::AccumulateAlgorithm=DecoupledLookback(),
-
-    # GPU settings
-    block_size::Int=256,
-    temp::Union{Nothing, AbstractArray}=nothing,
-    temp_flags::Union{Nothing, AbstractArray}=nothing,
+    kwargs...
 )
     accumulate(
         *, src, backend;
-        init=init,
-        neutral=neutral,
-        dims=dims,
+        init, neutral,
         inclusive=true,
-
-        alg=alg,
-
-        block_size=block_size,
-        temp=temp,
-        temp_flags=temp_flags,
+        kwargs...
     )
 end
diff --git a/src/foreachindex.jl b/src/foreachindex.jl
index 8923e04..2cf68a6 100644
--- a/src/foreachindex.jl
+++ b/src/foreachindex.jl
@@ -225,9 +225,8 @@ function foraxes(
     if isnothing(dims)
         return foreachindex(
             f, itr, backend;
-            max_tasks=max_tasks,
-            min_elems=min_elems,
-            block_size=block_size,
+            max_tasks, min_elems,
+            block_size,
         )
     end
 
diff --git a/src/map.jl b/src/map.jl
index ed7fe8a..ca37bd4 100644
--- a/src/map.jl
+++ b/src/map.jl
@@ -38,10 +38,9 @@ function map!(
 )
     @argcheck length(dst) == length(src)
     foreachindex(
-        src, backend,
-        max_tasks=max_tasks,
-        min_elems=min_elems,
-        block_size=block_size,
+        src, backend;
+        max_tasks, min_elems,
+        block_size,
     ) do idx
         dst[idx] = f(src[idx])
     end
@@ -58,7 +57,7 @@ end
         min_elems=1,
 
         # GPU settings
-        block_size=256,    
+        block_size=256,
     )
 
 Apply the function `f` to each element of `src` and store the results in a copy of `src` (if `f`
@@ -67,19 +66,11 @@ settings are the same as for [`foreachindex`](@ref).
 """
 function map(
     f, src::AbstractArray, backend::Backend=get_backend(src);
-
-    # CPU settings
-    max_tasks=Threads.nthreads(),
-    min_elems=1,
-
-    # GPU settings
-    block_size=256,
+    kwargs...
 )
     dst = similar(src)
     map!(
-        f, dst, src, backend,
-        max_tasks=max_tasks,
-        min_elems=min_elems,
-        block_size=block_size,
+        f, dst, src, backend;
+        kwargs...
     )
 end
diff --git a/src/predicates.jl b/src/predicates.jl
index 23419ba..19c8e5c 100644
--- a/src/predicates.jl
+++ b/src/predicates.jl
@@ -96,23 +96,11 @@ complex_any(CuArray(rand(Float32, 100)), CuArray(rand(Float32, 100)))
 """
 function any(
     pred, v::AbstractArray, backend::Backend=get_backend(v);
-
-    # Algorithm choice
-    alg::PredicatesAlgorithm=ConcurrentWrite(),
-
-    # CPU settings
-    max_tasks=Threads.nthreads(),
-    min_elems=1,
-
-    # GPU settings
-    block_size::Int=256,
+    kwargs...
 )
     _any_impl(
         pred, v, backend;
-        alg=alg,
-        max_tasks=max_tasks,
-        min_elems=min_elems,
-        block_size=block_size,
+        kwargs...
     )
 end
 
@@ -240,23 +228,11 @@ complex_all(CuArray(rand(Float32, 100)), CuArray(rand(Float32, 100)))
 """
 function all(
     pred, v::AbstractArray, backend::Backend=get_backend(v);
-
-    # Algorithm choice
-    alg::PredicatesAlgorithm=ConcurrentWrite(),
-
-    # CPU settings
-    max_tasks=Threads.nthreads(),
-    min_elems=1,
-
-    # GPU settings
-    block_size::Int=256,
+    kwargs...
 )
     _all_impl(
         pred, v, backend;
-        alg=alg,
-        max_tasks=max_tasks,
-        min_elems=min_elems,
-        block_size=block_size,
+        kwargs...,
     )
 end
 
diff --git a/src/reduce/mapreduce_1d_cpu.jl b/src/reduce/mapreduce_1d_cpu.jl
index 5384b1d..544c3a7 100644
--- a/src/reduce/mapreduce_1d_cpu.jl
+++ b/src/reduce/mapreduce_1d_cpu.jl
@@ -1,16 +1,16 @@
 function mapreduce_1d(
     f, op, src::AbstractArray, backend::CPU;
     init,
-    neutral=neutral_element(op, eltype(src)),
+    neutral,
 
     # CPU settings
-    max_tasks::Int=Threads.nthreads(),
-    min_elems::Int=1,
+    max_tasks::Int,
+    min_elems::Int,
 
     # GPU settings - ignored here
-    block_size::Int=256,
-    temp::Union{Nothing, AbstractArray}=nothing,
-    switch_below::Int=0,
+    block_size::Int,
+    temp::Union{Nothing, AbstractArray},
+    switch_below::Int,
 )
     if max_tasks == 1
         return op(init, Base.mapreduce(f, op, src; init=neutral))
diff --git a/src/reduce/mapreduce_1d_gpu.jl b/src/reduce/mapreduce_1d_gpu.jl
index cc3c4d6..b2b9566 100644
--- a/src/reduce/mapreduce_1d_gpu.jl
+++ b/src/reduce/mapreduce_1d_gpu.jl
@@ -102,16 +102,16 @@ end
 function mapreduce_1d(
     f, op, src::AbstractArray, backend::GPU;
     init,
-    neutral=neutral_element(op, eltype(src)),
+    neutral,
 
     # CPU settings - ignored here
-    max_tasks::Int=Threads.nthreads(),
-    min_elems::Int=1,
+    max_tasks::Int,
+    min_elems::Int,
 
     # GPU settings
-    block_size::Int=256,
-    temp::Union{Nothing, AbstractArray}=nothing,
-    switch_below::Int=0,
+    block_size::Int,
+    temp::Union{Nothing, AbstractArray},
+    switch_below::Int,
 )
     @argcheck 1 <= block_size <= 1024
     @argcheck switch_below >= 0
@@ -122,7 +122,7 @@ function mapreduce_1d(
     len == 1 && return @allowscalar f(src[1])
     if len < switch_below
         h_src = Vector(src)
-        return Base.mapreduce(f, op, h_src, init=init)
+        return Base.mapreduce(f, op, h_src; init)
     end
 
     # Each thread will handle two elements
@@ -152,7 +152,7 @@ function mapreduce_1d(
     len = blocks
     if len < switch_below
         h_src = Vector(@view(dst[1:len]))
-        return Base.reduce(op, h_src, init=init)
+        return Base.reduce(op, h_src; init)
     end
 
     # Now all src elements have been passed through f; just do final reduction, no map needed
@@ -168,7 +168,7 @@ function mapreduce_1d(
 
         if len < switch_below
             h_src = Vector(@view(p2[1:len]))
-            return Base.reduce(op, h_src, init=init)
+            return Base.reduce(op, h_src; init)
         end
 
         p1, p2 = p2, p1
diff --git a/src/reduce/mapreduce_nd.jl b/src/reduce/mapreduce_nd.jl
index bb5e644..a373a71 100644
--- a/src/reduce/mapreduce_nd.jl
+++ b/src/reduce/mapreduce_nd.jl
@@ -5,12 +5,12 @@ function mapreduce_nd(
     dims::Int,
 
     # CPU settings - ignored here
-    max_tasks::Int=Threads.nthreads(),
-    min_elems::Int=1,
+    max_tasks::Int,
+    min_elems::Int,
 
     # GPU settings
-    block_size::Int=256,
-    temp::Union{Nothing, AbstractArray}=nothing,
+    block_size::Int,
+    temp::Union{Nothing, AbstractArray},
 )
     @argcheck 1 <= block_size <= 1024
 
diff --git a/src/reduce/reduce.jl b/src/reduce/reduce.jl
index d6a3c73..bf6b4c8 100644
--- a/src/reduce/reduce.jl
+++ b/src/reduce/reduce.jl
@@ -69,57 +69,12 @@ mcolsum = AK.reduce(+, m; init=zero(eltype(m)), dims=2)
 function reduce(
     op, src::AbstractArray, backend::Backend=get_backend(src);
     init,
-    neutral=neutral_element(op, eltype(src)),
-    dims::Union{Nothing, Int}=nothing,
-
-    # CPU settings
-    max_tasks::Int=Threads.nthreads(),
-    min_elems::Int=1,
-
-    # GPU settings
-    block_size::Int=256,
-    temp::Union{Nothing, AbstractArray}=nothing,
-    switch_below::Int=0,
-)
-    _reduce_impl(
-        op, src, backend;
-        init=init,
-        neutral=neutral,
-        dims=dims,
-        max_tasks=max_tasks,
-        min_elems=min_elems,
-        block_size=block_size,
-        temp=temp,
-        switch_below=switch_below,
-    )
-end
-
-
-function _reduce_impl(
-    op, src::AbstractArray, backend;
-    init,
-    neutral=neutral_element(op, eltype(src)),
-    dims::Union{Nothing, Int}=nothing,
-
-    # CPU settings
-    max_tasks::Int=Threads.nthreads(),
-    min_elems::Int=1,
-
-    # GPU settings
-    block_size::Int=256,
-    temp::Union{Nothing, AbstractArray}=nothing,
-    switch_below::Int=0,
+    kwargs...
 )
     _mapreduce_impl(
         identity, op, src, backend;
-        init=init,
-        neutral=neutral,
-        dims=dims,
-        max_tasks=max_tasks,
-        min_elems=min_elems,
-        block_size=block_size,
-        temp=temp,
-        switch_below=switch_below,
+        init,
+        kwargs...
     )
 end
 
@@ -194,28 +149,12 @@ mcolsumsq = AK.mapreduce(f, +, m; init=zero(eltype(m)), dims=2)
 function mapreduce(
     f, op, src::AbstractArray, backend::Backend=get_backend(src);
     init,
-    neutral=neutral_element(op, eltype(src)),
-    dims::Union{Nothing, Int}=nothing,
-
-    # CPU settings
-    max_tasks::Int=Threads.nthreads(),
-    min_elems::Int=1,
-
-    # GPU settings
-    block_size::Int=256,
-    temp::Union{Nothing, AbstractArray}=nothing,
-    switch_below::Int=0,
+    kwargs...
 )
     _mapreduce_impl(
         f, op, src, backend;
-        init=init,
-        neutral=neutral,
-        dims=dims,
-        max_tasks=max_tasks,
-        min_elems=min_elems,
-        block_size=block_size,
-        temp=temp,
-        switch_below=switch_below,
+        init,
+        kwargs...
     )
 end
 
@@ -238,24 +177,18 @@ function _mapreduce_impl(
     if isnothing(dims)
         return mapreduce_1d(
             f, op, src, backend;
-            init=init,
-            neutral=neutral,
-            max_tasks=max_tasks,
-            min_elems=min_elems,
-            block_size=block_size,
-            temp=temp,
-            switch_below=switch_below,
+            init, neutral,
+            max_tasks, min_elems,
+            block_size, temp,
+            switch_below
         )
     else
         return mapreduce_nd(
             f, op, src, backend;
-            init=init,
-            neutral=neutral,
-            dims=dims,
-            max_tasks=max_tasks,
-            min_elems=min_elems,
-            block_size=block_size,
-            temp=temp,
+            init, neutral,
+            dims, max_tasks=max_tasks,
+            min_elems, block_size,
+            temp,
         )
     end
 end
diff --git a/src/searchsorted.jl b/src/searchsorted.jl
index ac16ba7..9039f12 100644
--- a/src/searchsorted.jl
+++ b/src/searchsorted.jl
@@ -96,12 +96,10 @@ function searchsortedfirst!(
 
     by=identity, lt=isless, rev::Bool=false,
 
-    # CPU settings
-    max_tasks::Int=Threads.nthreads(),
+    # CPU settings with different default from `foreachindex`
     min_elems::Int=1000,
 
-    # GPU settings
-    block_size::Int=256,
+    kwargs...
 )
     # Simple sanity checks
     @argcheck length(ix) == length(x)
@@ -111,9 +109,8 @@ function searchsortedfirst!(
     comp = (x, y) -> Base.Order.lt(ord, x, y)
 
     foreachindex(
-        x, backend,
-        max_tasks=max_tasks, min_elems=min_elems,
-        block_size=block_size,
+        x, backend;
+        min_elems, kwargs...
     ) do i
         @inbounds ix[i] = _searchsortedfirst(v, x[i], firstindex(v), lastindex(v), comp)
     end
@@ -143,22 +140,12 @@ function searchsortedfirst(
     v::AbstractVector,
     x::AbstractVector,
     backend::Backend=get_backend(x);
-
-    by=identity, lt=isless, rev::Bool=false,
-
-    # CPU settings
-    max_tasks::Int=Threads.nthreads(),
-    min_elems::Int=1000,
-
-    # GPU settings
-    block_size::Int=256,
+    kwargs...
 )
     ix = similar(x, Int)
     searchsortedfirst!(
         ix, v, x, backend;
-        by=by, lt=lt, rev=rev,
-        max_tasks=max_tasks, min_elems=min_elems,
-        block_size=block_size,
+        kwargs...
     )
     ix
 end
@@ -192,15 +179,12 @@ function searchsortedlast!(
 
     by=identity, lt=isless, rev::Bool=false,
 
-    # CPU settings
-    max_tasks::Int=Threads.nthreads(),
+    # CPU settings with different default from `foreachindex`
     min_elems::Int=1000,
 
-    # GPU settings
-    block_size::Int=256,
+    kwargs...
 )
     # Simple sanity checks
-    @argcheck block_size > 0
     @argcheck length(ix) == length(x)
 
     # Construct comparator
@@ -208,9 +192,8 @@ function searchsortedlast!(
     comp = (x, y) -> Base.Order.lt(ord, x, y)
 
     foreachindex(
-        x, backend,
-        max_tasks=max_tasks, min_elems=min_elems,
-        block_size=block_size,
+        x, backend;
+        min_elems, kwargs...
     ) do i
         @inbounds ix[i] = _searchsortedlast(v, x[i], firstindex(v), lastindex(v), comp)
     end
@@ -240,22 +223,12 @@ function searchsortedlast(
     v::AbstractVector,
     x::AbstractVector,
     backend::Backend=get_backend(x);
-
-    by=identity, lt=isless, rev::Bool=false,
-
-    # CPU settings
-    max_tasks::Int=Threads.nthreads(),
-    min_elems::Int=1000,
-
-    # GPU settings
-    block_size::Int=256,
+    kwargs...
 )
     ix = similar(x, Int)
     searchsortedlast!(
         ix, v, x, backend;
-        by=by, lt=lt, rev=rev,
-        max_tasks=max_tasks, min_elems=min_elems,
-        block_size=block_size,
+        kwargs...
     )
     ix
 end
diff --git a/src/sort/cpu_sample_sort.jl b/src/sort/cpu_sample_sort.jl
index c583e5e..84f0304 100644
--- a/src/sort/cpu_sample_sort.jl
+++ b/src/sort/cpu_sample_sort.jl
@@ -72,7 +72,7 @@ end
 
 function _sample_sort_sort_bucket!(
     v, temp, offsets, itask, max_tasks;
-    lt, by, rev, order    
+    lt, by, rev, order
 )
     @inbounds begin
         istart = offsets[itask] + 1
@@ -89,10 +89,10 @@ function _sample_sort_sort_bucket!(
         # odd-numbered itask, move elements first, to avoid false sharing from threads
         if isodd(itask)
             copyto!(v, istart, temp, istart, istop - istart + 1)
-            Base.sort!(view(v, istart:istop), lt=lt, by=by, rev=rev, order=order)
+            Base.sort!(view(v, istart:istop); lt, by, rev, order)
         else
             # For even-numbered itasks, sort first, then move elements back to v
-            Base.sort!(view(temp, istart:istop), lt=lt, by=by, rev=rev, order=order)
+            Base.sort!(view(temp, istart:istop); lt, by, rev, order)
             copyto!(v, istart, temp, istart, istop - istart + 1)
         end
     end
@@ -134,7 +134,7 @@ function _sample_sort_parallel!(
     itask_partition(tp) do itask, irange
         _sample_sort_sort_bucket!(
             v, temp, offsets, itask, max_tasks;
-            lt=lt, by=by, rev=rev, order=order,
+            lt, by, rev, order,
         )
     end
 
@@ -161,7 +161,7 @@ function _sample_sort_parallel!(
     # for itask in 1:max_tasks
     #     _sample_sort_sort_bucket!(
     #         v, temp, offsets, itask, max_tasks;
-    #         lt=lt, by=by, rev=rev, order=order,
+    #         lt, by, rev, order,
     #     )
     # end
 
@@ -211,7 +211,7 @@ function sample_sort!(
     end
     max_tasks = min(max_tasks, num_elements ÷ min_elems)
     if max_tasks <= 1 || num_elements < oversampling_factor * max_tasks
-        return Base.sort!(v, lt=lt, by=by, rev=rev, order=order)
+        return Base.sort!(v; lt, by, rev, order)
     end
 
     # Create a temporary buffer for the sorted output
@@ -231,7 +231,7 @@ function sample_sort!(
     end
 
     # Sort samples and choose splitters; these are small allocations, which Julia is fast at
-    Base.sort!(view(dest, 1:num_samples), lt=lt, by=by, rev=rev, order=order)
+    Base.sort!(view(dest, 1:num_samples); lt, by, rev, order)
     splitters = Vector{eltype(v)}(undef, max_tasks - 1)
     for i in 1:(max_tasks - 1)
         splitters[i] = dest[div(i * num_samples, max_tasks)]
@@ -248,7 +248,7 @@ function sample_sort!(
         v, dest, ord,
         splitters, histograms,
         max_tasks;
-        lt=lt, by=by, rev=rev, order=order,
+        lt, by, rev, order,
     )
 
     v
@@ -288,7 +288,7 @@ function sample_sortperm!(
     @argcheck length(ix) == length(v)
 
     # Initialise indices that will be sorted by the keys in v
-    foreachindex(ix, max_tasks=max_tasks, min_elems=min_elems) do i
+    foreachindex(ix; max_tasks, min_elems) do i
         @inbounds ix[i] = i
     end
 
@@ -296,9 +296,8 @@ function sample_sortperm!(
     ord = Base.Order.ord(lt, by, rev, order)
     _sample_sort_barrier!(
         ix, v, ord;
-        max_tasks=max_tasks,
-        min_elems=min_elems,
-        temp=temp,
+        max_tasks, min_elems,
+        temp,
     )
 end
 
@@ -313,8 +312,6 @@ function _sample_sort_barrier!(ix, v, ord; max_tasks, min_elems, temp)
         # Leave defaults - we already have a custom comparator
         # by=identity, rev=nothing, order=Base.Order.Forward,
 
-        max_tasks=max_tasks,
-        min_elems=min_elems,
-        temp=temp,
+        max_tasks, min_elems, temp,
     )
 end
diff --git a/src/sort/merge_sort.jl b/src/sort/merge_sort.jl
index 66d321b..00ea8fc 100644
--- a/src/sort/merge_sort.jl
+++ b/src/sort/merge_sort.jl
@@ -208,19 +208,11 @@ end
 """
 function merge_sort(
     v::AbstractGPUArray, backend::Backend=get_backend(v);
-
-    lt=isless,
-    by=identity,
-    rev::Union{Nothing, Bool}=nothing,
-    order::Base.Order.Ordering=Base.Order.Forward,
-
-    block_size::Int=256,
-    temp::Union{Nothing, AbstractGPUArray}=nothing,
+    kwargs...
 )
     v_copy = copy(v)
     merge_sort!(
-        v_copy, backend,
-        lt=lt, by=by, rev=rev, order=order,
-        block_size=block_size, temp=temp,
+        v_copy, backend;
+        kwargs...
     )
 end
diff --git a/src/sort/merge_sort_by_key.jl b/src/sort/merge_sort_by_key.jl
index 9c4918c..8690910 100644
--- a/src/sort/merge_sort_by_key.jl
+++ b/src/sort/merge_sort_by_key.jl
@@ -259,22 +259,13 @@ function merge_sort_by_key(
     keys::AbstractGPUArray,
     values::AbstractGPUArray,
     backend::Backend=get_backend(keys);
-
-    lt=isless,
-    by=identity,
-    rev::Union{Nothing, Bool}=nothing,
-    order::Base.Order.Ordering=Base.Order.Forward,
-
-    block_size::Int=256,
-    temp_keys::Union{Nothing, AbstractGPUArray}=nothing,
-    temp_values::Union{Nothing, AbstractGPUArray}=nothing,
+    kwargs...
 )
     keys_copy = copy(keys)
     values_copy = copy(values)
 
     merge_sort_by_key!(
-        keys_copy, values_copy, backend,
-        lt=lt, by=by, rev=rev, order=order,
-        block_size=block_size, temp_keys=temp_keys, temp_values=temp_values,
+        keys_copy, values_copy, backend;
+        kwargs...
     )
 end
diff --git a/src/sort/merge_sortperm.jl b/src/sort/merge_sortperm.jl
index 9f50dac..3266cc9 100644
--- a/src/sort/merge_sortperm.jl
+++ b/src/sort/merge_sortperm.jl
@@ -51,8 +51,7 @@ function merge_sortperm!(
 
     merge_sort_by_key!(
         keys, ix, backend;
-        lt=lt, by=by, rev=rev, order=order,
-        block_size=block_size,
+        lt, by, rev, order, block_size,
         temp_keys=temp_v, temp_values=temp_ix,
     )
 
@@ -77,22 +76,12 @@ end
 """
 function merge_sortperm(
     v::AbstractGPUArray, backend::Backend=get_backend(v);
-
-    lt=(<),
-    by=identity,
-    rev::Union{Nothing, Bool}=nothing,
-    order::Base.Order.Ordering=Base.Order.Forward,
-
-    inplace::Bool=false,
-    block_size::Int=256,
-    temp_ix::Union{Nothing, AbstractGPUArray}=nothing,
-    temp_v::Union{Nothing, AbstractGPUArray}=nothing,
+    kwargs...
 )
     ix = similar(v, Int)
     merge_sortperm!(
-        ix, v, backend,
-        lt=lt, by=by, rev=rev, order=order,
-        inplace=inplace, block_size=block_size, temp_ix=temp_ix, temp_v=temp_v,
+        ix, v, backend;
+        kwargs...
     )
 end
 
@@ -192,19 +181,11 @@ end
 """
 function merge_sortperm_lowmem(
     v::AbstractGPUArray, backend::Backend=get_backend(v);
-
-    lt=(<),
-    by=identity,
-    rev::Union{Nothing, Bool}=nothing,
-    order::Base.Order.Ordering=Base.Order.Forward,
-
-    block_size::Int=256,
-    temp::Union{Nothing, AbstractGPUArray}=nothing,
+    kwargs...
 )
     ix = similar(v, Int)
     merge_sortperm_lowmem!(
-        ix, v, backend,
-        lt=lt, by=by, rev=rev, order=order,
-        block_size=block_size, temp=temp,
+        ix, v, backend;
+        kwargs...
     )
 end
diff --git a/src/sort/sort.jl b/src/sort/sort.jl
index bd627f3..3d937ef 100644
--- a/src/sort/sort.jl
+++ b/src/sort/sort.jl
@@ -31,7 +31,7 @@ include("cpu_sample_sort.jl")
 
 Sorts the array `v` in-place using the specified backend. The `lt`, `by`, `rev`, and `order`
 arguments are the same as for `Base.sort`.
-    
+
 CPU settings: use at most `max_tasks` threads to sort the array such that at least `min_elems`
 elements are sorted by each thread. A parallel [`sample_sort!`](@ref) is used, processing
 independent slices of the array and deferring to `Base.sort!` for the final local sorts.
@@ -61,29 +61,11 @@ AK.sort!(v, temp=temp)
 """
 function sort!(
     v::AbstractArray, backend::Backend=get_backend(v);
-
-    lt=isless,
-    by=identity,
-    rev::Union{Nothing, Bool}=nothing,
-    order::Base.Order.Ordering=Base.Order.Forward,
-
-    # CPU settings
-    max_tasks=Threads.nthreads(),
-    min_elems=1,
-
-    # GPU settings
-    block_size::Int=256,
-
-    # Temporary buffer, same size as `v`
-    temp::Union{Nothing, AbstractArray}=nothing,
+    kwargs...
 )
     _sort_impl!(
-        v, backend,
-        lt=lt, by=by, rev=rev, order=order,
-        max_tasks=max_tasks,
-        min_elems=min_elems,
-        block_size=block_size,
-        temp=temp,
+        v, backend;
+        kwargs...
     )
 end
 
@@ -98,23 +80,26 @@ function _sort_impl!(
 
     max_tasks=Threads.nthreads(),
     min_elems=1,
+
+    # GPU settings
     block_size::Int=256,
+
+    # Temporary buffer, same size as `v`
     temp::Union{Nothing, AbstractArray}=nothing,
 )
     if backend isa GPU
         merge_sort!(
-            v, backend,
-            lt=lt, by=by, rev=rev, order=order,
-            block_size=block_size,
-            temp=temp,
+            v, backend;
+            lt, by, rev, order,
+            block_size,
+            temp,
         )
     else
         sample_sort!(
             v;
-            lt=lt, by=by, rev=rev, order=order,
-            max_tasks=max_tasks,
-            min_elems=min_elems,
-            temp=temp,
+            lt, by, rev, order,
+            max_tasks, min_elems,
+            temp,
         )
     end
 end
@@ -144,30 +129,12 @@ Out-of-place sort, same settings as [`sort!`](@ref).
 """
 function sort(
     v::AbstractArray, backend::Backend=get_backend(v);
-
-    lt=isless,
-    by=identity,
-    rev::Union{Nothing, Bool}=nothing,
-    order::Base.Order.Ordering=Base.Order.Forward,
-
-    # CPU settings
-    max_tasks=Threads.nthreads(),
-    min_elems=1,
-
-    # GPU settings
-    block_size::Int=256,
-
-    # Temporary buffer, same size as `v`
-    temp::Union{Nothing, AbstractArray}=nothing,
+    kwargs...
 )
     vcopy = copy(v)
     sort!(
-        vcopy, backend,
-        lt=lt, by=by, rev=rev, order=order,
-        max_tasks=max_tasks,
-        min_elems=min_elems,
-        block_size=block_size,
-        temp=temp,
+        vcopy, backend;
+        kwargs...
     )
 end
 
@@ -202,29 +169,11 @@ function sortperm!(
     ix::AbstractArray,
     v::AbstractArray,
     backend::Backend=get_backend(v);
-
-    lt=isless,
-    by=identity,
-    rev::Union{Nothing, Bool}=nothing,
-    order::Base.Order.Ordering=Base.Order.Forward,
-
-    # CPU settings
-    max_tasks=Threads.nthreads(),
-    min_elems=1,
-
-    # GPU settings
-    block_size::Int=256,
-
-    # Temporary buffer, same size as `v`
-    temp::Union{Nothing, AbstractArray}=nothing,
+    kwargs...
 )
     _sortperm_impl!(
-        ix, v, backend,
-        lt=lt, by=by, rev=rev, order=order,
-        max_tasks=max_tasks,
-        min_elems=min_elems,
-        block_size=block_size,
-        temp=temp,
+        ix, v, backend;
+        kwargs...
     )
 end
 
@@ -241,22 +190,26 @@ function _sortperm_impl!(
 
     max_tasks=Threads.nthreads(),
     min_elems=1,
+
+    # GPU settings
     block_size::Int=256,
+
+    # Temporary buffer, same size as `v`
     temp::Union{Nothing, AbstractArray}=nothing,
 )
     if backend isa GPU
         merge_sortperm_lowmem!(
-            ix, v,
-            lt=lt, by=by, rev=rev, order=order,
-            block_size=block_size, temp=temp,
+            ix, v, backend;
+            lt, by, rev, order,
+            block_size, temp,
         )
     else
         sample_sortperm!(
             ix, v;
-            lt=lt, by=by, rev=rev, order=order,
-            max_tasks=max_tasks,
-            min_elems=min_elems,
-            temp=temp,
+            lt, by, rev, order,
+            max_tasks,
+            min_elems,
+            temp,
         )
     end
 end
@@ -288,29 +241,11 @@ Out-of-place sortperm, same settings as [`sortperm!`](@ref).
 function sortperm(
     v::AbstractArray,
     backend::Backend=get_backend(v);
-
-    lt=isless,
-    by=identity,
-    rev::Union{Nothing, Bool}=nothing,
-    order::Base.Order.Ordering=Base.Order.Forward,
-
-    # CPU settings
-    max_tasks=Threads.nthreads(),
-    min_elems=1,
-
-    # GPU settings
-    block_size::Int=256,
-
-    # Temporary buffer, same size as `v`
-    temp::Union{Nothing, AbstractArray}=nothing,
+    kwargs...
 )
     ix = similar(v, Int)
     sortperm!(
-        ix, v, backend,
-        lt=lt, by=by, rev=rev, order=order,
-        max_tasks=max_tasks,
-        min_elems=min_elems,
-        block_size=block_size,
-        temp=temp,
+        ix, v, backend;
+        kwargs...
     )
 end
diff --git a/test/accumulate.jl b/test/accumulate.jl
index b50ba47..f3be80a 100644
--- a/test/accumulate.jl
+++ b/test/accumulate.jl
@@ -65,7 +65,7 @@
         y = similar(x)
         init = rand(-1000:1000)
         AK.accumulate!(+, y, x; init=Int32(init))
-        @test all(Array(y) .== accumulate(+, Array(x), init=init))
+        @test all(Array(y) .== accumulate(+, Array(x); init))
     end
 
     # Exclusive scan
@@ -106,10 +106,10 @@ end
                 for ksize in 0:3
                     sh = rand(Int32(1):Int32(100), isize, jsize, ksize)
                     s = array_from_host(sh)
-                    d = AK.accumulate(+, s; init=Int32(0), dims=dims)
+                    d = AK.accumulate(+, s; init=Int32(0), dims)
 
                     dh = Array(d)
-                    dhres = accumulate(+, sh, init=Int32(0), dims=dims)
+                    dhres = accumulate(+, sh; init=Int32(0), dims)
                     @test dh == dhres
                     @test eltype(dh) == eltype(dhres)
                 end
@@ -126,9 +126,9 @@ end
             vh = rand(Int32(1):Int32(100), n1, n2, n3)
             v = array_from_host(vh)
 
-            s = AK.accumulate(+, v; init=Int32(0), dims=dims)
+            s = AK.accumulate(+, v; init=Int32(0), dims)
             sh = Array(s)
-            @test sh == accumulate(+, vh, init=Int32(0), dims=dims)
+            @test sh == accumulate(+, vh; init=Int32(0), dims)
         end
     end
 
@@ -140,9 +140,9 @@ end
             vh = rand(UInt32(1):UInt32(100), n1, n2, n3)
             v = array_from_host(vh)
 
-            s = AK.accumulate(+, v; init=UInt32(0), dims=dims)
+            s = AK.accumulate(+, v; init=UInt32(0), dims)
             sh = Array(s)
-            @test sh == accumulate(+, vh, init=UInt32(0), dims=dims)
+            @test sh == accumulate(+, vh; init=UInt32(0), dims)
         end
     end
 
@@ -154,9 +154,9 @@ end
             vh = rand(Float32, n1, n2, n3)
             v = array_from_host(vh)
 
-            s = AK.accumulate(+, v; init=Float32(0), dims=dims)
+            s = AK.accumulate(+, v; init=Float32(0), dims)
             sh = Array(s)
-            @test all(sh .≈ accumulate(+, vh, init=Float32(0), dims=dims))
+            @test all(sh .≈ accumulate(+, vh; init=Float32(0), dims))
         end
     end
 
@@ -169,9 +169,9 @@ end
             vh = rand(Float32, n1, n2, n3)
             v = array_from_host(vh)
             init = rand(-1000:1000)
-            s = AK.accumulate(+, v; init=Float32(init), dims=dims)
+            s = AK.accumulate(+, v; init=Float32(init), dims)
             sh = Array(s)
-            @test all(sh .≈ accumulate(+, vh, init=Float32(init), dims=dims))
+            @test all(sh .≈ accumulate(+, vh; init=Float32(init), dims))
         end
     end
 
@@ -241,8 +241,8 @@ end
             # @test all(Array(AK.cumsum(v)) .== cumsum(vh))
 
             # Along dimensions
-            r = Array(AK.cumsum(v, dims=dims))
-            rh = cumsum(vh, dims=dims)
+            r = Array(AK.cumsum(v; dims))
+            rh = cumsum(vh; dims)
 
             @test r == rh
         end
@@ -257,6 +257,9 @@ end
     v = array_from_host(rand(-5:5, 100_000))
     AK.cumsum(v, block_size=64)
 
+    # Test that undefined kwargs are not accepted
+    @test_throws MethodError AK.cumsum(v; init=10, bad=:kwarg)
+
     # The other settings are stress-tested in reduce
 end
 
@@ -287,8 +290,8 @@ end
             # @test all(Array(AK.cumprod(v)) .== cumprod(vh))
 
             # Along dimensions
-            r = Array(AK.cumprod(v, dims=dims))
-            rh = cumprod(vh, dims=dims)
+            r = Array(AK.cumprod(v; dims))
+            rh = cumprod(vh; dims)
 
             @test r == rh
         end
@@ -298,5 +301,8 @@ end
     v = array_from_host(rand(-5:5, 100_000))
     AK.cumprod(v, block_size=64)
 
+    # Test that undefined kwargs are not accepted
+    @test_throws MethodError AK.cumprod(v; init=10, bad=:kwarg)
+
     # The other settings are stress-tested in reduce
 end
diff --git a/test/binarysearch.jl b/test/binarysearch.jl
index 806df71..b988cde 100644
--- a/test/binarysearch.jl
+++ b/test/binarysearch.jl
@@ -84,4 +84,10 @@
     AK.searchsortedfirst(vh, xh, by=abs, lt=(>), rev=true, max_tasks=10, min_elems=100)
     AK.searchsortedlast!(ixh, vh, xh, by=abs, lt=(>), rev=true, max_tasks=10, min_elems=100)
     AK.searchsortedlast(vh, xh, by=abs, lt=(>), rev=true, max_tasks=10, min_elems=100)
+
+    # Test that undefined kwargs are not accepted
+    @test_throws MethodError AK.searchsortedfirst!(ixh, vh, xh, by=abs, lt=(>), rev=true, max_tasks=10, min_elems=100, bad=:kwarg)
+    @test_throws MethodError AK.searchsortedfirst(vh, xh, by=abs, lt=(>), rev=true, max_tasks=10, min_elems=100, bad=:kwarg)
+    @test_throws MethodError AK.searchsortedlast!(ixh, vh, xh, by=abs, lt=(>), rev=true, max_tasks=10, min_elems=100, bad=:kwarg)
+    @test_throws MethodError AK.searchsortedlast(vh, xh, by=abs, lt=(>), rev=true, max_tasks=10, min_elems=100, bad=:kwarg)
 end
diff --git a/test/map.jl b/test/map.jl
index 95637d1..01c55bd 100644
--- a/test/map.jl
+++ b/test/map.jl
@@ -28,6 +28,8 @@
         end
         @test y == map(i -> i > 0.5 ? i : 0, x)
 
+        # Test that undefined kwargs are not accepted
+        @test_throws MethodError AK.map(x -> x^2, x; bad=:kwarg)
     # GPU
     else
         x = array_from_host(1:1000)
@@ -48,5 +50,8 @@
             i > 0.5 ? i : 0
         end
         @test Array(y) == map(i -> i > 0.5 ? i : 0, Array(x))
+
+        # Test that undefined kwargs are not accepted
+        @test_throws MethodError AK.map(x -> x^2, x; bad=:kwarg)
     end
 end
diff --git a/test/predicates.jl b/test/predicates.jl
index 13dbab3..cd589e1 100644
--- a/test/predicates.jl
+++ b/test/predicates.jl
@@ -34,10 +34,10 @@
         num_elems = rand(1:100_000)
         v = array_from_host(rand(Float32, num_elems))
         alg=AK.MapReduce(temp=similar(v, Bool), switch_below=100)
-        @test AK.any(x->x<0, v, alg=alg) === false
-        @test AK.any(x->x<1, v, alg=alg) === true
-        @test AK.all(x->x<1, v, alg=alg) === true
-        @test AK.all(x->x<0, v, alg=alg) === false
+        @test AK.any(x->x<0, v; alg) === false
+        @test AK.any(x->x<1, v; alg) === true
+        @test AK.all(x->x<1, v; alg) === true
+        @test AK.all(x->x<0, v; alg) === false
     end
 
     # Testing different settings
diff --git a/test/reduce.jl b/test/reduce.jl
index ec24f6a..7e9e4a6 100644
--- a/test/reduce.jl
+++ b/test/reduce.jl
@@ -106,7 +106,7 @@ Base.zero(::Type{Point}) = Point(0.0f0, 0.0f0)
         init = rand(1:100)
         s = AK.reduce(+, v; switch_below=switch_below, init=Int32(init))
         vh = Array(v)
-        @test s == reduce(+, vh, init=init)
+        @test s == reduce(+, vh; init)
     end
 
     # Test with unmaterialised ranges
@@ -118,6 +118,9 @@ Base.zero(::Type{Point}) = Point(0.0f0, 0.0f0)
         @test s == reduce(+, vh)
     end
 
+    # Test that undefined kwargs are not accepted
+    @test_throws MethodError AK.reduce(+, array_from_host(rand(Int32, 10)); init=10, bad=:kwarg)
+
     # Testing different settings
     AK.reduce(
         (x, y) -> x + 1,
@@ -151,10 +154,10 @@ end
                 for ksize in 0:3
                     sh = rand(Int32(1):Int32(100), isize, jsize, ksize)
                     s = array_from_host(sh)
-                    d = AK.reduce(+, s; init=Int32(10), dims=dims)
+                    d = AK.reduce(+, s; init=Int32(10), dims)
                     dh = Array(d)
-                    @test dh == sum(sh, init=Int32(10), dims=dims)
-                    @test eltype(dh) == eltype(sum(sh, init=Int32(10), dims=dims))
+                    @test dh == sum(sh; init=Int32(10), dims)
+                    @test eltype(dh) == eltype(sum(sh; init=Int32(10), dims))
                 end
             end
         end
@@ -168,9 +171,9 @@ end
             n3 = rand(1:100)
             vh = rand(Int32(1):Int32(100), n1, n2, n3)
             v = array_from_host(vh)
-            s = AK.reduce(+, v; init=Int32(0), dims=dims)
+            s = AK.reduce(+, v; init=Int32(0), dims)
             sh = Array(s)
-            @test sh == sum(vh, dims=dims)
+            @test sh == sum(vh; dims)
         end
     end
 
@@ -181,9 +184,9 @@ end
             n3 = rand(1:100)
             vh = rand(UInt32(1):UInt32(100), n1, n2, n3)
             v = array_from_host(vh)
-            s = AK.reduce(+, v; init=UInt32(0), dims=dims)
+            s = AK.reduce(+, v; init=UInt32(0), dims)
             sh = Array(s)
-            @test sh == sum(vh, dims=dims)
+            @test sh == sum(vh; dims)
         end
     end
 
@@ -194,9 +197,9 @@ end
             n3 = rand(1:100)
             vh = rand(Float32, n1, n2, n3)
             v = array_from_host(vh)
-            s = AK.reduce(+, v; init=Float32(0), dims=dims)
+            s = AK.reduce(+, v; init=Float32(0), dims)
             sh = Array(s)
-            @test sh ≈ sum(vh, dims=dims)
+            @test sh ≈ sum(vh; dims)
         end
     end
 
@@ -209,12 +212,15 @@ end
             vh = rand(Int32(1):Int32(100), n1, n2, n3)
             v = array_from_host(vh)
             init = rand(1:100)
-            s = AK.reduce(+, v; init=Int32(init), dims=dims)
+            s = AK.reduce(+, v; init=Int32(init), dims)
             sh = Array(s)
-            @test sh == reduce(+, vh, dims=dims, init=init)
+            @test sh == reduce(+, vh; dims, init)
         end
     end
 
+    # Test that undefined kwargs are not accepted
+    @test_throws MethodError AK.reduce(+, array_from_host(rand(Int32, 10, 10)); init=10, bad=:kwarg)
+
     # Testing different settings
     AK.reduce(
         (x, y) -> x + 1,
@@ -317,7 +323,7 @@ end
         init = rand(1:100)
         s = AK.mapreduce(abs, +, v; switch_below=switch_below, init=Int32(init))
         vh = Array(v)
-        @test s == mapreduce(abs, +, vh, init=init)
+        @test s == mapreduce(abs, +, vh; init)
     end
 
     # Test with unmaterialised ranges
@@ -345,6 +351,9 @@ end
     v = array_from_host([Point(rand(Float32), rand(Float32)) for _ in 1:10_042])
     temp = similar(v, Tuple{Float32, Float32})
     f(v, temp)
+
+    # Test that undefined kwargs are not accepted
+    @test_throws MethodError AK.mapreduce(-, +, v; init=10, bad=:kwarg)
 end
 
 
@@ -358,10 +367,10 @@ end
                 for ksize in 0:3
                     sh = rand(Int32(-100):Int32(100), isize, jsize, ksize)
                     s = array_from_host(sh)
-                    d = AK.mapreduce(-, +, s; init=Int32(-10), dims=dims)
+                    d = AK.mapreduce(-, +, s; init=Int32(-10), dims)
                     dh = Array(d)
-                    @test dh == mapreduce(-, +, sh, init=Int32(-10), dims=dims)
-                    @test eltype(dh) == eltype(mapreduce(-, +, sh, init=Int32(-10), dims=dims))
+                    @test dh == mapreduce(-, +, sh; init=Int32(-10), dims)
+                    @test eltype(dh) == eltype(mapreduce(-, +, sh; init=Int32(-10), dims))
                 end
             end
         end
@@ -375,9 +384,9 @@ end
             n3 = rand(1:100)
             vh = rand(Int32(1):Int32(100), n1, n2, n3)
             v = array_from_host(vh)
-            s = AK.mapreduce(-, +, v; init=Int32(0), dims=dims)
+            s = AK.mapreduce(-, +, v; init=Int32(0), dims)
             sh = Array(s)
-            @test sh == mapreduce(-, +, vh, init=Int32(0), dims=dims)
+            @test sh == mapreduce(-, +, vh; init=Int32(0), dims)
         end
     end
 
@@ -389,7 +398,7 @@ end
             s;
             init=(typemax(Float32), typemax(Float32)),
             neutral=(typemax(Float32), typemax(Float32)),
-            dims=dims,
+            dims,
         )
     end
 
@@ -400,7 +409,7 @@ end
             (a, b) -> (a[1] < b[1] ? a[1] : b[1], a[2] < b[2] ? a[2] : b[2]),
             s;
             init=(typemax(Float32), typemax(Float32)),
-            dims=dims,
+            dims,
         )
     end
 
@@ -434,12 +443,15 @@ end
             vh = rand(Int32(-100):Int32(100), n1, n2, n3)
             v = array_from_host(vh)
             init = rand(1:100)
-            s = AK.mapreduce(-, +, v; init=Int32(init), dims=dims)
+            s = AK.mapreduce(-, +, v; init=Int32(init), dims)
             sh = Array(s)
-            @test sh == mapreduce(-, +, vh, dims=dims, init=init)
+            @test sh == mapreduce(-, +, vh; dims, init)
         end
     end
 
+    # Test that undefined kwargs are not accepted
+    @test_throws MethodError AK.mapreduce(-, +, array_from_host(rand(Int32, 3, 4, 5)); init=10, bad=:kwarg)
+
     # Testing different settings
     AK.mapreduce(
         -,
@@ -495,8 +507,8 @@ end
             @test AK.sum(v) == sum(vh)
 
             # Along dimensions
-            r = Array(AK.sum(v, dims=dims))
-            rh = sum(vh, dims=dims)
+            r = Array(AK.sum(v; dims))
+            rh = sum(vh; dims)
 
             @test r == rh
         end
@@ -506,6 +518,9 @@ end
     v = array_from_host(rand(-5:5, 100_000))
     AK.sum(v, block_size=64)
 
+    # Test that undefined kwargs are not accepted
+    @test_throws MethodError AK.sum(v; bad=:kwarg)
+
     # The other settings are stress-tested in reduce
 end
 
@@ -537,8 +552,8 @@ end
             @test AK.sum(v) == sum(vh)
 
             # Along dimensions
-            r = Array(AK.sum(v, dims=dims))
-            rh = sum(vh, dims=dims)
+            r = Array(AK.sum(v; dims))
+            rh = sum(vh; dims)
 
             @test r == rh
         end
@@ -548,6 +563,9 @@ end
     v = array_from_host(rand(-5:5, 100_000))
     AK.prod(v, block_size=64)
 
+    # Test that undefined kwargs are not accepted
+    @test_throws MethodError AK.prod(v; bad=:kwarg)
+
     # The other settings are stress-tested in reduce
 end
 
@@ -579,8 +597,8 @@ end
             @test AK.minimum(v) == minimum(vh)
 
             # Along dimensions
-            r = Array(AK.minimum(v, dims=dims))
-            rh = minimum(vh, dims=dims)
+            r = Array(AK.minimum(v; dims))
+            rh = minimum(vh; dims)
 
             @test r == rh
         end
@@ -590,6 +608,9 @@ end
     v = array_from_host(rand(-5:5, 100_000))
     AK.minimum(v, block_size=64)
 
+    # Test that undefined kwargs are not accepted
+    @test_throws MethodError AK.minimum(v; bad=:kwarg)
+
     # The other settings are stress-tested in reduce
 end
 
@@ -621,8 +642,8 @@ end
             @test AK.maximum(v) == maximum(vh)
 
             # Along dimensions
-            r = Array(AK.maximum(v, dims=dims))
-            rh = maximum(vh, dims=dims)
+            r = Array(AK.maximum(v; dims))
+            rh = maximum(vh; dims)
 
             @test r == rh
         end
@@ -632,6 +653,9 @@ end
     v = array_from_host(rand(-5:5, 100_000))
     AK.maximum(v, block_size=64)
 
+    # Test that undefined kwargs are not accepted
+    @test_throws MethodError AK.maximum(v; bad=:kwarg)
+
     # The other settings are stress-tested in reduce
 end
 
@@ -663,8 +687,8 @@ end
             @test AK.count(x->x>0.5, v) == count(x->x>0.5, vh)
 
             # Along dimensions
-            r = Array(AK.count(x->x>0.5, v, dims=dims))
-            rh = count(x->x>0.5, vh, dims=dims)
+            r = Array(AK.count(x->x>0.5, v; dims))
+            rh = count(x->x>0.5, vh; dims)
 
             @test r == rh
         end
@@ -681,5 +705,8 @@ end
     v = array_from_host(rand(-5:5, 100_000))
     AK.count(x->x>0, v, block_size=64)
 
+    # Test that undefined kwargs are not accepted
+    @test_throws MethodError AK.count(v; bad=:kwarg)
+
     # The other settings are stress-tested in reduce
 end