diff --git a/examples/boundaries/boundaries.cpp b/examples/boundaries/boundaries.cpp
index 89185a4344..9d29e54cc9 100644
--- a/examples/boundaries/boundaries.cpp
+++ b/examples/boundaries/boundaries.cpp
@@ -64,11 +64,9 @@ template <typename T>
 struct direction_bc_input {
     T value;
 
-    GT_FUNCTION
-    direction_bc_input() : value(1) {}
+    constexpr direction_bc_input() : value(1) {}
 
-    GT_FUNCTION
-    direction_bc_input(T v) : value(v) {}
+    constexpr direction_bc_input(T v) : value(v) {}
 
     // This is the primary template and it will be picked when all the other specializations below fail to be selected.
     // It is important for debugging to note that, if a needed specialization i missing, this version will be selected.
diff --git a/examples/stencil/tridiagonal_solver.cpp b/examples/stencil/tridiagonal_solver.cpp
index 5556c4bfc9..a6d36712db 100644
--- a/examples/stencil/tridiagonal_solver.cpp
+++ b/examples/stencil/tridiagonal_solver.cpp
@@ -114,8 +114,7 @@ int main() {
 
     // Here we make the computation, specifying the backend, the grid (iteration space), binding of the spec arguments
     // to the fields
-    st::run(
-        spec, stencil_backend_t(), grid, st::make_global_parameter(-1), st::make_global_parameter(3), sup, rhs, out);
+    st::run(spec, stencil_backend_t(), grid, st::global_parameter(-1), st::global_parameter(3), sup, rhs, out);
 
     // In this simple example the solution is known and we can easily check it.
     auto view = out->const_host_view();
diff --git a/examples/stencil_type_erasure/interpolate_stencil.cpp b/examples/stencil_type_erasure/interpolate_stencil.cpp
index b984a32353..89107a4c05 100644
--- a/examples/stencil_type_erasure/interpolate_stencil.cpp
+++ b/examples/stencil_type_erasure/interpolate_stencil.cpp
@@ -48,6 +48,6 @@ namespace {
 std::function<void(inputs, outputs)> make_interpolate_stencil(grid_t grid, double weight) {
     return [grid = std::move(grid), weight](inputs in, outputs out) {
         run_single_stage(
-            interpolate_stage(), stencil_backend_t(), grid, in.in1, in.in2, make_global_parameter(weight), out.out);
+            interpolate_stage(), stencil_backend_t(), grid, in.in1, in.in2, global_parameter(weight), out.out);
     };
 }
diff --git a/include/gridtools/boundaries/apply_gpu.hpp b/include/gridtools/boundaries/apply_gpu.hpp
index 66cb731f02..cd3541492a 100644
--- a/include/gridtools/boundaries/apply_gpu.hpp
+++ b/include/gridtools/boundaries/apply_gpu.hpp
@@ -69,7 +69,7 @@ namespace gridtools {
               private:
                 /** Computation of the bit-index in `m_predicate_values` of the given direction. */
                 template <sign I, sign J, sign K>
-                GT_FUNCTION static constexpr uint_t direction_index(direction<I, J, K>) {
+                static constexpr uint_t direction_index(direction<I, J, K>) {
                     // computation of the bit-index of the given direction
                     constexpr int_t stride_i = 9;
                     constexpr int_t stride_j = 3;
@@ -133,23 +133,12 @@ namespace gridtools {
                         }
                     }
 
-                    GT_FUNCTION
-                    uint_t max() const { return m_sorted[0]; }
-
-                    GT_FUNCTION
-                    uint_t min() const { return m_sorted[2]; }
-
-                    GT_FUNCTION
-                    uint_t median() const { return m_sorted[1]; }
-
-                    GT_FUNCTION
-                    uint_t size(uint_t i) const { return m_size[i]; }
-
-                    GT_FUNCTION
-                    uint_t perm(uint_t i) const { return m_perm[i]; }
-
-                    GT_FUNCTION
-                    uint_t start(uint_t i) const { return m_start[i]; }
+                    constexpr uint_t max() const { return m_sorted[0]; }
+                    constexpr uint_t min() const { return m_sorted[2]; }
+                    constexpr uint_t median() const { return m_sorted[1]; }
+                    constexpr uint_t size(uint_t i) const { return m_size[i]; }
+                    constexpr uint_t perm(uint_t i) const { return m_perm[i]; }
+                    constexpr uint_t start(uint_t i) const { return m_start[i]; }
                 };
 
                 array<array<array<shape_type, 3>, 3>, 3> sizes;
@@ -219,12 +208,12 @@ namespace gridtools {
                 };
 
                 template <sign I, sign J, sign K>
-                GT_FUNCTION shape_type const &shape(direction<I, J, K>) const {
+                constexpr shape_type const &shape(direction<I, J, K>) const {
                     return sizes[I + 1][J + 1][K + 1];
                 }
             };
 
-            GT_FUNCTION int thread_along_axis(int i, int j, int k, int axis) {
+            constexpr int thread_along_axis(int i, int j, int k, int axis) {
                 assert(axis >= 0 && axis < 3);
                 return axis == 0 ? i : axis == 1 ? j : k;
             }
@@ -240,7 +229,7 @@ namespace gridtools {
                 const uint_t i = blockIdx.x * apply_gpu_impl_::threads_per_block_x_t::value + threadIdx.x;
                 const uint_t j = blockIdx.y * apply_gpu_impl_::threads_per_block_y_t::value + threadIdx.y;
                 const uint_t k = blockIdx.z * apply_gpu_impl_::threads_per_block_z_t::value + threadIdx.z;
-                device::for_each<directions_t>([&](auto dir) {
+                for_each<directions_t>([&](auto dir) {
                     if (predicate(dir)) {
                         auto const &shape = conf.shape(dir);
                         if (i < shape.max() && j < shape.median() && k < shape.min()) {
@@ -299,7 +288,7 @@ namespace gridtools {
             (DataField0, Datafield1, DataField2, ...)
             */
             template <typename... DataFieldViews>
-            void apply(DataFieldViews const &... data_field_views) const {
+            void apply(DataFieldViews const &...data_field_views) const {
                 apply_gpu_impl_::loop_kernel<<<m_conf.kernel_grid_size(), m_conf.kernel_thread_block_size()>>>(
                     m_boundary_function, m_predicate, m_conf, data_field_views...);
                 GT_CUDA_CHECK(cudaGetLastError());
diff --git a/include/gridtools/common/array.hpp b/include/gridtools/common/array.hpp
index 429b910d85..790faaa6e7 100644
--- a/include/gridtools/common/array.hpp
+++ b/include/gridtools/common/array.hpp
@@ -12,8 +12,8 @@
 @file
 @brief Implementation of an array class
 */
+
 #include <algorithm>
-#include <cassert>
 #include <iterator>
 #include <tuple>
 #include <type_traits>
@@ -23,9 +23,7 @@
 #include "../meta/list.hpp"
 #include "../meta/macros.hpp"
 #include "../meta/repeat.hpp"
-#include "defs.hpp"
 #include "host_device.hpp"
-#include "utility.hpp"
 
 namespace gridtools {
 
@@ -61,32 +59,28 @@ namespace gridtools {
         using reverse_iterator = std::reverse_iterator<iterator>;
         using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
-        GT_FUNCTION constexpr T const *begin() const { return &m_array[0]; }
+        GT_FORCE_INLINE constexpr T const *begin() const { return &m_array[0]; }
 
-        GT_FUNCTION constexpr T *begin() { return &m_array[0]; }
+        GT_FORCE_INLINE constexpr T *begin() { return &m_array[0]; }
 
-        GT_FUNCTION constexpr T const *end() const { return &m_array[D]; }
+        GT_FORCE_INLINE constexpr T const *end() const { return &m_array[D]; }
 
-        GT_FUNCTION constexpr T *end() { return &m_array[D]; }
+        GT_FORCE_INLINE constexpr T *end() { return &m_array[D]; }
 
-        GT_FUNCTION constexpr const T *data() const noexcept { return m_array; }
-        GT_FUNCTION constexpr T *data() noexcept { return m_array; }
+        GT_FORCE_INLINE constexpr const T *data() const noexcept { return m_array; }
+        GT_FORCE_INLINE constexpr T *data() noexcept { return m_array; }
 
-        GT_FUNCTION GT_CONSTEXPR T const &operator[](size_t i) const { return m_array[i]; }
+        GT_FORCE_INLINE constexpr T const &operator[](size_t i) const { return m_array[i]; }
 
-        GT_FUNCTION T &operator[](size_t i) {
-            assert(i < D);
-            return m_array[i];
-        }
+        GT_FORCE_INLINE constexpr T &operator[](size_t i) { return m_array[i]; }
 
         template <typename A>
-        GT_FUNCTION array &operator=(A const &a) {
-            assert(a.size() == D);
+        GT_FORCE_INLINE constexpr array &operator=(A const &a) {
             std::copy(a.begin(), a.end(), m_array);
             return *this;
         }
 
-        GT_FUNCTION static constexpr size_t size() { return D; }
+        static GT_FORCE_INLINE constexpr size_t size() { return D; }
     };
 
     template <class T, class... Ts>
@@ -108,21 +102,21 @@ namespace gridtools {
 
         struct getter {
             template <size_t I, typename T, size_t D>
-            static GT_FUNCTION GT_CONSTEXPR T &get(array<T, D> &arr) noexcept {
+            static GT_FORCE_INLINE constexpr T &get(array<T, D> &arr) noexcept {
                 static_assert(I < D, "index is out of bounds");
                 return arr.m_array[I];
             }
 
             template <size_t I, typename T, size_t D>
-            static GT_FUNCTION GT_CONSTEXPR const T &get(const array<T, D> &arr) noexcept {
+            static GT_FORCE_INLINE constexpr const T &get(const array<T, D> &arr) noexcept {
                 static_assert(I < D, "index is out of bounds");
                 return arr.m_array[I];
             }
 
             template <size_t I, typename T, size_t D>
-            static GT_FUNCTION GT_CONSTEXPR T &&get(array<T, D> &&arr) noexcept {
+            static GT_FORCE_INLINE constexpr T &&get(array<T, D> &&arr) noexcept {
                 static_assert(I < D, "index is out of bounds");
-                return wstd::move(arr.m_array[I]);
+                return std::move(arr.m_array[I]);
             }
         };
     } // namespace array_impl_
@@ -138,7 +132,7 @@ namespace gridtools {
 
     // in case we need a constexpr version we need to implement a recursive one for c++11
     template <typename T, typename U, size_t D>
-    GT_CONSTEXPR GT_FUNCTION bool operator==(array<T, D> const &a, array<U, D> const &b) {
+    GT_FORCE_INLINE constexpr bool operator==(array<T, D> const &a, array<U, D> const &b) {
 #ifndef __GNUC__
 #pragma unroll
 #endif
@@ -150,7 +144,7 @@ namespace gridtools {
     }
 
     template <typename T, typename U, size_t D>
-    GT_CONSTEXPR GT_FUNCTION bool operator!=(array<T, D> const &a, array<U, D> const &b) {
+    GT_FORCE_INLINE constexpr bool operator!=(array<T, D> const &a, array<U, D> const &b) {
         return !(a == b);
     }
 
@@ -167,21 +161,21 @@ namespace gridtools {
     struct is_array_of<array<Value, D>, Value> : std::true_type {};
 
     template <size_t I, typename T, size_t D>
-    GT_FUNCTION T &get(array<T, D> &arr) noexcept {
+    GT_FORCE_INLINE constexpr T &get(array<T, D> &arr) noexcept {
         static_assert(I < D, "index is out of bounds");
         return arr.m_array[I];
     }
 
     template <size_t I, typename T, size_t D>
-    GT_FUNCTION GT_CONSTEXPR const T &get(const array<T, D> &arr) noexcept {
+    GT_FORCE_INLINE constexpr const T &get(const array<T, D> &arr) noexcept {
         static_assert(I < D, "index is out of bounds");
         return arr.m_array[I];
     }
 
     template <size_t I, typename T, size_t D>
-    GT_FUNCTION GT_CONSTEXPR T &&get(array<T, D> &&arr) noexcept {
+    GT_FORCE_INLINE constexpr T &&get(array<T, D> &&arr) noexcept {
         static_assert(I < D, "index is out of bounds");
-        return wstd::move(get<I>(arr));
+        return std::move(get<I>(arr));
     }
 
     /** @} */
diff --git a/include/gridtools/common/atomic_host.hpp b/include/gridtools/common/atomic_host.hpp
index 1d5a30c395..576e58d385 100644
--- a/include/gridtools/common/atomic_host.hpp
+++ b/include/gridtools/common/atomic_host.hpp
@@ -8,7 +8,11 @@
  * SPDX-License-Identifier: BSD-3-Clause
  */
 #pragma once
+
 #include <algorithm>
+
+#include "host_device.hpp"
+
 namespace gridtools {
 
     /** \ingroup common
@@ -27,8 +31,7 @@ namespace gridtools {
          * @param val value added to var
          * @return the old value contained in var
          */
-        GT_FUNCTION
-        static T atomic_add(T &var, const T val) {
+        static GT_FORCE_INLINE constexpr T atomic_add(T &var, const T val) {
 #if _OPENMP > 201106
             T old;
 #pragma omp atomic capture
@@ -54,8 +57,7 @@ namespace gridtools {
          * @param val value added to var
          * @return the old value contained in var
          */
-        GT_FUNCTION
-        static T atomic_sub(T &var, const T val) {
+        static GT_FORCE_INLINE constexpr T atomic_sub(T &var, const T val) {
 #if _OPENMP > 201106
             T old;
 #pragma omp atomic capture
@@ -81,8 +83,7 @@ namespace gridtools {
          * @param val value inserted in variable var
          * @return the old value contained in var
          */
-        GT_FUNCTION
-        static T atomic_exch(T &var, const T val) {
+        static GT_FORCE_INLINE constexpr T atomic_exch(T &var, const T val) {
 #if _OPENMP > 201106
             T old;
 #pragma omp atomic capture
@@ -108,8 +109,7 @@ namespace gridtools {
          * @param val value used in the min comparison
          * @return the old value contained in var
          */
-        GT_FUNCTION
-        static T atomic_min(T &var, const T val) {
+        static GT_FORCE_INLINE constexpr T atomic_min(T &var, const T val) {
             T old;
 #pragma omp critical(min)
             {
@@ -125,8 +125,7 @@ namespace gridtools {
          * @param val value used in the min comparison
          * @return the old value contained in var
          */
-        GT_FUNCTION
-        static T atomic_max(T &var, const T val) {
+        static GT_FORCE_INLINE constexpr T atomic_max(T &var, const T val) {
             T old;
 #pragma omp critical(max)
             {
diff --git a/include/gridtools/common/compose.hpp b/include/gridtools/common/compose.hpp
index 4f9c127639..f87a0cbc8a 100644
--- a/include/gridtools/common/compose.hpp
+++ b/include/gridtools/common/compose.hpp
@@ -7,64 +7,23 @@
  * Please, refer to the LICENSE file in the root directory.
  * SPDX-License-Identifier: BSD-3-Clause
  */
+#pragma once
 
-#ifndef GT_TARGET_ITERATING
-// DON'T USE #pragma once HERE!!!
-#ifndef GT_COMMON_COMPOSE_HPP_
-#define GT_COMMON_COMPOSE_HPP_
-
-#include "../meta.hpp"
-#include "defs.hpp"
-#include "host_device.hpp"
-#include "utility.hpp"
-
-#define GT_FILENAME <gridtools/common/compose.hpp>
-#include GT_ITERATE_ON_TARGETS()
-#undef GT_FILENAME
-
-#endif // GT_COMMON_COMPOSE_HPP_
-#else  // GT_TARGET_ITERATING
+#include <utility>
 
 namespace gridtools {
-    GT_TARGET_NAMESPACE {
-        namespace compose_impl_ {
-            template <class... Funs>
-            struct composed_f;
-
-            template <class F, class G>
-            struct composed_f<F, G> {
-                F m_f;
-                G m_g;
-
-                template <class... Args>
-                GT_TARGET_CONSTEXPR GT_TARGET GT_FORCE_INLINE std::result_of_t<F(std::result_of_t<G(Args &&...)>)>
-                operator()(Args &&... args) const {
-                    return m_f(m_g(wstd::forward<Args>(args)...));
-                }
-            };
-
-            template <class F, class... Fs>
-            struct composed_f<F, Fs...> : composed_f<F, composed_f<Fs...>> {
-                GT_TARGET_CONSTEXPR GT_TARGET GT_FORCE_INLINE composed_f(F f, Fs... fs)
-                    : composed_f<F, composed_f<Fs...>>{wstd::move(f), {wstd::move(fs)...}} {}
-            };
-        } // namespace compose_impl_
-
-        /// Make function composition from provided functions
-        ///
-        /// compose(a, b, c)(x, y) <==> a(b(c(x, y)))
-        ///
-        template <class... Funs>
-        GT_TARGET_CONSTEXPR GT_TARGET GT_FORCE_INLINE compose_impl_::composed_f<std::decay_t<Funs>...> compose(
-            Funs && ... funs) {
-            return {wstd::forward<Funs>(funs)...};
-        }
+    /// Make function composition from provided functions
+    ///
+    /// compose(a, b, c)(x, y) <==> a(b(c(x, y)))
+    ///
+    template <class F>
+    constexpr F &&compose(F &&f) {
+        return std::forward<F>(f);
+    }
 
-        template <class Fun>
-        GT_TARGET_CONSTEXPR GT_TARGET GT_FORCE_INLINE Fun compose(Fun && fun) {
-            return fun;
-        }
+    template <class F, class... Fs>
+    constexpr auto compose(F &&f, Fs &&...fs) {
+        return [f = std::forward<F>(f), fs = compose(std::forward<Fs>(fs)...)](
+                   auto &&...args) { return f(fs(std::forward<decltype(args)>(args)...)); };
     }
 } // namespace gridtools
-
-#endif // GT_TARGET_ITERATING
diff --git a/include/gridtools/common/cuda_util.hpp b/include/gridtools/common/cuda_util.hpp
index 30cc3b2574..907f55fbf4 100644
--- a/include/gridtools/common/cuda_util.hpp
+++ b/include/gridtools/common/cuda_util.hpp
@@ -60,14 +60,14 @@ namespace gridtools {
             return unique_cuda_ptr<T>{ptr};
         }
 
-        template <class T, std::enable_if_t<std::is_trivially_copyable<T>::value, int> = 0>
+        template <class T, std::enable_if_t<std::is_trivially_copy_constructible_v<T>, int> = 0>
         unique_cuda_ptr<T> make_clone(T const &src) {
             unique_cuda_ptr<T> res = cuda_malloc<T>();
             GT_CUDA_CHECK(cudaMemcpy(res.get(), &src, sizeof(T), cudaMemcpyHostToDevice));
             return res;
         }
 
-        template <class T, std::enable_if_t<std::is_trivially_copyable<T>::value, int> = 0>
+        template <class T, std::enable_if_t<std::is_trivially_copy_constructible_v<T>, int> = 0>
         T from_clone(unique_cuda_ptr<T> const &clone) {
             T res;
             GT_CUDA_CHECK(cudaMemcpy(&res, clone.get(), sizeof(T), cudaMemcpyDeviceToHost));
diff --git a/include/gridtools/common/defs.hpp b/include/gridtools/common/defs.hpp
index d96f34806b..957f9b1465 100644
--- a/include/gridtools/common/defs.hpp
+++ b/include/gridtools/common/defs.hpp
@@ -26,8 +26,6 @@ namespace gridtools {
 #endif
 #endif
 
-#define GT_CONSTEXPR constexpr
-
 #ifdef __cpp_consteval
 #define GT_CONSTEVAL consteval
 #else
diff --git a/include/gridtools/common/enable_maker.hpp b/include/gridtools/common/enable_maker.hpp
index f3d030b56e..50908b6800 100644
--- a/include/gridtools/common/enable_maker.hpp
+++ b/include/gridtools/common/enable_maker.hpp
@@ -21,7 +21,7 @@ namespace gridtools {
         template <template <class...> class L>
         struct maker {
             template <class... Args>
-            constexpr GT_FUNCTION L<Args...> operator()(Args const &...args) const {
+            GT_FORCE_INLINE constexpr L<Args...> operator()(Args const &...args) const {
                 return {args...};
             }
         };
diff --git a/include/gridtools/common/for_each.hpp b/include/gridtools/common/for_each.hpp
index bcf37f445b..bf5be84f1f 100644
--- a/include/gridtools/common/for_each.hpp
+++ b/include/gridtools/common/for_each.hpp
@@ -7,41 +7,24 @@
  * Please, refer to the LICENSE file in the root directory.
  * SPDX-License-Identifier: BSD-3-Clause
  */
-#ifndef GT_TARGET_ITERATING
-// DON'T USE #pragma once HERE!!!
-#ifndef GT_COMMON_GENERIC_METAFUNCTIONS_FOR_EACH_HPP_
-#define GT_COMMON_GENERIC_METAFUNCTIONS_FOR_EACH_HPP_
+#pragma once
 
 #include "host_device.hpp"
 
-#define GT_FILENAME <gridtools/common/for_each.hpp>
-#include GT_ITERATE_ON_TARGETS()
-#undef GT_FILENAME
-
-#endif
-#else
-
 namespace gridtools {
-    GT_TARGET_NAMESPACE {
-        namespace for_each_impl_ {
-            template <class>
-            struct for_each_f;
+    template <class>
+    struct for_each_impl_;
 
-            template <template <class...> class L, class... Ts>
-            struct for_each_f<L<Ts...>> {
-                template <class F>
-                GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR void operator()(F &&f) const {
-                    (..., f(Ts()));
-                }
-            };
-        } // namespace for_each_impl_
+    template <template <class...> class L, class... Ts>
+    struct for_each_impl_<L<Ts...>> {
+        template <class F>
+        static GT_FORCE_INLINE constexpr void apply(F const &f) {
+            (..., f(Ts()));
+        }
+    };
 
-        template <class L>
-#if defined(GT_TARGET_HAS_DEVICE) and defined(__NVCC__)
-        GT_DEVICE
-#endif
-        constexpr for_each_impl_::for_each_f<L> for_each = {};
+    template <class L, class F>
+    GT_FORCE_INLINE constexpr void for_each(F const &f) {
+        for_each_impl_<L>::apply(f);
     }
 } // namespace gridtools
-
-#endif
diff --git a/include/gridtools/common/functional.hpp b/include/gridtools/common/functional.hpp
index 817874fa10..87726a6de4 100644
--- a/include/gridtools/common/functional.hpp
+++ b/include/gridtools/common/functional.hpp
@@ -10,29 +10,12 @@
 /**
 @file
 @brief Unstructured collection of small generic purpose functors and related helpers.
-
-   All functors here are supplied with the inner result or result_type to follow boost::result_of requirement
-   for the cases if BOOST_RESULT_OF_USE_DECLTYPE is not defined [It is so for nvcc8]. This makes those functors
-   usable in the context of boost::fuison high order functions.
-
 */
-
-#ifndef GT_TARGET_ITERATING
-// DON'T USE #pragma once HERE!!!
-#ifndef GT_COMMON_FUNCTIONAL_HPP_
-#define GT_COMMON_FUNCTIONAL_HPP_
+#pragma once
 
 #include <utility>
 
 #include "host_device.hpp"
-#include "utility.hpp"
-
-#define GT_FILENAME <gridtools/common/functional.hpp>
-#include GT_ITERATE_ON_TARGETS()
-#undef GT_FILENAME
-
-#endif
-#else
 
 namespace gridtools {
     /** \ingroup common
@@ -40,67 +23,46 @@ namespace gridtools {
         \defgroup functional Functional
         @{
     */
-    GT_TARGET_NAMESPACE {
-
-        /// Forward the args to constructor.
-        //
-        template <typename T>
-        struct ctor {
-            template <typename... Args>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR T operator()(Args &&... args) const {
-                return {wstd::forward<Args>(args)...};
-            }
-        };
-
-        /// Do nothing.
-        //
-        struct noop {
-            template <typename... Args>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR void operator()(Args &&...) const {}
-        };
-
-        /// Perfectly forward the argument.
-        //
-        struct identity {
-            template <typename Arg>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Arg operator()(Arg &&arg) const {
-                return arg;
-            }
-        };
-
-        /// Copy the argument.
-        //
-        struct clone {
-            template <typename Arg>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Arg operator()(Arg const &arg) const {
-                return arg;
-            }
-        };
-
-        template <class...>
-        struct overloaded_f;
-
-        template <class F>
-        struct overloaded_f<F> : F {
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR overloaded_f(F f) : F(wstd::move(f)) {}
-            using F::operator();
-        };
-
-        template <class F, class... Fs>
-        struct overloaded_f<F, Fs...> : F, overloaded_f<Fs...> {
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR overloaded_f(F f, Fs... fs)
-                : F(wstd::move(f)), overloaded_f<Fs...>(wstd::move(fs)...) {}
-            using F::operator();
-            using overloaded_f<Fs...>::operator();
-        };
-
-        template <class... Funs>
-        GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR overloaded_f<Funs...> overload(Funs... funs) {
-            return {wstd::move(funs)...};
+    /// Forward the args to constructor.
+    //
+    template <class T>
+    struct ctor {
+        template <class... Args>
+        GT_FORCE_INLINE constexpr T operator()(Args &&...args) const {
+            return {std::forward<Args>(args)...};
         }
-    }
+    };
+
+    /// Do nothing.
+    //
+    struct noop {
+        template <class... Args>
+        GT_FORCE_INLINE constexpr void operator()(Args &&...) const {}
+    };
+
+    /// Perfectly forward the argument.
+    //
+    struct identity {
+        template <class Arg>
+        GT_FORCE_INLINE constexpr Arg operator()(Arg &&arg) const {
+            return arg;
+        }
+    };
+
+    /// Copy the argument.
+    //
+    struct clone {
+        template <class Arg>
+        GT_FORCE_INLINE constexpr Arg operator()(Arg const &arg) const {
+            return arg;
+        }
+    };
+
+    template <class... Fs>
+    struct overload : Fs... {
+        constexpr overload(Fs... fs) : Fs(std::move(fs))... {}
+        using Fs::operator()...;
+    };
     /** @} */
     /** @} */
 } // namespace gridtools
-
-#endif
diff --git a/include/gridtools/common/gt_math.hpp b/include/gridtools/common/gt_math.hpp
index a4439553c7..e57e3a5cbc 100644
--- a/include/gridtools/common/gt_math.hpp
+++ b/include/gridtools/common/gt_math.hpp
@@ -25,20 +25,20 @@ namespace gridtools {
     */
 
     /**@brief Class in substitution of std::pow, not available in CUDA*/
-    template <uint_t Number>
+    template <size_t N>
     struct gt_pow {
-        template <typename Value>
-        GT_FUNCTION static Value constexpr apply(Value const &v) {
-            return v * gt_pow<Number - 1>::apply(v);
+        template <class T>
+        static constexpr T apply(T const &v) {
+            return v * gt_pow<N - 1>::apply(v);
         }
     };
 
     /**@brief Class in substitution of std::pow, not available in CUDA*/
     template <>
     struct gt_pow<0> {
-        template <typename Value>
-        GT_FUNCTION static Value constexpr apply(Value const &) {
-            return 1.;
+        template <class T>
+        static constexpr T apply(T const &) {
+            return 1;
         }
     };
 
@@ -47,42 +47,44 @@ namespace gridtools {
      * @param num value to ceil
      * @return ceiled value
      */
-    GT_FUNCTION GT_CONSTEXPR static int gt_ceil(float num) {
-        return (static_cast<float>(static_cast<int>(num)) == num) ? static_cast<int>(num)
-                                                                  : static_cast<int>(num) + ((num > 0) ? 1 : 0);
+    GT_FORCE_INLINE constexpr int gt_ceil(float num) {
+        int n = static_cast<int>(num);
+        return static_cast<float>(n) == num ? n : n + num > 0 ? 1 : 0;
     }
 
     namespace math {
-        template <typename Value>
-        GT_FUNCTION GT_CONSTEXPR Value const &max(Value const &val0) {
+        template <class Value>
+        GT_FORCE_INLINE constexpr Value const &max(Value const &val0) {
             return val0;
         }
 
-        template <typename Value>
-        GT_FUNCTION GT_CONSTEXPR Value const &max(Value const &val0, Value const &val1) {
+        template <class Value>
+        GT_FORCE_INLINE constexpr Value const &max(Value const &val0, Value const &val1) {
             return val0 > val1 ? val0 : val1;
         }
 
-        template <typename Value, typename... OtherValues>
-        GT_FUNCTION GT_CONSTEXPR Value const &max(Value const &val0, Value const &val1, OtherValues const &... vals) {
+        template <class Value, class... Values>
+        GT_FORCE_INLINE constexpr Value const &max(Value const &val0, Value const &val1, Values const &...vals) {
             return val0 > max(val1, vals...) ? val0 : max(val1, vals...);
         }
 
-        template <typename Value>
-        GT_FUNCTION GT_CONSTEXPR Value const &min(Value const &val0) {
+        template <class Value>
+        GT_FORCE_INLINE constexpr Value const &min(Value const &val0) {
             return val0;
         }
 
         template <typename Value>
-        GT_FUNCTION GT_CONSTEXPR Value const &min(Value const &val0, Value const &val1) {
+        GT_FORCE_INLINE constexpr Value const &min(Value const &val0, Value const &val1) {
             return val0 > val1 ? val1 : val0;
         }
 
-        template <typename Value, typename... OtherValues>
-        GT_FUNCTION GT_CONSTEXPR Value const &min(Value const &val0, Value const &val1, OtherValues const &... vals) {
+        template <typename Value, typename... Values>
+        GT_FORCE_INLINE constexpr Value const &min(Value const &val0, Value const &val1, Values const &...vals) {
             return val0 > min(val1, vals...) ? min(val1, vals...) : val0;
         }
 
+// Note that as for C++20, std functions in <cmath>  are not constexpr. 
+
 #if defined(GT_CUDACC) && defined(__NVCC__)
         // providing the same overload pattern as the std library
         // auto return type to ensure that we do not accidentally cast
diff --git a/include/gridtools/common/halo_descriptor.hpp b/include/gridtools/common/halo_descriptor.hpp
index 24bce7425f..c761030308 100644
--- a/include/gridtools/common/halo_descriptor.hpp
+++ b/include/gridtools/common/halo_descriptor.hpp
@@ -54,12 +54,12 @@ namespace gridtools {
          * initialized values that are subsequently copy constructed (since this is a POD structure it can be copied
          * without an explicit copy constructor.
          */
-        GT_FUNCTION halo_descriptor() : halo_descriptor(0, 0, 0, 0, 1) {}
+        GT_FORCE_INLINE constexpr halo_descriptor() : halo_descriptor(0, 0, 0, 0, 1) {}
 
         /**
          * @brief simple ctor without halos and padding
          */
-        GT_FUNCTION halo_descriptor(uint_t size) : halo_descriptor(0, 0, 0, size - 1, size) {}
+        GT_FORCE_INLINE constexpr halo_descriptor(uint_t size) : halo_descriptor(0, 0, 0, size - 1, size) {}
 
         /** Main constructors where the five integers are passed.
           \code
@@ -75,7 +75,7 @@ namespace gridtools {
           \param[in] e The end parameter (inclusive)
           \param[in] l The total_length parameter
          */
-        GT_FUNCTION halo_descriptor(uint_t m, uint_t p, uint_t b, uint_t e, uint_t l)
+        GT_FORCE_INLINE constexpr halo_descriptor(uint_t m, uint_t p, uint_t b, uint_t e, uint_t l)
             : m_minus(m), m_plus(p), m_begin(b), m_end(e), m_total_length(l) {
             assert(m_minus + m_plus + (m_end - m_begin + 1) <= m_total_length);
             assert(m_begin <= m_end);
@@ -87,7 +87,7 @@ namespace gridtools {
            Begin index for the loop on the outside region.
            \param[in] I relative coordinate of the neighbor (the \f$eta\f$ parameter in \link MULTI_DIM_ACCESS \endlink)
         */
-        GT_FUNCTION int_t loop_low_bound_outside(
+        GT_FORCE_INLINE constexpr int_t loop_low_bound_outside(
             int_t I) const { // inside is the fact that the halos are ones outside the begin-end region
             switch (I) {
             case 0:
@@ -106,7 +106,7 @@ namespace gridtools {
            End index for the loop on the outside region.
            \param[in] I relative coordinate of the neighbor (the \f$eta\f$ parameter in \link MULTI_DIM_ACCESS \endlink)
          */
-        GT_FUNCTION int_t loop_high_bound_outside(
+        GT_FORCE_INLINE constexpr int_t loop_high_bound_outside(
             int_t I) const { // inside is the fact that the halos are ones outside the begin-end region
             switch (I) {
             case 0:
@@ -125,7 +125,7 @@ namespace gridtools {
            Begin index for the loop on the inside region.
            \param[in] I relative coordinate of the neighbor (the \f$eta\f$ parameter in \link MULTI_DIM_ACCESS \endlink)
          */
-        GT_FUNCTION int_t loop_low_bound_inside(
+        GT_FORCE_INLINE constexpr int_t loop_low_bound_inside(
             int_t I) const { // inside is the fact that the halos are ones outside the begin-end region
 
             switch (I) {
@@ -145,7 +145,7 @@ namespace gridtools {
            End index for the loop on the inside region.
            \param[in] I relative coordinate of the neighbor (the \f$eta\f$ parameter in \link MULTI_DIM_ACCESS \endlink)
          */
-        GT_FUNCTION int_t loop_high_bound_inside(
+        GT_FORCE_INLINE constexpr int_t loop_high_bound_inside(
             int_t I) const { // inside is the fact that the halos are ones outside the begin-end region
             switch (I) {
             case 0:
@@ -166,7 +166,7 @@ namespace gridtools {
            \param[in] I relative coordinate of the neighbor (the \f$eta\f$ parameter in \link MULTI_DIM_ACCESS
            \endlink)
         */
-        GT_FUNCTION uint_t r_length(int_t I) const {
+        GT_FORCE_INLINE constexpr uint_t r_length(int_t I) const {
             switch (I) {
             case 0:
                 return (m_end - m_begin + 1);
@@ -186,7 +186,7 @@ namespace gridtools {
            \param[in] I relative coordinate of the neighbor (the \f$eta\f$ parameter in \link MULTI_DIM_ACCESS
            \endlink)
         */
-        GT_FUNCTION uint_t s_length(int_t I) const {
+        GT_FORCE_INLINE constexpr uint_t s_length(int_t I) const {
             switch (I) {
             case 0:
                 return (m_end - m_begin + 1);
@@ -200,30 +200,30 @@ namespace gridtools {
             }
         }
 
-        GT_FUNCTION uint_t minus() const { return m_minus; }
-        GT_FUNCTION uint_t plus() const { return m_plus; }
-        GT_FUNCTION uint_t begin() const { return m_begin; }
-        GT_FUNCTION uint_t end() const { return m_end; }
-        GT_FUNCTION uint_t total_length() const { return m_total_length; }
+        GT_FORCE_INLINE constexpr uint_t minus() const { return m_minus; }
+        GT_FORCE_INLINE constexpr uint_t plus() const { return m_plus; }
+        GT_FORCE_INLINE constexpr uint_t begin() const { return m_begin; }
+        GT_FORCE_INLINE constexpr uint_t end() const { return m_end; }
+        GT_FORCE_INLINE constexpr uint_t total_length() const { return m_total_length; }
 
         /**
          * @brief sets minus halo to zero.
          * This operation is needed in the communication module.
          * Unlike a general setter this operation will always result in a valid halo_descriptor.
          */
-        GT_FUNCTION void reset_minus() { m_minus = 0; }
+        GT_FORCE_INLINE constexpr void reset_minus() { m_minus = 0; }
         /**
          * @brief sets plus halo to zero.
          * This operation, unlike a general setter, will always result in a valid halo_descriptor.
          */
-        GT_FUNCTION void reset_plus() { m_plus = 0; }
+        GT_FORCE_INLINE constexpr void reset_plus() { m_plus = 0; }
 
-        GT_FUNCTION bool operator==(const halo_descriptor &rhs) const {
+        GT_FORCE_INLINE constexpr bool operator==(const halo_descriptor &rhs) const {
             return (m_minus == rhs.m_minus) && (m_plus == rhs.m_plus) && (m_begin == rhs.m_begin) &&
                    (m_end == rhs.m_end) && (m_total_length == rhs.m_total_length);
         }
 
-        GT_FUNCTION bool operator!=(const halo_descriptor &rhs) const { return !(*this == rhs); }
+        GT_FORCE_INLINE constexpr bool operator!=(const halo_descriptor &rhs) const { return !(*this == rhs); }
     };
 
     /** @} */
diff --git a/include/gridtools/common/host_device.hpp b/include/gridtools/common/host_device.hpp
index 40acfe5926..b96194b54f 100644
--- a/include/gridtools/common/host_device.hpp
+++ b/include/gridtools/common/host_device.hpp
@@ -30,9 +30,6 @@
 #elif defined(__GNUC__)
 #define GT_FORCE_INLINE inline __attribute__((always_inline))
 #define GT_FORCE_INLINE_LAMBDA __attribute__((always_inline))
-#elif defined(_MSC_VER)
-#define GT_FORCE_INLINE inline __forceinline
-#define GT_FORCE_INLINE_LAMBDA
 #else
 #define GT_FORCE_INLINE inline
 #define GT_FORCE_INLINE_LAMBDA
@@ -50,11 +47,6 @@
  * @def GT_FUNCTION_DEVICE
  * Function attribute macro to be used for device-only functions.
  */
-/**
- * @def GT_FUNCTION_WARNING
- * Function attribute macro to be used for host-only functions that might call a host-device
- * function. This macro is only needed to supress NVCC warnings.
- */
 
 #ifdef GT_CUDACC
 #define GT_HOST_DEVICE __host__ __device__
@@ -74,10 +66,6 @@
 #define GT_FUNCTION GT_HOST_DEVICE GT_FORCE_INLINE
 #endif
 
-#ifndef GT_FUNCTION_WARNING
-#define GT_FUNCTION_WARNING GT_HOST_DEVICE GT_FORCE_INLINE
-#endif
-
 #ifndef GT_FUNCTION_HOST
 #define GT_FUNCTION_HOST GT_HOST GT_FORCE_INLINE
 #endif
@@ -86,71 +74,5 @@
 #define GT_FUNCTION_DEVICE GT_DEVICE GT_FORCE_INLINE
 #endif
 
-/**
- *   A helper to implement a family of functions which are different from each other only by target specifies.
- *
- *   It uses the same design pattern as `BOOST_PP_ITERATE` does.
- *   For example if one wants to define a function with any possible combination of `__host__` and `__device__`
- *   specifiers he needs to write the following code:
- *
- *   foo.hpp:
- *
- *   \code
- *   // here we query if this file is used in the context of iteration
- *   #ifndef GT_TARGET_ITERATING
- *
- *   // note that you can't use `#pragma once` here and have to use classic header guards instead
- *   #ifndef FOO_HPP_
- *   #define FOO_HPP_
- *
- *   #include <path/to/this/file/host_device.hpp>
- *
- *   // we need to provide GT_ITERATE_ON_TARGETS() with the name of the current file to include it back during
- *   // iteration process. GT_FILENAME is a hardcoded name that GT_ITERATE_ON_TARGETS() will use.
- *   #define GT_FILENAME <path/to/the/user/file/foo.hpp>
- *
- *   // iteration takes place here
- *   #include GT_ITERATE_ON_TARGETS()
- *
- *   // cleanup
- *   #undef GT_FILENAME
- *
- *   #endif
- *   #else
- *
- *   // here is the code that will be included several times during the iteration process
- *
- *   namespace my {
- *     // GT_TARGET_NAMESPACE will be defined by GT_ITERATE_ON_TARGETS() for you.
- *     // It could be either `namespace host` or `namespace device` or `namespace host_device`.
- *     // one of those namespaces would be defined as `inline`
- *     GT_TARGET_NAMESPACE {
- *        // GT_TARGET will be defined by GT_ITERATE_ON_TARGETS() for you.
- *        // It will contain target specifier that is needed it the given context.
- *        GT_TARGET void foo() {}
- *     }
- *   }
- *
- *   #endif
- *   \endcode
- *
- *   By including "file.hpp" file the following symbols would be available:
- *   - `my::foo`
- *   - `my::host::foo`
- *   - `my::device::foo`
- *   - `my::host_device::foo`
- *
- *   where:
- *
- *   - `my::host::foo` has no specifiers.
- *   - `my::foo` is resolved to `my::host::foo`
- *
- *   If compiling with CUDA, `my::device::foo` has `__device__` specifier, `my::host_device::foo` has
- *   `__host__ __device__` specifier.
- *
- *   Otherwise `my::device::foo` and `my::host_device::foo` are resolved to `my::host::foo`.
- */
-#define GT_ITERATE_ON_TARGETS() <gridtools/common/iterate_on_host_device.hpp>
-
 /** @} */
 /** @} */
diff --git a/include/gridtools/common/hymap.hpp b/include/gridtools/common/hymap.hpp
index 053f287f80..ec4c241cd6 100644
--- a/include/gridtools/common/hymap.hpp
+++ b/include/gridtools/common/hymap.hpp
@@ -45,8 +45,7 @@
  *
  *  User API
  *  --------
- *  Run time: a single function `target_name::at_key<Key>(hymap_obj)` is provided where `target_name` is `host`,
- * `device` or `host_device`. `at_key` without `target_name` is an alias of `host::at_key`.
+ *  Run time: a single function `at_key<Key>(hymap_obj)` is provided.
  *
  *  Compile time:
  *  - `get_keys` metafunction. Usage: `get_keys<Hymap>`
@@ -89,13 +88,10 @@
  *  - converting to a map:
  *    `auto a_map = tuple_util::convert_to<hymap::keys<a, b>::values>(a_tuple_with_values)`
  */
-
-#ifndef GT_TARGET_ITERATING
-//// DON'T USE #pragma once HERE!!!
-#ifndef GT_COMMON_HYMAP_HPP_
-#define GT_COMMON_HYMAP_HPP_
+#pragma once
 
 #include <type_traits>
+#include <utility>
 
 #include "../meta.hpp"
 #include "defs.hpp"
@@ -104,12 +100,9 @@
 #include "integral_constant.hpp"
 #include "tuple.hpp"
 #include "tuple_util.hpp"
-#include "utility.hpp"
 
 namespace gridtools {
-
     namespace hymap_impl_ {
-
         template <class I>
         using get_key = integral_constant<int_t, I::value>;
 
@@ -194,6 +187,44 @@ namespace gridtools {
     template <class Map, class Key>
     using has_key = meta::st_contains<hymap_impl_::get_keys<Map>, Key>;
 
+    template <class Key,
+        class Map,
+        class Decayed = std::decay_t<Map>,
+        class I = meta::st_position<get_keys<Decayed>, Key>,
+        std::enable_if_t<I::value != tuple_util::size<Decayed>::value, int> = 0>
+    GT_FORCE_INLINE constexpr decltype(auto) at_key(Map &&map) noexcept {
+        return tuple_util::get<I::value>(std::forward<Map>(map));
+    }
+
+    template <class Key,
+        class Map,
+        class Decayed = std::decay_t<Map>,
+        class I = meta::st_position<get_keys<Decayed>, Key>,
+        std::enable_if_t<I::value == tuple_util::size<Decayed>::value, int> = 0>
+    constexpr void at_key(Map &&) noexcept {
+        static_assert(sizeof(Key) != sizeof(Key), "wrong key");
+    }
+
+    template <class Key,
+        class Default,
+        class Map,
+        class Decayed = std::decay_t<Map>,
+        class I = meta::st_position<get_keys<Decayed>, Key>,
+        std::enable_if_t<I::value != tuple_util::size<Decayed>::value, int> = 0>
+    GT_FORCE_INLINE constexpr decltype(auto) at_key_with_default(Map &&map) noexcept {
+        return tuple_util::get<I::value>(std::forward<Map>(map));
+    }
+
+    template <class Key,
+        class Default,
+        class Map,
+        class Decayed = std::decay_t<Map>,
+        class I = meta::st_position<get_keys<Decayed>, Key>,
+        std::enable_if_t<I::value == tuple_util::size<Decayed>::value, int> = 0>
+    GT_FORCE_INLINE constexpr Default at_key_with_default(Map &&) noexcept {
+        return {};
+    }
+
     namespace hymap {
         template <class...>
         struct keys : private enable_maker {
@@ -217,12 +248,12 @@ namespace gridtools {
 
             template <class... Args,
                 std::enable_if_t<std::conjunction_v<std::is_constructible<Vals, Args>...>, int> = 0>
-            constexpr GT_FUNCTION values(Args &&...args) noexcept : m_vals{wstd::forward<Args>(args)...} {}
+            GT_FORCE_INLINE constexpr values(Args &&...args) noexcept : m_vals{std::forward<Args>(args)...} {}
 
-            constexpr GT_FUNCTION values(Vals const &...args) noexcept : m_vals(args...) {}
+            GT_FORCE_INLINE constexpr values(Vals const &...args) noexcept : m_vals(args...) {}
 
-            constexpr GT_FUNCTION values(tuple<Vals...> &&args) noexcept : m_vals(wstd::move(args)) {}
-            constexpr GT_FUNCTION values(tuple<Vals...> const &args) noexcept : m_vals(args) {}
+            GT_FORCE_INLINE constexpr values(tuple<Vals...> &&args) noexcept : m_vals(std::move(args)) {}
+            GT_FORCE_INLINE constexpr values(tuple<Vals...> const &args) noexcept : m_vals(args) {}
 
             values() = default;
             values(values const &) = default;
@@ -253,7 +284,7 @@ namespace gridtools {
                 meta::if_<meta::is_empty<MetaMap>, meta::list<meta::list<>, meta::list<>>, meta::transpose<MetaMap>>>
         using from_meta_map = from_keys_values<meta::first<KeysAndValues>, meta::second<KeysAndValues>, KeyCtor>;
 
-        namespace hymap_impl_ {
+        namespace impl_ {
             template <class Maps>
             using merged_keys = meta::dedup<meta::transform<meta::first, meta::flatten<Maps>>>;
 
@@ -286,222 +317,152 @@ namespace gridtools {
                 template <class Values, class Maps, class Keys = meta::flatten<meta::transform<get_keys, Maps>>>
                 using apply = typename get_from_keys_values<meta::first<Maps>>::template apply<Keys, Values>;
             };
-        } // namespace hymap_impl_
-    }     // namespace hymap
-} // namespace gridtools
-
-#define GT_FILENAME <gridtools/common/hymap.hpp>
-#include GT_ITERATE_ON_TARGETS()
-#undef GT_FILENAME
 
-#endif // GT_COMMON_HYMAP_HPP_
-#else  // GT_TARGET_ITERATING
+            template <class Fun, class Keys>
+            struct adapter_f {
+                Fun m_fun;
+                template <size_t I, class Value, class Key = meta::at_c<Keys, I>>
+                GT_FORCE_INLINE constexpr decltype(auto) operator()(Value &&value) const {
+                    return m_fun.template operator()<Key>(std::forward<Value>(value));
+                }
+            };
+        } // namespace impl_
 
-namespace gridtools {
-    GT_TARGET_NAMESPACE {
-        template <class Key,
-            class Map,
-            class Decayed = std::decay_t<Map>,
-            class I = meta::st_position<get_keys<Decayed>, Key>,
-            std::enable_if_t<I::value != tuple_util::size<Decayed>::value, int> = 0>
-        GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) at_key(Map && map) noexcept {
-            return tuple_util::GT_TARGET_NAMESPACE_NAME::get<I::value>(wstd::forward<Map>(map));
+        template <class Fun, class Map>
+        GT_FORCE_INLINE constexpr auto transform(Fun &&fun, Map &&map) {
+            return tuple_util::transform_index(
+                impl_::adapter_f<Fun, get_keys<std::decay_t<Map>>>{std::forward<Fun>(fun)}, std::forward<Map>(map));
         }
 
-        template <class Key,
-            class Map,
-            class Decayed = std::decay_t<Map>,
-            class I = meta::st_position<get_keys<Decayed>, Key>,
-            std::enable_if_t<I::value == tuple_util::size<Decayed>::value, int> = 0>
-        GT_TARGET void at_key(Map &&) noexcept {
-            static_assert(sizeof(Key) != sizeof(Key), "wrong key");
+        template <class Fun, class Map>
+        GT_FORCE_INLINE constexpr void for_each(Fun &&fun, Map &&map) {
+            tuple_util::for_each_index(
+                impl_::adapter_f<Fun, get_keys<std::decay_t<Map>>>{std::forward<Fun>(fun)}, std::forward<Map>(map));
         }
 
-        template <class Key,
-            class Default,
-            class Map,
-            class Decayed = std::decay_t<Map>,
-            class I = meta::st_position<get_keys<Decayed>, Key>,
-            std::enable_if_t<I::value != tuple_util::size<Decayed>::value, int> = 0>
-        GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) at_key_with_default(Map && map) noexcept {
-            return tuple_util::GT_TARGET_NAMESPACE_NAME::get<I::value>(wstd::forward<Map>(map));
+        // Concatenate several maps into one. The type of the result is infered from the type of the first map.
+        // Precondition: keys should not overlap.
+        template <class... Maps>
+        GT_FORCE_INLINE constexpr auto concat(Maps... maps) {
+            static_assert(meta::is_set_fast<meta::concat<get_keys<Maps>...>>::value, GT_INTERNAL_ERROR);
+            return tuple_util::concat_ex<impl_::concat_result_maker_f>(std::move(maps)...);
         }
 
-        template <class Key,
-            class Default,
-            class Map,
-            class Decayed = std::decay_t<Map>,
-            class I = meta::st_position<get_keys<Decayed>, Key>,
-            std::enable_if_t<I::value == tuple_util::size<Decayed>::value, int> = 0>
-        GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Default at_key_with_default(Map &&) noexcept {
-            return {};
+        template <template <class...> class KeyCtor,
+            class Keys,
+            class Tup,
+            class HyMapKeys = meta::rename<KeyCtor, Keys>>
+        GT_FORCE_INLINE constexpr auto convert_to(Tup &&tup) {
+            return tuple_util::convert_to<HyMapKeys::template values>(std::forward<Tup>(tup));
         }
-    }
-
-    namespace hymap {
-        GT_TARGET_NAMESPACE {
-            namespace hymap_detail {
-                template <class Fun, class Keys>
-                struct adapter_f {
-                    Fun m_fun;
-                    template <size_t I, class Value, class Key = meta::at_c<Keys, I>>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) operator()(Value &&value) const {
-                        return m_fun.template operator()<Key>(wstd::forward<Value>(value));
-                    }
-                };
-            } // namespace hymap_detail
-
-            template <class Fun, class Map>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR auto transform(Fun && fun, Map && map) {
-                return tuple_util::GT_TARGET_NAMESPACE_NAME::transform_index(
-                    hymap_detail::adapter_f<Fun, get_keys<std::decay_t<Map>>>{wstd::forward<Fun>(fun)},
-                    wstd::forward<Map>(map));
-            }
-
-            template <class Fun, class Map>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR void for_each(Fun && fun, Map && map) {
-                tuple_util::GT_TARGET_NAMESPACE_NAME::for_each_index(
-                    hymap_detail::adapter_f<Fun, get_keys<std::decay_t<Map>>>{wstd::forward<Fun>(fun)},
-                    wstd::forward<Map>(map));
-            }
-
-            // Concatenate several maps into one. The type of the result is infered from the type of the first map.
-            // Precondition: keys should not overlap.
-            template <class... Maps>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR auto concat(Maps... maps) {
-                static_assert(meta::is_set_fast<meta::concat<get_keys<Maps>...>>::value, GT_INTERNAL_ERROR);
-                return tuple_util::concat_ex<hymap_impl_::concat_result_maker_f>(wstd::move(maps)...);
-            }
-
-            template <template <class...> class KeyCtor,
-                class Keys,
-                class Tup,
-                class HyMapKeys = meta::rename<KeyCtor, Keys>>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR auto convert_to(Tup && tup) {
-                return tuple_util::convert_to<HyMapKeys::template values>(wstd::forward<Tup>(tup));
-            }
 
-            // This class holds two maps and models hymap content.
-            // at_key returns the item of the primary map if the key is found there
-            // otherwise it falls back to the secondary map.
-            template <class Primary, class Secondary>
-            class merged : tuple<Primary, Secondary> {
-                using base_t = tuple<Primary, Secondary>;
+        // This class holds two maps and models hymap content.
+        // at_key returns the item of the primary map if the key is found there
+        // otherwise it falls back to the secondary map.
+        template <class Primary, class Secondary>
+        class merged : tuple<Primary, Secondary> {
+            using base_t = tuple<Primary, Secondary>;
 
-                using meta_primary_t = to_meta_map<Primary>;
-                using meta_secondary_t = to_meta_map<Secondary>;
+            using meta_primary_t = to_meta_map<Primary>;
+            using meta_secondary_t = to_meta_map<Secondary>;
 
-                using primary_keys_t = meta::transform<meta::first, meta_primary_t>;
-                using secondary_keys_t = meta::transform<meta::first, meta_secondary_t>;
+            using primary_keys_t = meta::transform<meta::first, meta_primary_t>;
+            using secondary_keys_t = meta::transform<meta::first, meta_secondary_t>;
 
-                template <class Key,
-                    class PrimaryItem = meta::mp_find<meta_primary_t, Key>,
-                    class SecondaryItem = meta::mp_find<meta_secondary_t, Key>>
-                using get_value_type = meta::second<meta::if_<std::is_void<PrimaryItem>, SecondaryItem, PrimaryItem>>;
+            template <class Key,
+                class PrimaryItem = meta::mp_find<meta_primary_t, Key>,
+                class SecondaryItem = meta::mp_find<meta_secondary_t, Key>>
+            using get_value_type = meta::second<meta::if_<std::is_void<PrimaryItem>, SecondaryItem, PrimaryItem>>;
 
-                using keys_t = meta::dedup<meta::concat<primary_keys_t, secondary_keys_t>>;
-                using values_t = meta::transform<get_value_type, keys_t>;
+            using keys_t = meta::dedup<meta::concat<primary_keys_t, secondary_keys_t>>;
+            using values_t = meta::transform<get_value_type, keys_t>;
 
-                template <size_t I, class Key = meta::at_c<keys_t, I>>
-                using is_primary_index = meta::st_contains<primary_keys_t, Key>;
+            template <size_t I, class Key = meta::at_c<keys_t, I>>
+            using is_primary_index = meta::st_contains<primary_keys_t, Key>;
 
-                template <size_t I, class Key = meta::at_c<keys_t, I>>
-                using inner_index = meta::if_<is_primary_index<I>,
-                    meta::st_position<primary_keys_t, Key>,
-                    meta::st_position<secondary_keys_t, Key>>;
+            template <size_t I, class Key = meta::at_c<keys_t, I>>
+            using inner_index = meta::if_<is_primary_index<I>,
+                meta::st_position<primary_keys_t, Key>,
+                meta::st_position<secondary_keys_t, Key>>;
 
-                template <size_t I,
-                    class Key = meta::at_c<keys_t, I>,
-                    class PrimaryPos = meta::st_position<primary_keys_t, Key>,
-                    class SecondaryPos = meta::st_position<secondary_keys_t, Key>>
-                using split_index = meta::if_c<(PrimaryPos::value < meta::length<primary_keys_t>::value),
-                    meta::list<std::integral_constant<size_t, 0>, PrimaryPos>,
-                    meta::list<std::integral_constant<size_t, 1>, SecondaryPos>>;
+            template <size_t I,
+                class Key = meta::at_c<keys_t, I>,
+                class PrimaryPos = meta::st_position<primary_keys_t, Key>,
+                class SecondaryPos = meta::st_position<secondary_keys_t, Key>>
+            using split_index = meta::if_c<(PrimaryPos::value < meta::length<primary_keys_t>::value),
+                meta::list<std::integral_constant<size_t, 0>, PrimaryPos>,
+                meta::list<std::integral_constant<size_t, 1>, SecondaryPos>>;
 
-                friend values_t tuple_to_types(merged const &) { return {}; }
+            friend values_t tuple_to_types(merged const &) { return {}; }
 
-                friend keys_t hymap_get_keys(merged const &) { return {}; }
+            friend keys_t hymap_get_keys(merged const &) { return {}; }
 
-                friend struct merged_getter;
+            friend struct merged_getter;
 
-                GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR base_t const &base() const { return *this; }
-                GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR base_t &base() { return *this; }
+            GT_FORCE_INLINE constexpr base_t const &base() const { return *this; }
+            GT_FORCE_INLINE constexpr base_t &base() { return *this; }
 
-                template <size_t I>
-                GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) source() const {
-                    return tuple_util::GT_TARGET_NAMESPACE_NAME::get < is_primary_index<I>::value ? 0 : 1 > (base());
-                }
-                template <size_t I>
-                GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) source() {
-                    return tuple_util::GT_TARGET_NAMESPACE_NAME::get < is_primary_index<I>::value ? 0 : 1 > (base());
-                }
+            template <size_t I>
+            GT_FORCE_INLINE constexpr decltype(auto) source() const {
+                return tuple_util::get < is_primary_index<I>::value ? 0 : 1 > (base());
+            }
+            template <size_t I>
+            GT_FORCE_INLINE constexpr decltype(auto) source() {
+                return tuple_util::get < is_primary_index<I>::value ? 0 : 1 > (base());
+            }
 
-                template <size_t I>
-                GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) get() const {
-                    return tuple_util::GT_TARGET_NAMESPACE_NAME::get<inner_index<I>::value>(source<I>());
-                }
-                template <size_t I>
-                GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) get() {
-                    return tuple_util::GT_TARGET_NAMESPACE_NAME::get<inner_index<I>::value>(source<I>());
-                }
+            template <size_t I>
+            GT_FORCE_INLINE constexpr decltype(auto) get() const {
+                return tuple_util::get<inner_index<I>::value>(source<I>());
+            }
+            template <size_t I>
+            GT_FORCE_INLINE constexpr decltype(auto) get() {
+                return tuple_util::get<inner_index<I>::value>(source<I>());
+            }
 
-              public:
-                merged() = default;
+          public:
+            merged() = default;
 
-                GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR merged(Primary primary, Secondary secondary)
-                    : base_t(wstd::move(primary), wstd::move(secondary)) {}
+            GT_FORCE_INLINE constexpr merged(Primary primary, Secondary secondary)
+                : base_t(std::move(primary), std::move(secondary)) {}
 
-                GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Primary const &primary() const {
-                    return tuple_util::GT_TARGET_NAMESPACE_NAME::get<0>(base());
-                }
-                GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Primary &primary() {
-                    return tuple_util::GT_TARGET_NAMESPACE_NAME::get<0>(base());
-                }
+            GT_FORCE_INLINE constexpr Primary const &primary() const { return tuple_util::get<0>(base()); }
+            GT_FORCE_INLINE constexpr Primary &primary() { return tuple_util::get<0>(base()); }
 
-                GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Secondary const &secondary() const {
-                    return tuple_util::GT_TARGET_NAMESPACE_NAME::get<1>(base());
-                }
-                GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Secondary &secondary() {
-                    return tuple_util::GT_TARGET_NAMESPACE_NAME::get<1>(base());
-                }
+            GT_FORCE_INLINE constexpr Secondary const &secondary() const { return tuple_util::get<1>(base()); }
+            GT_FORCE_INLINE constexpr Secondary &secondary() { return tuple_util::get<1>(base()); }
 
-                // TODO:
-                // - element wise ctor
-                // - tuple_from_types
-                // - hymap_from_keys_values
-            };
+            // TODO:
+            // - element wise ctor
+            // - tuple_from_types
+            // - hymap_from_keys_values
+        };
 
-            struct merged_getter {
-                template <size_t I, class Primary, class Secondary>
-                static GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) get(
-                    merged<Primary, Secondary> const &obj) {
-                    return obj.template get<I>();
-                }
-                template <size_t I, class Primary, class Secondary>
-                static GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) get(
-                    merged<Primary, Secondary> &obj) {
-                    return obj.template get<I>();
-                }
-            };
+        struct merged_getter {
+            template <size_t I, class Primary, class Secondary>
+            static GT_FORCE_INLINE constexpr decltype(auto) get(merged<Primary, Secondary> const &obj) {
+                return obj.template get<I>();
+            }
+            template <size_t I, class Primary, class Secondary>
+            static GT_FORCE_INLINE constexpr decltype(auto) get(merged<Primary, Secondary> &obj) {
+                return obj.template get<I>();
+            }
+        };
 
-            template <class Primary, class Secondary>
-            merged_getter tuple_getter(merged<Primary, Secondary> const &);
+        template <class Primary, class Secondary>
+        merged_getter tuple_getter(merged<Primary, Secondary> const &);
 
-            // merge the maps
-            // unlike concat keys could overlap
-            // in the case of overlap the value is taken from the primary map
-            template <class Primary, class Secondary>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR merged<Primary, Secondary> merge(
-                Primary primary, Secondary secondary) {
-                return {wstd::move(primary), wstd::move(secondary)};
-            }
+        // merge the maps
+        // unlike concat keys could overlap
+        // in the case of overlap the value is taken from the primary map
+        template <class Primary, class Secondary>
+        GT_FORCE_INLINE constexpr merged<Primary, Secondary> merge(Primary primary, Secondary secondary) {
+            return {std::move(primary), std::move(secondary)};
+        }
 
-            template <class Primary, class... Secondaries>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR auto merge(Primary primary, Secondaries... secondaries) {
-                return merge(wstd::move(primary), merge(wstd::move(secondaries)...));
-            }
-        } // namespace hymap
-    }     // namespace hymap
+        template <class Primary, class... Secondaries>
+        GT_FORCE_INLINE constexpr auto merge(Primary primary, Secondaries... secondaries) {
+            return merge(std::move(primary), merge(std::move(secondaries)...));
+        }
+    } // namespace hymap
 } // namespace gridtools
-
-#endif // GT_TARGET_ITERATING
diff --git a/include/gridtools/common/hypercube_iterator.hpp b/include/gridtools/common/hypercube_iterator.hpp
index c3a98a0e27..69661469ff 100644
--- a/include/gridtools/common/hypercube_iterator.hpp
+++ b/include/gridtools/common/hypercube_iterator.hpp
@@ -10,6 +10,9 @@
 
 #pragma once
 
+#include <utility>
+#include <type_traits>
+
 #include "array.hpp"
 #include "defs.hpp"
 #include "host_device.hpp"
@@ -27,7 +30,7 @@ namespace gridtools {
                 const point_t &m_begin;
                 const point_t &m_end;
 
-                GT_FUNCTION grid_iterator &operator++() {
+                GT_FORCE_INLINE constexpr grid_iterator &operator++() {
                     // The CUDA compiler is very sensitive in properly unrolling the following loop, please change with
                     // care. The kernel in test_layout_transformation_cuda should use 0 stack frame (and about 14
                     // registers) if this loop is properly unrolled.
@@ -49,23 +52,23 @@ namespace gridtools {
                     return *this;
                 }
 
-                GT_FUNCTION grid_iterator operator++(int) {
+                GT_FORCE_INLINE constexpr grid_iterator operator++(int) {
                     grid_iterator tmp(*this);
                     operator++();
                     return tmp;
                 }
 
-                GT_FUNCTION point_t const &operator*() const { return m_pos; }
+                GT_FORCE_INLINE constexpr point_t const &operator*() const { return m_pos; }
 
-                GT_FUNCTION bool operator!=(const grid_iterator &other) const { return m_pos != other.m_pos; }
+                GT_FORCE_INLINE constexpr bool operator!=(const grid_iterator &other) const { return m_pos != other.m_pos; }
             };
 
           public:
-            GT_FUNCTION hypercube_view(const point_t &begin, const point_t &end) : m_begin(begin), m_end(end) {}
-            GT_FUNCTION hypercube_view(const point_t &end) : m_end(end) {}
+            GT_FORCE_INLINE constexpr hypercube_view(const point_t &begin, const point_t &end) : m_begin(begin), m_end(end) {}
+            GT_FORCE_INLINE constexpr hypercube_view(const point_t &end) : m_end(end) {}
 
-            GT_FUNCTION grid_iterator begin() const { return grid_iterator{m_begin, m_begin, m_end}; }
-            GT_FUNCTION grid_iterator end() const { return grid_iterator{m_end, m_begin, m_end}; }
+            GT_FORCE_INLINE constexpr grid_iterator begin() const { return grid_iterator{m_begin, m_begin, m_end}; }
+            GT_FORCE_INLINE constexpr grid_iterator end() const { return grid_iterator{m_end, m_begin, m_end}; }
 
           private:
             point_t m_begin = {};
@@ -91,10 +94,10 @@ namespace gridtools {
         size_t OuterD = tuple_util::size<Decayed>::value,
         std::enable_if_t<OuterD != 0 && meta::all_of<impl_::is_pair_like, tuple_util::traits::to_types<Decayed>>::value,
             int> = 0>
-    GT_FUNCTION impl_::hypercube_view<OuterD> make_hypercube_view(Container &&cube) {
-        auto &&transposed = tuple_util::host_device::transpose(wstd::forward<Container>(cube));
-        return {tuple_util::host_device::convert_to<array, size_t>(tuple_util::host_device::get<0>(transposed)),
-            tuple_util::host_device::convert_to<array, size_t>(tuple_util::host_device::get<1>(transposed))};
+    GT_FORCE_INLINE constexpr impl_::hypercube_view<OuterD> make_hypercube_view(Container &&cube) {
+        auto &&transposed = tuple_util::transpose(std::forward<Container>(cube));
+        return {tuple_util::convert_to<array, size_t>(tuple_util::get<0>(transposed)),
+            tuple_util::convert_to<array, size_t>(tuple_util::get<1>(transposed))};
     }
 
     /**
@@ -103,7 +106,7 @@ namespace gridtools {
     template <typename Container,
         size_t D = tuple_util::size<std::decay_t<Container>>::value,
         std::enable_if_t<D == 0, int> = 0>
-    GT_FUNCTION array<array<size_t, 0>, 1> make_hypercube_view(Container &&) {
+    GT_FORCE_INLINE constexpr array<array<size_t, 0>, 1> make_hypercube_view(Container &&) {
         return {{}};
     }
 
@@ -116,7 +119,7 @@ namespace gridtools {
         size_t D = tuple_util::size<Decayed>::value,
         std::enable_if_t<D != 0 && meta::all_of<impl_::is_size_t_like, tuple_util::traits::to_types<Decayed>>::value,
             int> = 0>
-    GT_FUNCTION impl_::hypercube_view<D> make_hypercube_view(Container &&sizes) {
-        return {tuple_util::host_device::convert_to<array, size_t>(wstd::forward<Container>(sizes))};
+    GT_FORCE_INLINE constexpr impl_::hypercube_view<D> make_hypercube_view(Container &&sizes) {
+        return {tuple_util::convert_to<array, size_t>(std::forward<Container>(sizes))};
     }
 } // namespace gridtools
diff --git a/include/gridtools/common/implicit_cast.hpp b/include/gridtools/common/implicit_cast.hpp
deleted file mode 100644
index 82cc425136..0000000000
--- a/include/gridtools/common/implicit_cast.hpp
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * GridTools
- *
- * Copyright (c) 2014-2021, ETH Zurich
- * All rights reserved.
- *
- * Please, refer to the LICENSE file in the root directory.
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-#ifndef GT_TARGET_ITERATING
-// DON'T USE #pragma once HERE!!!
-#ifndef GT_COMMON_IMPLICIT_CAST_HPP_
-#define GT_COMMON_IMPLICIT_CAST_HPP_
-
-#include "../meta/id.hpp"
-#include "defs.hpp"
-#include "host_device.hpp"
-
-#define GT_FILENAME <gridtools/common/implicit_cast.hpp>
-#include GT_ITERATE_ON_TARGETS()
-#undef GT_FILENAME
-
-#endif // GT_COMMON_IMPLICIT_CAST_HPP_
-#else
-
-namespace gridtools {
-    GT_TARGET_NAMESPACE {
-        /**
-         * `boost::implicit_cast` clone with constexpr and target specifiers
-         *
-         * The use of identity creates a non-deduced form, so that the explicit template argument must be supplied
-         */
-        template <class T>
-        GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR T implicit_cast(typename meta::lazy::id<T>::type x) {
-            return x;
-        }
-    }
-} // namespace gridtools
-
-#endif
diff --git a/include/gridtools/common/int_vector.hpp b/include/gridtools/common/int_vector.hpp
index d75f8001fd..9927276add 100644
--- a/include/gridtools/common/int_vector.hpp
+++ b/include/gridtools/common/int_vector.hpp
@@ -22,14 +22,13 @@
 #pragma once
 
 #include <type_traits>
+#include <utility>
 
 #include "../meta.hpp"
-#include "defs.hpp"
 #include "host_device.hpp"
 #include "hymap.hpp"
 #include "integral_constant.hpp"
 #include "tuple_util.hpp"
-#include "utility.hpp"
 
 namespace gridtools {
 
@@ -48,8 +47,8 @@ namespace gridtools {
         template <class Key>
         struct add_f {
             template <class... Ts>
-            GT_FUNCTION GT_CONSTEXPR decltype(auto) operator()(Ts const &...args) const {
-                return (host_device::at_key_with_default<Key, integral_constant<int, 0>>(args) + ...);
+            GT_FORCE_INLINE constexpr decltype(auto) operator()(Ts const &...args) const {
+                return (at_key_with_default<Key, integral_constant<int, 0>>(args) + ...);
             }
         };
 
@@ -59,8 +58,8 @@ namespace gridtools {
         template <class Key>
         struct at_key_f {
             template <class T>
-            GT_FUNCTION GT_CONSTEXPR decltype(auto) operator()(T const &arg) const {
-                return host_device::at_key<Key>(arg);
+            GT_FORCE_INLINE constexpr decltype(auto) operator()(T const &arg) const {
+                return at_key<Key>(arg);
             }
         };
 
@@ -99,32 +98,31 @@ namespace gridtools {
          * The keys of the resulting `int_vector` are the union of the keys of the operands.
          */
         template <class... Vecs>
-        GT_FUNCTION GT_CONSTEXPR auto plus(Vecs && ...vecs) {
+        GT_FORCE_INLINE constexpr auto plus(Vecs && ...vecs) {
             using merged_meta_map_t = meta::mp_make<impl_::merger_t, meta::concat<hymap::to_meta_map<Vecs>...>>;
             using keys_t = meta::transform<meta::first, merged_meta_map_t>;
             using generators = meta::transform<impl_::add_f, keys_t>;
-            return tuple_util::host_device::generate<generators, hymap::from_meta_map<merged_meta_map_t>>(
-                wstd::forward<Vecs>(vecs)...);
+            return tuple_util::generate<generators, hymap::from_meta_map<merged_meta_map_t>>(
+                std::forward<Vecs>(vecs)...);
         }
 
         /**
          * @brief Returns `int_vector` with elements multiplied by an integral scalar
          */
         template <class Vec, class Scalar>
-        GT_FUNCTION GT_CONSTEXPR auto multiply(Vec && vec, Scalar scalar) {
-            return tuple_util::host_device::transform([scalar](auto v) { return v * scalar; }, wstd::forward<Vec>(vec));
+        GT_FORCE_INLINE constexpr auto multiply(Vec && vec, Scalar scalar) {
+            return tuple_util::transform([scalar](auto v) { return v * scalar; }, std::forward<Vec>(vec));
         }
 
         /**
          * @brief Returns `int_vector` with elements removed that are `integral_constant<T, 0>`
          */
         template <class Vec>
-        GT_FUNCTION GT_CONSTEXPR auto prune_zeros(Vec && vec) {
+        GT_FORCE_INLINE constexpr auto prune_zeros(Vec && vec) {
             using filtered_map_t = meta::filter<meta::not_<impl_::is_constant_zero>::apply, hymap::to_meta_map<Vec>>;
             using keys_t = meta::transform<meta::first, filtered_map_t>;
             using generators = meta::transform<impl_::at_key_f, keys_t>;
-            return tuple_util::host_device::generate<generators, hymap::from_meta_map<filtered_map_t>>(
-                wstd::forward<Vec>(vec));
+            return tuple_util::generate<generators, hymap::from_meta_map<filtered_map_t>>(std::forward<Vec>(vec));
         }
 
         namespace arithmetic {
@@ -133,8 +131,8 @@ namespace gridtools {
                 std::enable_if_t<is_int_vector_v<std::decay_t<Vec>> &&
                                      impl_::is_integral_or_gr_integral_constant<Scalar>::value,
                     bool> = true>
-            GT_FUNCTION GT_CONSTEXPR auto operator*(Vec &&vec, Scalar scalar) {
-                return multiply(wstd::forward<Vec>(vec), scalar);
+            GT_FORCE_INLINE constexpr auto operator*(Vec &&vec, Scalar scalar) {
+                return multiply(std::forward<Vec>(vec), scalar);
             }
 
             template <class Vec,
@@ -142,34 +140,34 @@ namespace gridtools {
                 std::enable_if_t<is_int_vector_v<std::decay_t<Vec>> &&
                                      impl_::is_integral_or_gr_integral_constant<Scalar>::value,
                     bool> = true>
-            GT_FUNCTION GT_CONSTEXPR auto operator*(Scalar scalar, Vec &&vec) {
-                return multiply(wstd::forward<Vec>(vec), scalar);
+            GT_FORCE_INLINE constexpr auto operator*(Scalar scalar, Vec &&vec) {
+                return multiply(std::forward<Vec>(vec), scalar);
             }
 
             template <class First,
                 class Second,
                 std::enable_if_t<is_int_vector_v<std::decay_t<First>> && is_int_vector_v<std::decay_t<Second>>, bool> =
                     true>
-            GT_FUNCTION GT_CONSTEXPR auto operator+(First &&first, Second &&second) {
-                return plus(wstd::forward<First>(first), wstd::forward<Second>(second));
+            GT_FORCE_INLINE constexpr auto operator+(First &&first, Second &&second) {
+                return plus(std::forward<First>(first), std::forward<Second>(second));
             }
 
             template <class Vec, std::enable_if_t<is_int_vector_v<std::decay_t<Vec>>, bool> = true>
-            GT_FUNCTION GT_CONSTEXPR auto operator+(Vec &&vec) {
+            GT_FORCE_INLINE constexpr auto operator+(Vec &&vec) {
                 return vec;
             }
 
             template <class Vec, std::enable_if_t<is_int_vector_v<std::decay_t<Vec>>, bool> = true>
-            GT_FUNCTION GT_CONSTEXPR auto operator-(Vec &&vec) {
-                return multiply(wstd::forward<Vec>(vec), integral_constant<int, -1>{});
+            GT_FORCE_INLINE constexpr auto operator-(Vec &&vec) {
+                return multiply(std::forward<Vec>(vec), integral_constant<int, -1>{});
             }
 
             template <class First,
                 class Second,
                 std::enable_if_t<is_int_vector_v<std::decay_t<First>> && is_int_vector_v<std::decay_t<Second>>, bool> =
                     true>
-            GT_FUNCTION GT_CONSTEXPR auto operator-(First &&first, Second &&second) {
-                return plus(wstd::forward<First>(first), -wstd::forward<Second>(second));
+            GT_FORCE_INLINE constexpr auto operator-(First &&first, Second &&second) {
+                return plus(std::forward<First>(first), -std::forward<Second>(second));
             }
 
         } // namespace arithmetic
diff --git a/include/gridtools/common/integral_constant.hpp b/include/gridtools/common/integral_constant.hpp
index adf5b4d8a2..ccf3a9aec5 100644
--- a/include/gridtools/common/integral_constant.hpp
+++ b/include/gridtools/common/integral_constant.hpp
@@ -37,8 +37,6 @@ namespace gridtools {
     template <class T, T V>
     struct integral_constant : std::integral_constant<T, V> {
         using type = integral_constant;
-
-        constexpr GT_FUNCTION operator T() const noexcept { return V; }
     };
 
     // This predicate checks if the the class has `gridtools::integral_constant` as a public base, which has arithmetic
@@ -51,12 +49,13 @@ namespace gridtools {
         std::enable_if_t<std::is_base_of<integral_constant<typename T::value_type, T::value>, T>::value>>
         : std::true_type {};
 
-#define GT_INTEGRAL_CONSTANT_DEFINE_UNARY_OPERATOR(op, type)                                                           \
-    template <class T, T V>                                                                                            \
-    constexpr GT_FUNCTION integral_constant<decltype(op V), (op V)> operator op(integral_constant<T, V> &&) noexcept { \
-        return {};                                                                                                     \
-    }                                                                                                                  \
-    static_assert(1, "")
+#define GT_INTEGRAL_CONSTANT_DEFINE_UNARY_OPERATOR(op, type)                         \
+    template <class T, T V>                                                          \
+    GT_FORCE_INLINE constexpr integral_constant<decltype(op V), (op V)> operator op( \
+        integral_constant<T, V> &&) noexcept {                                       \
+        return {};                                                                   \
+    }                                                                                \
+    static_assert(1)
 
     GT_INTEGRAL_CONSTANT_DEFINE_UNARY_OPERATOR(+, T);
     GT_INTEGRAL_CONSTANT_DEFINE_UNARY_OPERATOR(-, T);
@@ -65,13 +64,13 @@ namespace gridtools {
 
 #undef GT_INTEGRAL_CONSTANT_DEFINE_UNARY_OPERATOR
 
-#define GT_INTEGRAL_CONSTANT_DEFINE_BINARY_OPERATOR(op, type)                            \
-    template <class T, T TV, class U, U UV>                                              \
-    constexpr GT_FUNCTION integral_constant<decltype(TV op UV), (TV op UV)> operator op( \
-        integral_constant<T, TV>, integral_constant<U, UV>) noexcept {                   \
-        return {};                                                                       \
-    }                                                                                    \
-    static_assert(1, "")
+#define GT_INTEGRAL_CONSTANT_DEFINE_BINARY_OPERATOR(op, type)                                \
+    template <class T, T TV, class U, U UV>                                                  \
+    GT_FORCE_INLINE constexpr integral_constant<decltype(TV op UV), (TV op UV)> operator op( \
+        integral_constant<T, TV>, integral_constant<U, UV>) noexcept {                       \
+        return {};                                                                           \
+    }                                                                                        \
+    static_assert(1)
 
     GT_INTEGRAL_CONSTANT_DEFINE_BINARY_OPERATOR(+, (std::common_type_t<T, U>));
     GT_INTEGRAL_CONSTANT_DEFINE_BINARY_OPERATOR(-, (std::common_type_t<T, U>));
@@ -115,10 +114,10 @@ namespace gridtools {
             }
             template <>
             constexpr literal_int_t to_int<16>(char c) {
-                return c >= 'A' && c <= 'F'
-                           ? c - 'A' + 10
-                           : c >= 'a' && c <= 'f' ? c - 'a' + 10
-                                                  : c >= '0' && c <= '9' ? c - '0' : throw "invalid hex _c literal";
+                return c >= 'A' && c <= 'F'   ? c - 'A' + 10
+                       : c >= 'a' && c <= 'f' ? c - 'a' + 10
+                       : c >= '0' && c <= '9' ? c - '0'
+                                              : throw "invalid hex _c literal";
             }
 
             template <literal_int_t Base>
@@ -150,7 +149,8 @@ namespace gridtools {
         } // namespace literals_impl_
 
         template <char... Chars>
-        constexpr GT_FUNCTION integral_constant<literals_impl_::literal_int_t, literals_impl_::parser<Chars...>::value>
+        GT_FORCE_INLINE constexpr integral_constant<literals_impl_::literal_int_t,
+            literals_impl_::parser<Chars...>::value>
         operator"" _c() {
             return {};
         }
diff --git a/include/gridtools/common/iterate_on_host_device.hpp b/include/gridtools/common/iterate_on_host_device.hpp
deleted file mode 100644
index 2e660f3cb4..0000000000
--- a/include/gridtools/common/iterate_on_host_device.hpp
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
- * GridTools
- *
- * Copyright (c) 2014-2021, ETH Zurich
- * All rights reserved.
- *
- * Please, refer to the LICENSE file in the root directory.
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-// DON'T USE #pragma once HERE!!!
-
-#if !defined(GT_FILENAME)
-#error GT_FILENAME is not defined
-#endif
-
-#if defined(GT_TARGET_ITERATING)
-#error nesting target iterating is not supported
-#endif
-
-#if defined(GT_TARGET)
-#error GT_TARGET should not be defined outside of this file
-#endif
-
-#if defined(GT_TARGET_NAMESPACE)
-#error GT_TARGET_NAMESPACE should not be defined outside of this file
-#endif
-
-#if defined(GT_TARGET_CONSTEXPR)
-#error GT_TARGET_NAMESPACE should not be defined outside of this file
-#endif
-
-#define GT_TARGET_ITERATING
-
-#ifdef GT_CUDACC
-
-#define GT_TARGET_NAMESPACE_NAME host
-#define GT_TARGET_NAMESPACE inline namespace host
-#define GT_TARGET GT_HOST
-#define GT_TARGET_CONSTEXPR constexpr
-
-#include GT_FILENAME
-#undef GT_TARGET
-#undef GT_TARGET_NAMESPACE
-#undef GT_TARGET_NAMESPACE_NAME
-#undef GT_TARGET_CONSTEXPR
-
-#define GT_TARGET_NAMESPACE_NAME host_device
-#define GT_TARGET_NAMESPACE namespace host_device
-#define GT_TARGET GT_HOST_DEVICE
-#define GT_TARGET_CONSTEXPR
-#define GT_TARGET_HAS_DEVICE
-#include GT_FILENAME
-#undef GT_TARGET_HAS_DEVICE
-#undef GT_TARGET
-#undef GT_TARGET_NAMESPACE
-#undef GT_TARGET_NAMESPACE_NAME
-#undef GT_TARGET_CONSTEXPR
-
-#define GT_TARGET_NAMESPACE_NAME device
-#define GT_TARGET_NAMESPACE namespace device
-#define GT_TARGET GT_DEVICE
-#define GT_TARGET_HAS_DEVICE
-#define GT_TARGET_CONSTEXPR
-#include GT_FILENAME
-#undef GT_TARGET_HAS_DEVICE
-#undef GT_TARGET
-#undef GT_TARGET_NAMESPACE
-#undef GT_TARGET_NAMESPACE_NAME
-#undef GT_TARGET_CONSTEXPR
-
-#else
-
-#define GT_TARGET_NAMESPACE_NAME host
-#define GT_TARGET_NAMESPACE   \
-    inline namespace host {}  \
-    namespace host_device {   \
-        using namespace host; \
-    }                         \
-    inline namespace host
-#define GT_TARGET GT_HOST
-#define GT_TARGET_CONSTEXPR constexpr
-#include GT_FILENAME
-#undef GT_TARGET
-#undef GT_TARGET_NAMESPACE
-#undef GT_TARGET_NAMESPACE_NAME
-#undef GT_TARGET_CONSTEXPR
-#endif
-
-#undef GT_TARGET_ITERATING
diff --git a/include/gridtools/common/pair.hpp b/include/gridtools/common/pair.hpp
deleted file mode 100644
index a3927e02e8..0000000000
--- a/include/gridtools/common/pair.hpp
+++ /dev/null
@@ -1,194 +0,0 @@
-/*
- * GridTools
- *
- * Copyright (c) 2014-2021, ETH Zurich
- * All rights reserved.
- *
- * Please, refer to the LICENSE file in the root directory.
- * SPDX-License-Identifier: BSD-3-Clause
- */
-#pragma once
-
-#include <cstddef>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-
-#include "defs.hpp"
-#include "host_device.hpp"
-#include "utility.hpp"
-
-namespace gridtools {
-    /** \ingroup common
-        @{
-        \defgroup pair Simple Pair
-        @{
-    */
-
-    /**
-       @brief simple pair with constexpr constructor
-
-       NOTE: can be replaced by std::pair
-     */
-    template <typename T1, typename T2>
-    struct pair {
-        pair() = default;
-
-        template <class U1, class U2>
-        GT_CONSTEXPR GT_FUNCTION pair(const std::pair<U1, U2> &p) : pair(p.first, p.second) {}
-
-        template <class U1, class U2>
-        GT_CONSTEXPR GT_FUNCTION pair(std::pair<U1, U2> &&p) : pair(wstd::move(p.first), wstd::move(p.second)) {}
-
-        GT_CONSTEXPR GT_FUNCTION pair(T1 const &t1_, T2 const &t2_) : first(t1_), second(t2_) {}
-
-        template <class U1, class U2>
-        GT_CONSTEXPR GT_FUNCTION pair(U1 &&t1_, U2 &&t2_)
-            : first(wstd::forward<U1>(t1_)), second(wstd::forward<U2>(t2_)) {}
-
-        template <class U1, class U2, std::enable_if_t<!std::is_same<pair<U1, U2>, pair>::value, int> = 0>
-        GT_CONSTEXPR GT_FUNCTION pair(pair<U1, U2> const &p) : first(p.first), second(p.second) {}
-
-        template <class U1, class U2, std::enable_if_t<!std::is_same<pair<U1, U2>, pair>::value, int> = 0>
-        GT_CONSTEXPR GT_FUNCTION pair(pair<U1, U2> &&p) : first(wstd::move(p.first)), second(wstd::move(p.second)) {}
-
-        template <typename U1, typename U2, std::enable_if_t<!std::is_same<pair<U1, U2>, pair>::value, int> = 0>
-        GT_FUNCTION pair &operator=(const pair<U1, U2> &other) {
-            first = other.first;
-            second = other.second;
-            return *this;
-        }
-
-        template <typename U1, typename U2, std::enable_if_t<!std::is_same<pair<U1, U2>, pair>::value, int> = 0>
-        GT_FUNCTION pair &operator=(pair<U1, U2> &&other) noexcept {
-            first = wstd::move(other.first);
-            second = wstd::move(other.second);
-            return *this;
-        }
-
-        T1 first;
-        T2 second;
-    };
-
-    template <typename T1, typename T2>
-    GT_CONSTEXPR GT_FUNCTION bool operator==(const pair<T1, T2> &lhs, const pair<T1, T2> &rhs) {
-        return lhs.first == rhs.first && lhs.second == rhs.second;
-    }
-
-    template <typename T1, typename T2>
-    GT_CONSTEXPR GT_FUNCTION bool operator!=(const pair<T1, T2> &lhs, const pair<T1, T2> &rhs) {
-        return !(lhs == rhs);
-    }
-
-    template <typename T1, typename T2>
-    GT_CONSTEXPR GT_FUNCTION bool operator<(const pair<T1, T2> &lhs, const pair<T1, T2> &rhs) {
-        return lhs.first < rhs.first || (!(rhs.first < lhs.first) && lhs.second < rhs.second);
-    }
-
-    template <typename T1, typename T2>
-    GT_CONSTEXPR GT_FUNCTION bool operator>(const pair<T1, T2> &lhs, const pair<T1, T2> &rhs) {
-        return rhs < lhs;
-    }
-
-    template <typename T1, typename T2>
-    GT_CONSTEXPR GT_FUNCTION bool operator<=(const pair<T1, T2> &lhs, const pair<T1, T2> &rhs) {
-        return !(rhs < lhs);
-    }
-
-    template <typename T1, typename T2>
-    GT_CONSTEXPR GT_FUNCTION bool operator>=(const pair<T1, T2> &lhs, const pair<T1, T2> &rhs) {
-        return !(lhs < rhs);
-    }
-
-    template <typename T1, typename T2>
-    GT_CONSTEXPR GT_FUNCTION pair<T1, T2> make_pair(T1 const &t1_, T2 const &t2_) {
-        return pair<T1, T2>(t1_, t2_);
-    }
-    /** @} */
-    /** @} */
-
-    namespace pair_impl_ {
-        template <std::size_t I>
-        struct pair_get;
-
-        template <>
-        struct pair_get<0> {
-            template <typename T1, typename T2>
-            static GT_CONSTEXPR GT_FUNCTION const T1 &const_get(const pair<T1, T2> &p) noexcept {
-                return p.first;
-            }
-            template <typename T1, typename T2>
-            static GT_FUNCTION T1 &get(pair<T1, T2> &p) noexcept {
-                return p.first;
-            }
-            template <typename T1, typename T2>
-            static GT_CONSTEXPR GT_FUNCTION T1 &&move_get(pair<T1, T2> &&p) noexcept {
-                return wstd::move(p.first);
-            }
-        };
-        template <>
-        struct pair_get<1> {
-            template <typename T1, typename T2>
-            static GT_CONSTEXPR GT_FUNCTION const T2 &const_get(const pair<T1, T2> &p) noexcept {
-                return p.second;
-            }
-            template <typename T1, typename T2>
-            static GT_FUNCTION T2 &get(pair<T1, T2> &p) noexcept {
-                return p.second;
-            }
-            template <typename T1, typename T2>
-            static GT_CONSTEXPR GT_FUNCTION T2 &&move_get(pair<T1, T2> &&p) noexcept {
-                return wstd::move(p.second);
-            }
-        };
-
-        struct getter {
-            template <std::size_t I, class T1, class T2>
-            static GT_CONSTEXPR GT_FUNCTION decltype(auto) get(pair<T1, T2> &p) noexcept {
-                return pair_get<I>::get(p);
-            }
-
-            template <std::size_t I, class T1, class T2>
-            static GT_CONSTEXPR GT_FUNCTION decltype(auto) get(const pair<T1, T2> &p) noexcept {
-                return pair_get<I>::const_get(p);
-            }
-
-            template <std::size_t I, class T1, class T2>
-            static GT_CONSTEXPR GT_FUNCTION decltype(auto) get(pair<T1, T2> &&p) noexcept {
-                return pair_get<I>::move_get(wstd::move(p));
-            }
-        };
-    } // namespace pair_impl_
-
-    template <std::size_t I, class T1, class T2>
-    GT_FUNCTION decltype(auto) get(pair<T1, T2> &p) noexcept {
-        return pair_impl_::pair_get<I>::get(p);
-    }
-
-    template <std::size_t I, class T1, class T2>
-    GT_CONSTEXPR GT_FUNCTION decltype(auto) get(const pair<T1, T2> &p) noexcept {
-        return pair_impl_::pair_get<I>::const_get(p);
-    }
-
-    template <std::size_t I, class T1, class T2>
-    GT_CONSTEXPR GT_FUNCTION decltype(auto) get(pair<T1, T2> &&p) noexcept {
-        return pair_impl_::pair_get<I>::move_get(wstd::move(p));
-    }
-
-    template <class T1, class T2>
-    pair_impl_::getter tuple_getter(pair<T1, T2> const &);
-} // namespace gridtools
-
-namespace std {
-    template <class T1, class T2>
-    struct tuple_size<::gridtools::pair<T1, T2>> : integral_constant<size_t, 2> {};
-
-    template <class T1, class T2>
-    struct tuple_element<0, ::gridtools::pair<T1, T2>> {
-        using type = T1;
-    };
-    template <class T1, class T2>
-    struct tuple_element<1, ::gridtools::pair<T1, T2>> {
-        using type = T2;
-    };
-} // namespace std
diff --git a/include/gridtools/common/tuple.hpp b/include/gridtools/common/tuple.hpp
index 0611eb9b4c..56667937ea 100644
--- a/include/gridtools/common/tuple.hpp
+++ b/include/gridtools/common/tuple.hpp
@@ -15,9 +15,7 @@
 #include <type_traits>
 
 #include "../meta/at.hpp"
-#include "defs.hpp"
 #include "host_device.hpp"
-#include "utility.hpp"
 
 namespace gridtools {
 
@@ -31,10 +29,10 @@ namespace gridtools {
             tuple_leaf &operator=(tuple_leaf const &) = default;
             tuple_leaf &operator=(tuple_leaf &&) = default;
 
-            GT_CONSTEXPR GT_FUNCTION tuple_leaf() noexcept : m_value() {}
+            GT_FORCE_INLINE constexpr tuple_leaf() noexcept : m_value() {}
 
             template <class Arg, std::enable_if_t<std::is_constructible<T, Arg &&>::value, int> = 0>
-            GT_CONSTEXPR GT_FUNCTION tuple_leaf(Arg &&arg) noexcept : m_value(wstd::forward<Arg>(arg)) {}
+            GT_FORCE_INLINE constexpr tuple_leaf(Arg &&arg) noexcept : m_value(std::forward<Arg>(arg)) {}
         };
 
         template <size_t I, class T>
@@ -46,37 +44,37 @@ namespace gridtools {
             tuple_leaf &operator=(tuple_leaf &&) = default;
 
             template <class Arg, std::enable_if_t<std::is_constructible<T, Arg &&>::value, int> = 0>
-            GT_CONSTEXPR GT_FUNCTION tuple_leaf(Arg &&arg) noexcept : T(wstd::forward<Arg>(arg)) {}
+            GT_FORCE_INLINE constexpr tuple_leaf(Arg &&arg) noexcept : T(std::forward<Arg>(arg)) {}
         };
 
         struct tuple_leaf_getter {
             template <size_t I, class T>
-            static GT_CONSTEXPR GT_FUNCTION T const &get(tuple_leaf<I, T, false> const &obj) noexcept {
+            static GT_FORCE_INLINE constexpr T const &get(tuple_leaf<I, T, false> const &obj) noexcept {
                 return obj.m_value;
             }
 
             template <size_t I, class T>
-            static GT_CONSTEXPR GT_FUNCTION T &get(tuple_leaf<I, T, false> &obj) noexcept {
+            static GT_FORCE_INLINE constexpr T &get(tuple_leaf<I, T, false> &obj) noexcept {
                 return obj.m_value;
             }
 
             template <size_t I, class T>
-            static GT_CONSTEXPR GT_FUNCTION T&& get(tuple_leaf<I, T, false> &&obj) noexcept {
+            static GT_FORCE_INLINE constexpr T &&get(tuple_leaf<I, T, false> &&obj) noexcept {
                 return static_cast<T &&>(get<I>(obj));
             }
 
             template <size_t I, class T>
-            static GT_CONSTEXPR GT_FUNCTION T const &get(tuple_leaf<I, T, true> const &obj) noexcept {
+            static GT_FORCE_INLINE constexpr T const &get(tuple_leaf<I, T, true> const &obj) noexcept {
                 return obj;
             }
 
             template <size_t I, class T>
-            static GT_CONSTEXPR GT_FUNCTION T &get(tuple_leaf<I, T, true> &obj) noexcept {
+            static GT_FORCE_INLINE constexpr T &get(tuple_leaf<I, T, true> &obj) noexcept {
                 return obj;
             }
 
             template <size_t I, class T>
-            static GT_CONSTEXPR GT_FUNCTION T&& get(tuple_leaf<I, T, true> &&obj) noexcept {
+            static GT_FORCE_INLINE constexpr T &&get(tuple_leaf<I, T, true> &&obj) noexcept {
                 return static_cast<T &&>(obj);
             }
         };
@@ -93,35 +91,32 @@ namespace gridtools {
             tuple_impl &operator=(tuple_impl &&) = default;
 
             template <class... Args>
-            GT_CONSTEXPR GT_FUNCTION tuple_impl(Args &&... args) noexcept
-                : tuple_leaf<Is, Ts>(wstd::forward<Args>(args))... {}
+            GT_FORCE_INLINE constexpr tuple_impl(Args &&...args) noexcept
+                : tuple_leaf<Is, Ts>(std::forward<Args>(args))... {}
 
             template <class Src>
-            GT_CONSTEXPR GT_FUNCTION tuple_impl(Src &&src) noexcept
-                : tuple_leaf<Is, Ts>(tuple_leaf_getter::get<Is>(wstd::forward<Src>(src)))... {}
+            GT_FORCE_INLINE constexpr tuple_impl(Src &&src) noexcept
+                : tuple_leaf<Is, Ts>(tuple_leaf_getter::get<Is>(std::forward<Src>(src)))... {}
 
-            GT_FORCE_INLINE void swap(tuple_impl &other) noexcept {
+            GT_FORCE_INLINE constexpr void swap(tuple_impl &other) noexcept {
                 using std::swap;
-                using loop_t = int[sizeof...(Is)];
-                void(loop_t{(swap(tuple_leaf_getter::get<Is>(*this), tuple_leaf_getter::get<Is>(other)), 0)...});
+                (..., swap(tuple_leaf_getter::get<Is>(*this), tuple_leaf_getter::get<Is>(other)));
             }
 
             template <class... Args,
                 std::enable_if_t<sizeof...(Ts) == sizeof...(Args) &&
                                      std::conjunction<std::is_assignable<Ts &, Args const &>...>::value,
                     int> = 0>
-            GT_CONSTEXPR GT_FUNCTION void assign(tuple_impl<std::index_sequence<Is...>, Args...> const &src) noexcept {
-                using loop_t = int[sizeof...(Is)];
-                void(loop_t{(tuple_leaf_getter::get<Is>(*this) = tuple_leaf_getter::get<Is>(src), 0)...});
+            GT_FORCE_INLINE constexpr void assign(tuple_impl<std::index_sequence<Is...>, Args...> const &src) noexcept {
+                (..., (tuple_leaf_getter::get<Is>(*this) = tuple_leaf_getter::get<Is>(src)));
             }
 
             template <class... Args,
                 std::enable_if_t<sizeof...(Ts) == sizeof...(Args) &&
                                      std::conjunction<std::is_assignable<Ts &, Args &&>...>::value,
                     int> = 0>
-            GT_CONSTEXPR GT_FUNCTION void assign(tuple_impl<std::index_sequence<Is...>, Args...> &&src) noexcept {
-                using loop_t = int[sizeof...(Is)];
-                void(loop_t{(tuple_leaf_getter::get<Is>(*this) = tuple_leaf_getter::get<Is>(wstd::move(src)), 0)...});
+            GT_FORCE_INLINE constexpr void assign(tuple_impl<std::index_sequence<Is...>, Args...> &&src) noexcept {
+                (..., (tuple_leaf_getter::get<Is>(*this) = tuple_leaf_getter::get<Is>(std::move(src))));
             }
         };
     } // namespace impl_
@@ -147,18 +142,18 @@ namespace gridtools {
 
         struct getter {
             template <size_t I>
-            static GT_CONSTEXPR GT_FUNCTION decltype(auto) get(tuple const &obj) noexcept {
+            static GT_FORCE_INLINE constexpr decltype(auto) get(tuple const &obj) noexcept {
                 return impl_::tuple_leaf_getter::get<I>(obj.m_impl);
             }
 
             template <size_t I>
-            static GT_CONSTEXPR GT_FUNCTION decltype(auto) get(tuple &obj) noexcept {
+            static GT_FORCE_INLINE constexpr decltype(auto) get(tuple &obj) noexcept {
                 return impl_::tuple_leaf_getter::get<I>(obj.m_impl);
             }
 
             template <size_t I>
-            static GT_CONSTEXPR GT_FUNCTION decltype(auto) get(tuple &&obj) noexcept {
-                return impl_::tuple_leaf_getter::get<I>(wstd::move(obj.m_impl));
+            static GT_FORCE_INLINE constexpr decltype(auto) get(tuple &&obj) noexcept {
+                return impl_::tuple_leaf_getter::get<I>(std::move(obj.m_impl));
             }
         };
         friend getter tuple_getter(tuple const &) { return {}; }
@@ -173,31 +168,31 @@ namespace gridtools {
         tuple &operator=(tuple const &) = default;
         tuple &operator=(tuple &&) = default;
 
-        GT_CONSTEXPR GT_FUNCTION tuple(Ts const &... args) noexcept : m_impl(args...) {}
+        GT_FORCE_INLINE constexpr tuple(Ts const &...args) noexcept : m_impl(args...) {}
 
         template <class... Args,
             std::enable_if_t<sizeof...(Ts) == sizeof...(Args) &&
                                  std::conjunction<std::is_constructible<Ts, Args &&>...>::value,
                 int> = 0>
-        GT_CONSTEXPR GT_FUNCTION tuple(Args &&...args) noexcept : m_impl(wstd::forward<Args>(args)...) {}
+        GT_FORCE_INLINE constexpr tuple(Args &&...args) noexcept : m_impl(std::forward<Args>(args)...) {}
 
         template <class... Args,
             std::enable_if_t<sizeof...(Ts) == sizeof...(Args) &&
                                  std::conjunction<std::is_constructible<Ts, Args const &>...>::value,
                 int> = 0>
-        GT_CONSTEXPR GT_FUNCTION tuple(tuple<Args...> const &src) noexcept : m_impl(src.m_impl) {}
+        GT_FORCE_INLINE constexpr tuple(tuple<Args...> const &src) noexcept : m_impl(src.m_impl) {}
 
         template <class... Args,
             std::enable_if_t<sizeof...(Ts) == sizeof...(Args) &&
                                  std::conjunction<std::is_constructible<Ts, Args &&>...>::value,
                 int> = 0>
-        GT_CONSTEXPR GT_FUNCTION tuple(tuple<Args...> &&src) noexcept : m_impl(wstd::move(src).m_impl) {}
+        GT_FORCE_INLINE constexpr tuple(tuple<Args...> &&src) noexcept : m_impl(std::move(src).m_impl) {}
 
-        GT_FORCE_INLINE void swap(tuple &other) noexcept { m_impl.swap(other.m_impl); }
+        GT_FORCE_INLINE constexpr void swap(tuple &other) noexcept { m_impl.swap(other.m_impl); }
 
         template <class Other>
-        GT_CONSTEXPR GT_FUNCTION tuple &operator=(Other &&other) {
-            m_impl.assign(wstd::forward<Other>(other).m_impl);
+        GT_FORCE_INLINE constexpr tuple &operator=(Other &&other) {
+            m_impl.assign(std::forward<Other>(other).m_impl);
             return *this;
         }
     };
@@ -207,17 +202,17 @@ namespace gridtools {
         T m_value;
         struct getter {
             template <size_t I, std::enable_if_t<I == 0, int> = 0>
-            static GT_CONSTEXPR GT_FUNCTION T const &get(tuple const &obj) noexcept {
+            static GT_FORCE_INLINE constexpr T const &get(tuple const &obj) noexcept {
                 return obj.m_value;
             }
 
             template <size_t I, std::enable_if_t<I == 0, int> = 0>
-            static GT_CONSTEXPR GT_FUNCTION T &get(tuple &obj) noexcept {
+            static GT_FORCE_INLINE constexpr T &get(tuple &obj) noexcept {
                 return obj.m_value;
             }
 
             template <size_t I, std::enable_if_t<I == 0, int> = 0>
-            static GT_CONSTEXPR GT_FUNCTION T &&get(tuple &&obj) noexcept {
+            static GT_FORCE_INLINE constexpr T &&get(tuple &&obj) noexcept {
                 return static_cast<T &&>(obj.m_value);
             }
         };
@@ -227,45 +222,45 @@ namespace gridtools {
         friend class tuple;
 
       public:
-        GT_CONSTEXPR GT_FUNCTION tuple() noexcept : m_value() {}
+        GT_FORCE_INLINE constexpr tuple() noexcept : m_value() {}
 
         tuple(tuple const &) = default;
         tuple(tuple &&) = default;
         tuple &operator=(tuple const &) = default;
         tuple &operator=(tuple &&) = default;
 
-        GT_CONSTEXPR GT_FUNCTION tuple(T const &arg) noexcept : m_value(arg) {}
+        GT_FORCE_INLINE constexpr tuple(T const &arg) noexcept : m_value(arg) {}
 
         template <class Arg, std::enable_if_t<std::is_constructible<T, Arg &&>::value, int> = 0>
-        GT_CONSTEXPR GT_FUNCTION tuple(Arg &&arg) noexcept : m_value(wstd::forward<Arg>(arg)) {}
+        GT_FORCE_INLINE constexpr tuple(Arg &&arg) noexcept : m_value(std::forward<Arg>(arg)) {}
 
         template <class Arg,
             std::enable_if_t<std::is_constructible<T, Arg const &>::value &&
                                  !std::is_convertible<tuple<Arg> const &, T>::value &&
                                  !std::is_constructible<T, tuple<Arg> const &>::value && !std::is_same<T, Arg>::value,
                 int> = 0>
-        GT_CONSTEXPR GT_FUNCTION tuple(tuple<Arg> const &src) noexcept : m_value(src.m_value) {}
+        GT_FORCE_INLINE constexpr tuple(tuple<Arg> const &src) noexcept : m_value(src.m_value) {}
 
         template <class Arg,
             std::enable_if_t<std::is_constructible<T, Arg &&>::value && !std::is_convertible<tuple<Arg>, T>::value &&
                                  !std::is_constructible<T, tuple<Arg>>::value && !std::is_same<T, Arg>::value,
                 int> = 0>
-        GT_CONSTEXPR GT_FUNCTION tuple(tuple<Arg> &&src) noexcept : m_value(wstd::move(src).m_value) {}
+        GT_FORCE_INLINE constexpr tuple(tuple<Arg> &&src) noexcept : m_value(std::move(src).m_value) {}
 
-        GT_FORCE_INLINE void swap(tuple &other) noexcept {
+        GT_FORCE_INLINE constexpr void swap(tuple &other) noexcept {
             using std::swap;
             swap(m_value, other.m_value);
         }
 
         template <class Arg, std::enable_if_t<std::is_assignable<T &, Arg const &>::value, int> = 0>
-        GT_CONSTEXPR GT_FUNCTION tuple &operator=(tuple<Arg> const &src) noexcept {
+        GT_FORCE_INLINE constexpr tuple &operator=(tuple<Arg> const &src) noexcept {
             m_value = src.m_value;
             return *this;
         }
 
         template <class Arg, std::enable_if_t<std::is_assignable<T &, Arg &&>::value, int> = 0>
-        GT_CONSTEXPR GT_FUNCTION tuple &operator=(tuple<Arg> &&src) noexcept {
-            m_value = wstd::move(src).m_value;
+        GT_FORCE_INLINE constexpr tuple &operator=(tuple<Arg> &&src) noexcept {
+            m_value = std::move(src).m_value;
             return *this;
         }
     };
@@ -275,27 +270,27 @@ namespace gridtools {
         friend tuple tuple_getter(tuple const &) { return {}; }
 
       public:
-        GT_FORCE_INLINE void swap(tuple &) noexcept {}
+        GT_FORCE_INLINE constexpr void swap(tuple &) noexcept {}
     };
 
     template <class... Ts>
-    GT_FORCE_INLINE void swap(tuple<Ts...> &lhs, tuple<Ts...> &rhs) noexcept {
+    GT_FORCE_INLINE constexpr void swap(tuple<Ts...> &lhs, tuple<Ts...> &rhs) noexcept {
         lhs.swap(rhs);
     }
 
     template <size_t I, class... Ts>
-    GT_CONSTEXPR GT_FUNCTION decltype(auto) get(tuple<Ts...> const &obj) noexcept {
+    GT_FORCE_INLINE constexpr decltype(auto) get(tuple<Ts...> const &obj) noexcept {
         return decltype(tuple_getter(obj))::template get<I>(obj);
     }
 
     template <size_t I, class... Ts>
-    GT_CONSTEXPR GT_FUNCTION decltype(auto) get(tuple<Ts...> &obj) noexcept {
+    GT_FORCE_INLINE constexpr decltype(auto) get(tuple<Ts...> &obj) noexcept {
         return decltype(tuple_getter(std::declval<tuple<Ts...> const &>()))::template get<I>(obj);
     }
 
     template <size_t I, class... Ts>
-    GT_CONSTEXPR GT_FUNCTION decltype(auto) get(tuple<Ts...> &&obj) noexcept {
-        return decltype(tuple_getter(std::declval<tuple<Ts...> const &>()))::template get<I>(wstd::move(obj));
+    GT_FORCE_INLINE constexpr decltype(auto) get(tuple<Ts...> &&obj) noexcept {
+        return decltype(tuple_getter(std::declval<tuple<Ts...> const &>()))::template get<I>(std::move(obj));
     }
 } // namespace gridtools
 
diff --git a/include/gridtools/common/tuple_util.hpp b/include/gridtools/common/tuple_util.hpp
index 2715bb102d..178c3efd3c 100644
--- a/include/gridtools/common/tuple_util.hpp
+++ b/include/gridtools/common/tuple_util.hpp
@@ -95,10 +95,20 @@
  *
  */
 
-#ifndef GT_TARGET_ITERATING
-//// DON'T USE #pragma once HERE!!!
-#ifndef GT_COMMON_TUPLE_UTIL_HPP_
-#define GT_COMMON_TUPLE_UTIL_HPP_
+/*
+vertical_advection_dycore_gpu
+positional_stencil_gpu
+positional_stencil_gpu_horizontal
+alignment_gpu
+alignment_gpu_horizontal
+whole_axis_access_gpu
+whole_axis_access_gpu_horizontal
+test_kcache_fill_gpu
+test_kcache_fill_and_flush_gpu
+test_kcache_flush_gpu
+*/
+
+#pragma once
 
 #include <array>
 #include <tuple>
@@ -116,40 +126,38 @@
 #include "defs.hpp"
 #include "functional.hpp"
 #include "host_device.hpp"
-#include "implicit_cast.hpp"
-#include "utility.hpp"
-
-#define GT_TUPLE_UTIL_FORWARD_GETTER_TO_MEMBER(class_name, member_name)                                    \
-    struct class_name##_tuple_util_getter {                                                                \
-        template <::std::size_t I>                                                                         \
-        static GT_CONSTEXPR GT_FUNCTION decltype(auto) get(class_name const &obj) {                        \
-            return ::gridtools::tuple_util::host_device::get<I>(obj.member_name);                          \
-        }                                                                                                  \
-        template <::std::size_t I>                                                                         \
-        static GT_FUNCTION decltype(auto) get(class_name &obj) {                                           \
-            return ::gridtools::tuple_util::host_device::get<I>(obj.member_name);                          \
-        }                                                                                                  \
-        template <::std::size_t I>                                                                         \
-        static GT_CONSTEXPR GT_FUNCTION decltype(auto) get(class_name &&obj) {                             \
-            return ::gridtools::tuple_util::host_device::get<I>(::gridtools::wstd::move(obj).member_name); \
-        }                                                                                                  \
-    };                                                                                                     \
-    friend class_name##_tuple_util_getter tuple_getter(class_name const &) { return {}; }                  \
-    static_assert(1, "")
+
+#define GT_TUPLE_UTIL_FORWARD_GETTER_TO_MEMBER(class_name, member_name)                   \
+    struct class_name##_tuple_util_getter {                                               \
+        template <::std::size_t I>                                                        \
+        static GT_FORCE_INLINE constexpr decltype(auto) get(class_name const &obj) {      \
+            return ::gridtools::tuple_util::get<I>(obj.member_name);                      \
+        }                                                                                 \
+        template <::std::size_t I>                                                        \
+        static GT_FORCE_INLINE constexpr decltype(auto) get(class_name &obj) {            \
+            return ::gridtools::tuple_util::get<I>(obj.member_name);                      \
+        }                                                                                 \
+        template <::std::size_t I>                                                        \
+        static GT_FORCE_INLINE constexpr decltype(auto) get(class_name &&obj) {           \
+            return ::gridtools::tuple_util::get<I>(::std::move(obj).member_name);         \
+        }                                                                                 \
+    };                                                                                    \
+    friend class_name##_tuple_util_getter tuple_getter(class_name const &) { return {}; } \
+    static_assert(1)
 
 #define GT_STRUCT_TUPLE_IMPL_DECL_(r, data, elem) BOOST_PP_TUPLE_ELEM(0, elem) BOOST_PP_TUPLE_ELEM(1, elem);
 #define GT_STRUCT_TUPLE_IMPL_TYPE_(s, data, elem) BOOST_PP_TUPLE_ELEM(0, elem)
 #define GT_STRUCT_TUPLE_IMPL_GETS_(s, name, i, elem)                                                        \
     template <::std::size_t I, ::std::enable_if_t<I == i, int> = 0, class T = BOOST_PP_TUPLE_ELEM(0, elem)> \
-    static GT_CONSTEXPR GT_FUNCTION T const &get(name const &obj) {                                         \
+    static GT_FORCE_INLINE constexpr T const &get(name const &obj) {                                        \
         return obj.BOOST_PP_TUPLE_ELEM(1, elem);                                                            \
     }                                                                                                       \
     template <::std::size_t I, ::std::enable_if_t<I == i, int> = 0, class T = BOOST_PP_TUPLE_ELEM(0, elem)> \
-    static GT_FUNCTION T &get(name &obj) {                                                                  \
+    static GT_FORCE_INLINE constexpr T &get(name &obj) {                                                    \
         return obj.BOOST_PP_TUPLE_ELEM(1, elem);                                                            \
     }                                                                                                       \
     template <::std::size_t I, ::std::enable_if_t<I == i, int> = 0, class T = BOOST_PP_TUPLE_ELEM(0, elem)> \
-    static GT_CONSTEXPR GT_FUNCTION T &&get(name &&obj) {                                                   \
+    static GT_FORCE_INLINE constexpr T &&get(name &&obj) {                                                  \
         return static_cast<T &&>(obj.BOOST_PP_TUPLE_ELEM(1, elem));                                         \
     }
 #define GT_STRUCT_TUPLE_IMPL_(name, members)                                                                          \
@@ -191,12 +199,29 @@
  */
 #define GT_STRUCT_TUPLE(name, ...) GT_STRUCT_TUPLE_IMPL_(name, BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__))
 
+#ifdef GT_CUDACC
+#define DEFINE_FUNCTOR_INSTANCE(name, functor)                      \
+    template <class... Args>                                        \
+    GT_FORCE_INLINE constexpr decltype(auto) name(Args &&...args) { \
+        return functor()(std::forward<Args>(args)...);              \
+    }                                                               \
+    static_assert(1)
+#ifdef __NVCC__
+#define DEFINE_TEMPLATED_FUNCTOR_INSTANCE(name, functor) GT_DEVICE constexpr functor name = {}
+#else
+#define DEFINE_TEMPLATED_FUNCTOR_INSTANCE(name, functor) constexpr functor name = {}
+#endif
+#else
+#define DEFINE_FUNCTOR_INSTANCE(name, functor) constexpr functor name = {}
+#define DEFINE_TEMPLATED_FUNCTOR_INSTANCE(name, functor) constexpr functor name = {}
+#endif
+
 namespace gridtools {
     namespace tuple_util {
 
         /// @cond
         namespace traits {
-            namespace _impl {
+            namespace impl_ {
 
                 template <class... Ts>
                 struct deduce_array_type : std::common_type<Ts...> {};
@@ -218,10 +243,10 @@ namespace gridtools {
                 struct std_getter {
                     template <size_t I, class T>
                     GT_FORCE_INLINE static constexpr decltype(auto) get(T &&obj) noexcept {
-                        return std::get<I>(wstd::forward<T>(obj));
+                        return std::get<I>(std::forward<T>(obj));
                     }
                 };
-            } // namespace _impl
+            } // namespace impl_
 
             // start of builtin adaptations
 
@@ -248,17 +273,17 @@ namespace gridtools {
 
             // arrays specialization.
             template <class T, size_t N>
-            _impl::array_from_types tuple_from_types(std::array<T, N>);
+            impl_::array_from_types tuple_from_types(std::array<T, N>);
 
             // getter
 
             // all `std` "tuple_like"s use `std::get`
             template <class... Ts>
-            _impl::std_getter tuple_getter(std::tuple<Ts...>);
+            impl_::std_getter tuple_getter(std::tuple<Ts...>);
             template <class T, class U>
-            _impl::std_getter tuple_getter(std::pair<T, U>);
+            impl_::std_getter tuple_getter(std::pair<T, U>);
             template <class T, size_t N>
-            _impl::std_getter tuple_getter(std::array<T, N>);
+            impl_::std_getter tuple_getter(std::array<T, N>);
 
             // end of builtin adaptations
 
@@ -304,9 +329,7 @@ namespace gridtools {
         template <class Tup>
         struct is_empty_or_tuple_of_empties<Tup, std::enable_if_t<is_tuple_of_empties<Tup>::value>> : std::true_type {};
 
-        // Here goes the stuff that is common for all targets (meta functions)
-        namespace _impl {
-
+        namespace impl_ {
             template <class T>
             using to_types = meta::rename<meta::list, traits::to_types<std::decay_t<T>>>;
 
@@ -445,1205 +468,1058 @@ namespace gridtools {
                       // check that the getters produce expected types for all indices
                       meta::all_of<meta::curry<is_getter_valid, T, Getter, Types>::template apply,
                           meta::make_indices_for<Types>>::value> {};
-        } // namespace _impl
+        } // namespace impl_
 
         template <class, class = void>
         struct is_tuple_like : std::false_type {};
 
         template <class T>
-        struct is_tuple_like<T, std::enable_if_t<_impl::is_tuple_like<T>::value>> : std::true_type {};
-    } // namespace tuple_util
-
-    using tuple_util::is_tuple_like;
+        struct is_tuple_like<T, std::enable_if_t<impl_::is_tuple_like<T>::value>> : std::true_type {};
 
-#ifdef __cpp_concepts
-    namespace concepts {
-        template <class T>
-        concept tuple_like = is_tuple_like<T>::value;
-
-        template <class T, class... Ts>
-        concept tuple_like_of = tuple_like<T> &&
-            std::is_same_v<meta::rename<meta::list, tuple_util::traits::to_types<T>>, meta::list<Ts...>>;
-    } // namespace concepts
-#endif
-
-} // namespace gridtools
-
-// Now it's time to generate host/device/host_device stuff
-#define GT_FILENAME <gridtools/common/tuple_util.hpp>
-#include GT_ITERATE_ON_TARGETS()
-#undef GT_FILENAME
-
-#endif // GT_COMMON_TUPLE_UTIL_HPP_
-#else  // GT_TARGET_ITERATING
-
-#ifdef GT_TARGET_HAS_DEVICE
-
-#define DEFINE_FUNCTOR_INSTANCE(name, functor)                                          \
-    template <class... Args>                                                            \
-    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) name(Args &&...args) { \
-        return functor()(wstd::forward<Args>(args)...);                                 \
-    }                                                                                   \
-    static_assert(1, "")
-
-#ifdef __NVCC__
-#define DEFINE_TEMPLATED_FUNCTOR_INSTANCE(name, functor) GT_DEVICE constexpr functor name = {}
-#else
-#define DEFINE_TEMPLATED_FUNCTOR_INSTANCE(name, functor) constexpr functor name = {}
-#endif
-
-#else
-
-#define DEFINE_FUNCTOR_INSTANCE(name, functor) constexpr functor name = {}
-
-#define DEFINE_TEMPLATED_FUNCTOR_INSTANCE(name, functor) constexpr functor name = {}
-
-#endif
-
-namespace gridtools {
-    namespace tuple_util {
-        GT_TARGET_NAMESPACE {
-            /**
-             * @brief Tuple element accessor like std::get.
-             *
-             * @tparam I Element index.
-             * @tparam T Tuple-like type.
-             * @param obj Tuple-like object.
-             */
-            template <size_t I, class T, class Getter = traits::getter<std::decay_t<T>>>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) get(T && obj) noexcept {
-                return Getter::template get<I>(wstd::forward<T>(obj));
+        template <size_t I>
+        struct get_f {
+            template <class T, class Getter = traits::getter<std::decay_t<T>>>
+            GT_FORCE_INLINE constexpr decltype(auto) operator()(T &&obj) const noexcept {
+                return Getter::template get<I>(std::forward<T>(obj));
             }
-
+        };
+
+        /**
+         * @brief Tuple element accessor like std::get.
+         *
+         * @tparam I Element index.
+         * @tparam T Tuple-like type.
+         * @param obj Tuple-like object.
+         */
+        template <size_t I>
+        DEFINE_TEMPLATED_FUNCTOR_INSTANCE(get, get_f<I>);
+
+        namespace impl_ {
             template <size_t I>
-            struct get_nth_f {
-                template <class T, class Getter = traits::getter<std::decay_t<T>>>
-                GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) operator()(T &&obj) const noexcept {
-                    return Getter::template get<I>(wstd::forward<T>(obj));
+            struct transform_elem_index_f {
+                template <class Fun, class... Tups>
+                GT_FORCE_INLINE constexpr decltype(auto) operator()(Fun &&fun, Tups &&...tups) const {
+                    return std::forward<Fun>(fun).template operator()<I>(get<I>(std::forward<Tups>(tups))...);
                 }
             };
 
-            // Let us use `detail` for internal namespace of the target dependent namespace.
-            // This way we can refer `_impl::foo` for the entities that are independent on the target and
-            // `detail::bar` for the target dependent ones.
-            namespace detail {
-                using _impl::from_types;
-                using _impl::get_accessors;
-                using _impl::get_fun_result;
-                using _impl::to_types;
-
-                template <size_t I>
-                struct transform_elem_index_f {
-                    template <class Fun, class... Tups>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) operator()(
-                        Fun &&fun, Tups &&...tups) const {
-                        return wstd::forward<Fun>(fun).template operator()<I>(
-                            GT_TARGET_NAMESPACE_NAME::get<I>(wstd::forward<Tups>(tups))...);
-                    }
-                };
+            template <class I>
+            using get_transform_index_generator = transform_elem_index_f<I::value>;
 
-                template <class I>
-                using get_transform_index_generator = transform_elem_index_f<I::value>;
-
-                template <class GeneratorList, class Res>
-                struct generate_f;
-                template <template <class...> class L, class... Generators, class Res>
-                struct generate_f<L<Generators...>, Res> {
-                    template <class... Args>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res operator()(Args &&...args) const {
-                        return Res{Generators{}(wstd::forward<Args>(args)...)...};
-                    }
-                };
+            template <class GeneratorList, class Res>
+            struct generate_f;
+            template <template <class...> class L, class... Generators, class Res>
+            struct generate_f<L<Generators...>, Res> {
+                template <class... Args>
+                GT_FORCE_INLINE constexpr Res operator()(Args &&...args) const {
+                    return Res{Generators{}(std::forward<Args>(args)...)...};
+                }
+            };
 
-                template <class Fun>
-                struct transform_index_f {
-                    template <class... Args>
-                    using get_results_t = meta::transform<_impl::get_fun_result_index<Fun>::template apply, Args...>;
-
-                    Fun m_fun;
-
-                    template <class Tup, class... Tups>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR auto operator()(Tup &&tup, Tups &&...tups) const {
-                        using indices_t = meta::make_indices<size<std::decay_t<Tup>>>;
-                        using res_t =
-                            from_types<Tup, get_results_t<indices_t, get_accessors<Tup>, get_accessors<Tups>...>>;
-                        using generators_t = meta::transform<get_transform_index_generator, indices_t>;
-                        return generate_f<generators_t, res_t>()(
-                            m_fun, wstd::forward<Tup>(tup), wstd::forward<Tups>(tups)...);
-                    }
-                };
+            template <class Fun>
+            struct transform_index_f {
+                template <class... Args>
+                using get_results_t = meta::transform<get_fun_result_index<Fun>::template apply, Args...>;
+
+                Fun m_fun;
+
+                template <class Tup, class... Tups>
+                GT_FORCE_INLINE constexpr auto operator()(Tup &&tup, Tups &&...tups) const {
+                    using indices_t = meta::make_indices<size<std::decay_t<Tup>>>;
+                    using res_t = from_types<Tup, get_results_t<indices_t, get_accessors<Tup>, get_accessors<Tups>...>>;
+                    using generators_t = meta::transform<get_transform_index_generator, indices_t>;
+                    return generate_f<generators_t, res_t>()(
+                        m_fun, std::forward<Tup>(tup), std::forward<Tups>(tups)...);
+                }
+            };
 
-                template <class Fun>
-                struct add_index_arg_f {
-                    Fun m_fun;
+            template <class Fun>
+            struct add_index_arg_f {
+                Fun m_fun;
 
-                    template <size_t I, class... Args>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR auto operator()(Args &&...args) const
-                        -> decltype(m_fun(wstd::forward<Args>(args)...)) {
-                        return m_fun(wstd::forward<Args>(args)...);
-                    }
-                };
+                template <size_t I, class... Args>
+                GT_FORCE_INLINE constexpr auto operator()(Args &&...args) const
+                    -> decltype(m_fun(std::forward<Args>(args)...)) {
+                    return m_fun(std::forward<Args>(args)...);
+                }
+            };
 
-                template <class Fun>
-                using transform_f = transform_index_f<add_index_arg_f<Fun>>;
-
-                template <class Fun>
-                struct for_each_adaptor_f {
-                    Fun m_fun;
-                    template <size_t I, class... Args>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR meta::lazy::id<void> operator()(
-                        Args &&...args) const {
-                        m_fun(wstd::forward<Args>(args)...);
-                        return {};
-                    }
-                };
+            template <class Fun>
+            using transform_f = transform_index_f<add_index_arg_f<Fun>>;
 
-                template <class Fun>
-                struct for_each_index_adaptor_f {
-                    Fun m_fun;
-                    template <size_t I, class... Args>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR meta::lazy::id<void> operator()(
-                        Args &&...args) const {
-                        m_fun.template operator()<I>(wstd::forward<Args>(args)...);
-                        return {};
-                    }
-                };
+            template <class Fun>
+            struct for_each_adaptor_f {
+                Fun m_fun;
+                template <size_t I, class... Args>
+                GT_FORCE_INLINE constexpr meta::lazy::id<void> operator()(Args &&...args) const {
+                    m_fun(std::forward<Args>(args)...);
+                    return {};
+                }
+            };
 
-                template <class Indices>
-                struct apply_to_elements_f;
+            template <class Fun>
+            struct for_each_index_adaptor_f {
+                Fun m_fun;
+                template <size_t I, class... Args>
+                GT_FORCE_INLINE constexpr meta::lazy::id<void> operator()(Args &&...args) const {
+                    m_fun.template operator()<I>(std::forward<Args>(args)...);
+                    return {};
+                }
+            };
 
-                template <template <class...> class L, class... Is>
-                struct apply_to_elements_f<L<Is...>> {
-                    template <class Fun, class... Tups>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) operator()(
-                        Fun &&fun, Tups &&...tups) const {
-                        return wstd::forward<Fun>(fun)(
-                            GT_TARGET_NAMESPACE_NAME::get<Is::value>(wstd::forward<Tups>(tups))...);
-                    }
-                };
+            template <class Indices>
+            struct apply_to_elements_f;
 
-                template <class>
-                struct for_each_in_cartesian_product_impl_f;
-
-                template <template <class...> class Outer, class... Inners>
-                struct for_each_in_cartesian_product_impl_f<Outer<Inners...>> {
-                    template <class Fun, class... Tups>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR void operator()(Fun &&fun, Tups &&...tups) const {
-                        using loop_t = int[sizeof...(Inners)];
-                        void(loop_t{
-                            (apply_to_elements_f<Inners>{}(wstd::forward<Fun>(fun), wstd::forward<Tups>(tups)...),
-                                0)...});
-                    }
-                };
+            template <template <class...> class L, class... Is>
+            struct apply_to_elements_f<L<Is...>> {
+                template <class Fun, class... Tups>
+                GT_FORCE_INLINE constexpr decltype(auto) operator()(Fun &&fun, Tups &&...tups) const {
+                    return std::forward<Fun>(fun)(get<Is::value>(std::forward<Tups>(tups))...);
+                }
+            };
 
-                template <class Fun>
-                struct for_each_in_cartesian_product_f {
-                    Fun m_fun;
-                    template <class... Tups>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR void operator()(Tups &&...tups) const {
-                        for_each_in_cartesian_product_impl_f<
-                            meta::cartesian_product<meta::make_indices_c<size<std::decay_t<Tups>>::value>...>>{}(
-                            m_fun, wstd::forward<Tups>(tups)...);
-                    }
-                };
+            template <class>
+            struct for_each_in_cartesian_product_impl_f;
+
+            template <template <class...> class Outer, class... Inners>
+            struct for_each_in_cartesian_product_impl_f<Outer<Inners...>> {
+                template <class Fun, class... Tups>
+                GT_FORCE_INLINE constexpr void operator()(Fun &&fun, Tups &&...tups) const {
+                    using loop_t = int[sizeof...(Inners)];
+                    void(loop_t{
+                        (apply_to_elements_f<Inners>{}(std::forward<Fun>(fun), std::forward<Tups>(tups)...), 0)...});
+                }
+            };
 
-                struct skip_me {
-                    template <class T>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR skip_me(T &&) {}
-                };
+            template <class Fun>
+            struct for_each_in_cartesian_product_f {
+                Fun m_fun;
+                template <class... Tups>
+                GT_FORCE_INLINE constexpr void operator()(Tups &&...tups) const {
+                    for_each_in_cartesian_product_impl_f<
+                        meta::cartesian_product<meta::make_indices_c<size<std::decay_t<Tups>>::value>...>>{}(
+                        m_fun, std::forward<Tups>(tups)...);
+                }
+            };
 
-                template <size_t>
-                using skip_me_type = skip_me;
+            struct skip_me {
+                template <class T>
+                GT_FORCE_INLINE constexpr skip_me(T &&) {}
+            };
 
-                template <class IndicesToSkip>
-                struct select_arg_f;
+            template <size_t>
+            using skip_me_type = skip_me;
 
-                template <size_t... IndicesToSkip>
-                struct select_arg_f<std::index_sequence<IndicesToSkip...>> {
-                    template <class T, class... Ts>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR T &&operator()(
-                        skip_me_type<IndicesToSkip> &&..., T &&obj, Ts &&...) const {
-                        return wstd::forward<T>(obj);
-                    }
-                };
+            template <class IndicesToSkip>
+            struct select_arg_f;
 
-                template <class ResultMaker>
-                struct concat_f {
-                    template <class OuterI, class InnerI>
-                    struct generator_f {
-                        template <class... Tups>
-                        GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) operator()(Tups &&...tups) const {
-                            return GT_TARGET_NAMESPACE_NAME::get<InnerI::value>(
-                                select_arg_f<std::make_index_sequence<OuterI::value>>{}(wstd::forward<Tups>(tups)...));
-                        }
-                    };
-
-                    template <class OuterI, class InnerTup>
-                    using get_inner_generators = meta::transform<meta::curry<generator_f, OuterI>::template apply,
-                        meta::make_indices_for<InnerTup>>;
+            template <size_t... IndicesToSkip>
+            struct select_arg_f<std::index_sequence<IndicesToSkip...>> {
+                template <class T, class... Ts>
+                GT_FORCE_INLINE constexpr T &&operator()(skip_me_type<IndicesToSkip> &&..., T &&obj, Ts &&...) const {
+                    return std::forward<T>(obj);
+                }
+            };
 
+            template <class ResultMaker>
+            struct concat_f {
+                template <class OuterI, class InnerI>
+                struct generator_f {
                     template <class... Tups>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR auto operator()(Tups &&...tups) const {
-                        using accessors_t = meta::transform<get_accessors, meta::list<Tups...>>;
-                        using res_t =
-                            typename ResultMaker::template apply<meta::flatten<accessors_t>, meta::list<Tups...>>;
-                        using generators_t = meta::flatten<
-                            meta::transform<get_inner_generators, meta::make_indices_for<accessors_t>, accessors_t>>;
-                        return generate_f<generators_t, res_t>{}(wstd::forward<Tups>(tups)...);
+                    GT_FORCE_INLINE constexpr decltype(auto) operator()(Tups &&...tups) const {
+                        return get<InnerI::value>(
+                            select_arg_f<std::make_index_sequence<OuterI::value>>{}(std::forward<Tups>(tups)...));
                     }
                 };
 
-                template <class ResultMaker>
-                struct flatten_f {
-                    template <class OuterI, class InnerI>
-                    struct generator_f {
-                        template <class Tup>
-                        GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) operator()(Tup &&tup) const {
-                            return GT_TARGET_NAMESPACE_NAME::get<InnerI::value>(
-                                GT_TARGET_NAMESPACE_NAME::get<OuterI::value>(wstd::forward<Tup>(tup)));
-                        }
-                    };
-
-                    template <class OuterI, class InnerTup>
-                    using get_inner_generators = meta::transform<meta::curry<generator_f, OuterI>::template apply,
-                        meta::make_indices_for<InnerTup>>;
+                template <class OuterI, class InnerTup>
+                using get_inner_generators =
+                    meta::transform<meta::curry<generator_f, OuterI>::template apply, meta::make_indices_for<InnerTup>>;
+
+                template <class... Tups>
+                GT_FORCE_INLINE constexpr auto operator()(Tups &&...tups) const {
+                    using accessors_t = meta::transform<get_accessors, meta::list<Tups...>>;
+                    using res_t = typename ResultMaker::template apply<meta::flatten<accessors_t>, meta::list<Tups...>>;
+                    using generators_t = meta::flatten<
+                        meta::transform<get_inner_generators, meta::make_indices_for<accessors_t>, accessors_t>>;
+                    return generate_f<generators_t, res_t>{}(std::forward<Tups>(tups)...);
+                }
+            };
 
+            template <class ResultMaker>
+            struct flatten_f {
+                template <class OuterI, class InnerI>
+                struct generator_f {
                     template <class Tup>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR auto operator()(Tup &&tup) const {
-                        static_assert(size<Tup>::value != 0, "can not flatten empty tuple");
-                        using accessors_t = meta::transform<get_accessors, get_accessors<Tup>>;
-                        using res_t = typename ResultMaker::template apply<meta::flatten<accessors_t>, to_types<Tup>>;
-                        using generators_t = meta::flatten<
-                            meta::transform<get_inner_generators, meta::make_indices_for<accessors_t>, accessors_t>>;
-                        return generate_f<generators_t, res_t>{}(wstd::forward<Tup>(tup));
-                    }
-                };
-
-                template <size_t N>
-                struct drop_front_f {
-                    template <class I>
-                    using get_drop_front_generator = get_nth_f<N + I::value>;
-
-                    template <class Tup,
-                        class Accessors = get_accessors<Tup>,
-                        class Res = from_types<Tup, meta::drop_front_c<N, Accessors>>>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res operator()(Tup &&tup) const {
-                        using generators =
-                            meta::transform<get_drop_front_generator, meta::make_indices_c<size<Accessors>::value - N>>;
-                        return generate_f<generators, Res>{}(wstd::forward<Tup>(tup));
-                    }
-                };
-
-                template <class, class>
-                struct push_back_impl_f;
-
-                template <template <class T, T...> class L, class Int, Int... Is, class Res>
-                struct push_back_impl_f<L<Int, Is...>, Res> {
-                    template <class Tup, class... Args>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res operator()(Tup &&tup, Args &&...args) const {
-                        return Res{GT_TARGET_NAMESPACE_NAME::get<Is>(wstd::forward<Tup>(tup))...,
-                            wstd::forward<Args>(args)...};
+                    GT_FORCE_INLINE constexpr decltype(auto) operator()(Tup &&tup) const {
+                        return get<InnerI::value>(get<OuterI::value>(std::forward<Tup>(tup)));
                     }
                 };
 
-                struct push_back_f {
-                    template <class Tup,
-                        class... Args,
-                        class Accessors = get_accessors<Tup>,
-                        class Res = from_types<Tup, meta::push_back<Accessors, Args &&...>>>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res operator()(Tup &&tup, Args &&...args) const {
-                        return push_back_impl_f<std::make_index_sequence<size<Accessors>::value>, Res>{}(
-                            wstd::forward<Tup>(tup), wstd::forward<Args>(args)...);
-                    }
-                };
-
-                template <class, class>
-                struct push_front_impl_f;
-
-                template <template <class T, T...> class L, class Int, Int... Is, class Res>
-                struct push_front_impl_f<L<Int, Is...>, Res> {
-                    template <class Tup, class... Args>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res operator()(Tup &&tup, Args &&...args) const {
-                        return Res{wstd::forward<Args>(args)...,
-                            GT_TARGET_NAMESPACE_NAME::get<Is>(wstd::forward<Tup>(tup))...};
-                    }
-                };
+                template <class OuterI, class InnerTup>
+                using get_inner_generators =
+                    meta::transform<meta::curry<generator_f, OuterI>::template apply, meta::make_indices_for<InnerTup>>;
+
+                template <class Tup>
+                GT_FORCE_INLINE constexpr auto operator()(Tup &&tup) const {
+                    static_assert(size<Tup>::value != 0, "can not flatten empty tuple");
+                    using accessors_t = meta::transform<get_accessors, get_accessors<Tup>>;
+                    using res_t = typename ResultMaker::template apply<meta::flatten<accessors_t>, to_types<Tup>>;
+                    using generators_t = meta::flatten<
+                        meta::transform<get_inner_generators, meta::make_indices_for<accessors_t>, accessors_t>>;
+                    return generate_f<generators_t, res_t>{}(std::forward<Tup>(tup));
+                }
+            };
 
-                struct push_front_f {
-                    template <class Tup,
-                        class... Args,
-                        class Accessors = get_accessors<Tup>,
-                        class Res = from_types<Tup, meta::push_front<Accessors, Args &&...>>>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res operator()(Tup &&tup, Args &&...args) const {
-                        return push_front_impl_f<std::make_index_sequence<size<Accessors>::value>, Res>{}(
-                            wstd::forward<Tup>(tup), wstd::forward<Args>(args)...);
-                    }
-                };
+            template <size_t N>
+            struct drop_front_f {
+                template <class I>
+                using get_drop_front_generator = get_f<N + I::value>;
+
+                template <class Tup,
+                    class Accessors = get_accessors<Tup>,
+                    class Res = from_types<Tup, meta::drop_front_c<N, Accessors>>>
+                GT_FORCE_INLINE constexpr Res operator()(Tup &&tup) const {
+                    using generators =
+                        meta::transform<get_drop_front_generator, meta::make_indices_c<size<Accessors>::value - N>>;
+                    return generate_f<generators, Res>{}(std::forward<Tup>(tup));
+                }
+            };
 
-                template <class, class>
-                struct pop_back_impl_f;
+            template <class, class>
+            struct push_back_impl_f;
 
-                template <template <class T, T...> class L, class Int, Int... Is, class Res>
-                struct pop_back_impl_f<L<Int, Is...>, Res> {
-                    template <class Tup>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res operator()(Tup &&tup) const {
-                        return Res{GT_TARGET_NAMESPACE_NAME::get<Is>(wstd::forward<Tup>(tup))...};
-                    }
-                };
+            template <template <class T, T...> class L, class Int, Int... Is, class Res>
+            struct push_back_impl_f<L<Int, Is...>, Res> {
+                template <class Tup, class... Args>
+                GT_FORCE_INLINE constexpr Res operator()(Tup &&tup, Args &&...args) const {
+                    return Res{get<Is>(std::forward<Tup>(tup))..., std::forward<Args>(args)...};
+                }
+            };
 
-                struct pop_back_f {
-                    template <class Tup,
-                        class Accessors = get_accessors<Tup>,
-                        class Res = from_types<Tup, meta::pop_front<Accessors>>>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res operator()(Tup &&tup) const {
-                        return pop_back_impl_f<std::make_index_sequence<size<Accessors>::value - 1>, Res>()(
-                            wstd::forward<Tup>(tup));
-                    }
-                };
+            struct push_back_f {
+                template <class Tup,
+                    class... Args,
+                    class Accessors = get_accessors<Tup>,
+                    class Res = from_types<Tup, meta::push_back<Accessors, Args &&...>>>
+                GT_FORCE_INLINE constexpr Res operator()(Tup &&tup, Args &&...args) const {
+                    return push_back_impl_f<std::make_index_sequence<size<Accessors>::value>, Res>{}(
+                        std::forward<Tup>(tup), std::forward<Args>(args)...);
+                }
+            };
 
-                template <class, class>
-                struct pop_front_impl_f;
+            template <class, class>
+            struct push_front_impl_f;
 
-                template <template <class T, T...> class L, class Int, Int... Is, class Res>
-                struct pop_front_impl_f<L<Int, Is...>, Res> {
-                    template <class Tup>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res operator()(Tup &&tup) const {
-                        return Res{GT_TARGET_NAMESPACE_NAME::get<Is + 1>(wstd::forward<Tup>(tup))...};
-                    }
-                };
+            template <template <class T, T...> class L, class Int, Int... Is, class Res>
+            struct push_front_impl_f<L<Int, Is...>, Res> {
+                template <class Tup, class... Args>
+                GT_FORCE_INLINE constexpr Res operator()(Tup &&tup, Args &&...args) const {
+                    return Res{std::forward<Args>(args)..., get<Is>(std::forward<Tup>(tup))...};
+                }
+            };
 
-                struct pop_front_f {
-                    template <class Tup,
-                        class Accessors = get_accessors<Tup>,
-                        class Res = from_types<Tup, meta::pop_front<Accessors>>>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res operator()(Tup &&tup) const {
-                        return pop_front_impl_f<std::make_index_sequence<size<Accessors>::value - 1>, Res>()(
-                            wstd::forward<Tup>(tup));
-                    }
-                };
+            struct push_front_f {
+                template <class Tup,
+                    class... Args,
+                    class Accessors = get_accessors<Tup>,
+                    class Res = from_types<Tup, meta::push_front<Accessors, Args &&...>>>
+                GT_FORCE_INLINE constexpr Res operator()(Tup &&tup, Args &&...args) const {
+                    return push_front_impl_f<std::make_index_sequence<size<Accessors>::value>, Res>{}(
+                        std::forward<Tup>(tup), std::forward<Args>(args)...);
+                }
+            };
 
-                template <class Fun>
-                struct fold_f {
-                    template <class S, class T>
-                    using meta_fun = typename get_fun_result<Fun>::template apply<S, T>;
-                    Fun m_fun;
+            template <class, class>
+            struct pop_back_impl_f;
 
-                    template <size_t I, size_t N, class State, class Tup, std::enable_if_t<I == N, int> = 0>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR State impl(State &&state, Tup &&) const {
-                        return state;
-                    }
+            template <template <class T, T...> class L, class Int, Int... Is, class Res>
+            struct pop_back_impl_f<L<Int, Is...>, Res> {
+                template <class Tup>
+                GT_FORCE_INLINE constexpr Res operator()(Tup &&tup) const {
+                    return Res{get<Is>(std::forward<Tup>(tup))...};
+                }
+            };
 
-                    template <size_t I, size_t N, class State, class Tup, std::enable_if_t<I + 1 == N, int> = 0>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) impl(State &&state, Tup &&tup) const {
-                        return m_fun(
-                            wstd::forward<State>(state), GT_TARGET_NAMESPACE_NAME::get<I>(wstd::forward<Tup>(tup)));
-                    }
+            struct pop_back_f {
+                template <class Tup,
+                    class Accessors = get_accessors<Tup>,
+                    class Res = from_types<Tup, meta::pop_front<Accessors>>>
+                GT_FORCE_INLINE constexpr Res operator()(Tup &&tup) const {
+                    return pop_back_impl_f<std::make_index_sequence<size<Accessors>::value - 1>, Res>()(
+                        std::forward<Tup>(tup));
+                }
+            };
 
-                    template <size_t I, size_t N, class State, class Tup, std::enable_if_t<I + 2 == N, int> = 0>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) impl(State &&state, Tup &&tup) const {
-                        return m_fun(m_fun(wstd::forward<State>(state),
-                                         GT_TARGET_NAMESPACE_NAME::get<I>(wstd::forward<Tup>(tup))),
-                            GT_TARGET_NAMESPACE_NAME::get<I + 1>(wstd::forward<Tup>(tup)));
-                    }
+            template <class, class>
+            struct pop_front_impl_f;
 
-                    template <size_t I, size_t N, class State, class Tup, std::enable_if_t<I + 3 == N, int> = 0>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) impl(State &&state, Tup &&tup) const {
-                        return m_fun(m_fun(m_fun(wstd::forward<State>(state),
-                                               GT_TARGET_NAMESPACE_NAME::get<I>(wstd::forward<Tup>(tup))),
-                                         GT_TARGET_NAMESPACE_NAME::get<I + 1>(wstd::forward<Tup>(tup))),
-                            GT_TARGET_NAMESPACE_NAME::get<I + 2>(wstd::forward<Tup>(tup)));
-                    }
+            template <template <class T, T...> class L, class Int, Int... Is, class Res>
+            struct pop_front_impl_f<L<Int, Is...>, Res> {
+                template <class Tup>
+                GT_FORCE_INLINE constexpr Res operator()(Tup &&tup) const {
+                    return Res{get<Is + 1>(std::forward<Tup>(tup))...};
+                }
+            };
 
-                    template <size_t I, size_t N, class State, class Tup, std::enable_if_t<I + 4 == N, int> = 0>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) impl(State &&state, Tup &&tup) const {
-                        return m_fun(m_fun(m_fun(m_fun(wstd::forward<State>(state),
-                                                     GT_TARGET_NAMESPACE_NAME::get<I>(wstd::forward<Tup>(tup))),
-                                               GT_TARGET_NAMESPACE_NAME::get<I + 1>(wstd::forward<Tup>(tup))),
-                                         GT_TARGET_NAMESPACE_NAME::get<I + 2>(wstd::forward<Tup>(tup))),
-                            GT_TARGET_NAMESPACE_NAME::get<I + 3>(wstd::forward<Tup>(tup)));
-                    }
+            struct pop_front_f {
+                template <class Tup,
+                    class Accessors = get_accessors<Tup>,
+                    class Res = from_types<Tup, meta::pop_front<Accessors>>>
+                GT_FORCE_INLINE constexpr Res operator()(Tup &&tup) const {
+                    return pop_front_impl_f<std::make_index_sequence<size<Accessors>::value - 1>, Res>()(
+                        std::forward<Tup>(tup));
+                }
+            };
 
-                    template <size_t I,
-                        size_t N,
-                        class State,
-                        class Tup,
-                        class AllAccessors = get_accessors<Tup>,
-                        class Accessors = meta::drop_front_c<I, AllAccessors>,
-                        class Res = meta::foldl<meta_fun, State, Accessors>,
-                        std::enable_if_t<(I + 4 < N), int> = 0>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res impl(State &&state, Tup &&tup) const {
-                        return impl<I + 5, N>(
-                            m_fun(m_fun(m_fun(m_fun(m_fun(wstd::forward<State>(state),
-                                                        GT_TARGET_NAMESPACE_NAME::get<I>(wstd::forward<Tup>(tup))),
-                                                  GT_TARGET_NAMESPACE_NAME::get<I + 1>(wstd::forward<Tup>(tup))),
-                                            GT_TARGET_NAMESPACE_NAME::get<I + 2>(wstd::forward<Tup>(tup))),
-                                      GT_TARGET_NAMESPACE_NAME::get<I + 3>(wstd::forward<Tup>(tup))),
-                                GT_TARGET_NAMESPACE_NAME::get<I + 4>(wstd::forward<Tup>(tup))),
-                            wstd::forward<Tup>(tup));
-                    }
+            template <class Fun>
+            struct fold_f {
+                template <class S, class T>
+                using meta_fun = typename get_fun_result<Fun>::template apply<S, T>;
+                Fun m_fun;
+
+                template <size_t I, size_t N, class State, class Tup, std::enable_if_t<I == N, int> = 0>
+                GT_FORCE_INLINE constexpr State impl(State &&state, Tup &&) const {
+                    return state;
+                }
 
-                    template <class State,
-                        class Tup,
-                        class Accessors = get_accessors<Tup>,
-                        class Res = meta::foldl<meta_fun, State, Accessors>>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res operator()(State &&state, Tup &&tup) const {
-                        return impl<0, size<std::decay_t<Tup>>::value>(
-                            wstd::forward<State>(state), wstd::forward<Tup>(tup));
-                    }
+                template <size_t I, size_t N, class State, class Tup, std::enable_if_t<I + 1 == N, int> = 0>
+                GT_FORCE_INLINE constexpr decltype(auto) impl(State &&state, Tup &&tup) const {
+                    return m_fun(std::forward<State>(state), get<I>(std::forward<Tup>(tup)));
+                }
 
-                    template <class Tup,
-                        class AllAccessors = get_accessors<Tup>,
-                        class StateAccessor = meta::first<AllAccessors>,
-                        class Accessors = meta::drop_front_c<1, AllAccessors>,
-                        class Res = meta::foldl<meta_fun, StateAccessor, Accessors>>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res operator()(Tup &&tup) const {
-                        return impl<1, size<std::decay_t<Tup>>::value>(
-                            GT_TARGET_NAMESPACE_NAME::get<0>(wstd::forward<Tup>(tup)), wstd::forward<Tup>(tup));
-                    }
-                };
+                template <size_t I, size_t N, class State, class Tup, std::enable_if_t<I + 2 == N, int> = 0>
+                GT_FORCE_INLINE constexpr decltype(auto) impl(State &&state, Tup &&tup) const {
+                    return m_fun(m_fun(std::forward<State>(state), get<I>(std::forward<Tup>(tup))),
+                        get<I + 1>(std::forward<Tup>(tup)));
+                }
 
-                template <class Fun>
-                struct all_of_f {
-                    Fun m_fun;
+                template <size_t I, size_t N, class State, class Tup, std::enable_if_t<I + 3 == N, int> = 0>
+                GT_FORCE_INLINE constexpr decltype(auto) impl(State &&state, Tup &&tup) const {
+                    return m_fun(m_fun(m_fun(std::forward<State>(state), get<I>(std::forward<Tup>(tup))),
+                                     get<I + 1>(std::forward<Tup>(tup))),
+                        get<I + 2>(std::forward<Tup>(tup)));
+                }
 
-                    template <size_t I, size_t N, class... Tups, std::enable_if_t<I == N, int> = 0>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR bool impl(Tups &&...) const {
-                        return true;
-                    }
+                template <size_t I, size_t N, class State, class Tup, std::enable_if_t<I + 4 == N, int> = 0>
+                GT_FORCE_INLINE constexpr decltype(auto) impl(State &&state, Tup &&tup) const {
+                    return m_fun(m_fun(m_fun(m_fun(std::forward<State>(state), get<I>(std::forward<Tup>(tup))),
+                                           get<I + 1>(std::forward<Tup>(tup))),
+                                     get<I + 2>(std::forward<Tup>(tup))),
+                        get<I + 3>(std::forward<Tup>(tup)));
+                }
 
-                    template <size_t I, size_t N, class... Tups, std::enable_if_t<I + 1 == N, int> = 0>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR bool impl(Tups &&...tups) const {
-                        return m_fun(GT_TARGET_NAMESPACE_NAME::get<I>(wstd::forward<Tups>(tups))...);
-                    }
+                template <size_t I,
+                    size_t N,
+                    class State,
+                    class Tup,
+                    class AllAccessors = get_accessors<Tup>,
+                    class Accessors = meta::drop_front_c<I, AllAccessors>,
+                    class Res = meta::foldl<meta_fun, State, Accessors>,
+                    std::enable_if_t<(I + 4 < N), int> = 0>
+                GT_FORCE_INLINE constexpr Res impl(State &&state, Tup &&tup) const {
+                    return impl<I + 5, N>(
+                        m_fun(m_fun(m_fun(m_fun(m_fun(std::forward<State>(state), get<I>(std::forward<Tup>(tup))),
+                                              get<I + 1>(std::forward<Tup>(tup))),
+                                        get<I + 2>(std::forward<Tup>(tup))),
+                                  get<I + 3>(std::forward<Tup>(tup))),
+                            get<I + 4>(std::forward<Tup>(tup))),
+                        std::forward<Tup>(tup));
+                }
 
-                    template <size_t I, size_t N, class... Tups, std::enable_if_t<I + 2 == N, int> = 0>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR bool impl(Tups &&...tups) const {
-                        return m_fun(GT_TARGET_NAMESPACE_NAME::get<I>(wstd::forward<Tups>(tups))...) &&
-                               m_fun(GT_TARGET_NAMESPACE_NAME::get<I + 1>(wstd::forward<Tups>(tups))...);
-                    }
+                template <class State,
+                    class Tup,
+                    class Accessors = get_accessors<Tup>,
+                    class Res = meta::foldl<meta_fun, State, Accessors>>
+                GT_FORCE_INLINE constexpr Res operator()(State &&state, Tup &&tup) const {
+                    return impl<0, size<std::decay_t<Tup>>::value>(std::forward<State>(state), std::forward<Tup>(tup));
+                }
 
-                    template <size_t I, size_t N, class... Tups, std::enable_if_t<I + 3 == N, int> = 0>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR bool impl(Tups &&...tups) const {
-                        return m_fun(GT_TARGET_NAMESPACE_NAME::get<I>(wstd::forward<Tups>(tups))...) &&
-                               m_fun(GT_TARGET_NAMESPACE_NAME::get<I + 1>(wstd::forward<Tups>(tups))...) &&
-                               m_fun(GT_TARGET_NAMESPACE_NAME::get<I + 2>(wstd::forward<Tups>(tups))...);
-                    }
+                template <class Tup,
+                    class AllAccessors = get_accessors<Tup>,
+                    class StateAccessor = meta::first<AllAccessors>,
+                    class Accessors = meta::drop_front_c<1, AllAccessors>,
+                    class Res = meta::foldl<meta_fun, StateAccessor, Accessors>>
+                GT_FORCE_INLINE constexpr Res operator()(Tup &&tup) const {
+                    return impl<1, size<std::decay_t<Tup>>::value>(
+                        get<0>(std::forward<Tup>(tup)), std::forward<Tup>(tup));
+                }
+            };
 
-                    template <size_t I, size_t N, class... Tups, std::enable_if_t<I + 4 == N, int> = 0>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR bool impl(Tups &&...tups) const {
-                        return m_fun(GT_TARGET_NAMESPACE_NAME::get<I>(wstd::forward<Tups>(tups))...) &&
-                               m_fun(GT_TARGET_NAMESPACE_NAME::get<I + 1>(wstd::forward<Tups>(tups))...) &&
-                               m_fun(GT_TARGET_NAMESPACE_NAME::get<I + 2>(wstd::forward<Tups>(tups))...) &&
-                               m_fun(GT_TARGET_NAMESPACE_NAME::get<I + 3>(wstd::forward<Tups>(tups))...);
-                    }
+            template <class To, class Index>
+            struct implicit_convert_to_f {
+                using type = implicit_convert_to_f;
+                template <class Tup>
+                GT_FORCE_INLINE constexpr To operator()(Tup &&tup) const {
+                    return get<Index::value>(std::forward<Tup>(tup));
+                }
+            };
 
-                    template <size_t I, size_t N, class... Tups, std::enable_if_t<(I + 4 < N), int> = 0>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR bool impl(Tups &&...tups) const {
-                        return m_fun(GT_TARGET_NAMESPACE_NAME::get<I>(wstd::forward<Tups>(tups))...) &&
-                               m_fun(GT_TARGET_NAMESPACE_NAME::get<I + 1>(wstd::forward<Tups>(tups))...) &&
-                               m_fun(GT_TARGET_NAMESPACE_NAME::get<I + 2>(wstd::forward<Tups>(tups))...) &&
-                               m_fun(GT_TARGET_NAMESPACE_NAME::get<I + 3>(wstd::forward<Tups>(tups))...) &&
-                               impl<I + 4, N>(wstd::forward<Tups>(tups)...);
-                    }
+            template <class DstFromTypesMetaClass>
+            struct convert_to_f {
+                template <class Tup,
+                    class ToTypes = get_accessors<Tup>,
+                    class Res = meta::rename<DstFromTypesMetaClass::template apply, ToTypes>>
+                GT_FORCE_INLINE constexpr Res operator()(Tup &&tup) const {
+                    using generators_t =
+                        meta::transform<implicit_convert_to_f, to_types<Res>, meta::make_indices_for<ToTypes>>;
+                    return generate_f<generators_t, Res>{}(std::forward<Tup>(tup));
+                }
+            };
 
-                    template <class Tup, class... Tups>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR bool operator()(Tup &&tup, Tups &&...tups) const {
-                        return impl<0, size<std::decay_t<Tup>>::value>(
-                            wstd::forward<Tup>(tup), wstd::forward<Tups>(tups)...);
-                    }
+            struct transpose_f {
+                template <class Tup>
+                struct get_inner_tuple_f {
+                    template <class Types>
+                    using apply = from_types<Tup, Types>;
                 };
 
-                template <class To, class Index>
-                struct implicit_convert_to_f {
-                    using type = implicit_convert_to_f;
-                    template <class Tup>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR To operator()(Tup &&tup) const {
-                        return GT_TARGET_NAMESPACE_NAME::get<Index::value>(wstd::forward<Tup>(tup));
-                    }
-                };
+                template <class I>
+                using get_generator = transform_f<get_f<I::value>>;
 
-                template <class DstFromTypesMetaClass>
-                struct convert_to_f {
-                    template <class Tup,
-                        class ToTypes = get_accessors<Tup>,
-                        class Res = meta::rename<DstFromTypesMetaClass::template apply, ToTypes>>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res operator()(Tup &&tup) const {
-                        using generators_t =
-                            meta::transform<implicit_convert_to_f, to_types<Res>, meta::make_indices_for<ToTypes>>;
-                        return generate_f<generators_t, Res>{}(wstd::forward<Tup>(tup));
-                    }
-                };
+                template <class Tup>
+                GT_FORCE_INLINE constexpr std::enable_if_t<tuple_util::size<std::decay_t<Tup>>::value == 0> operator()(
+                    Tup &&) const {
+                    static_assert(
+                        tuple_util::size<std::decay_t<Tup>>::value, "tuple_util::transpose input should not be empty");
+                }
 
-                struct transpose_f {
-                    template <class Tup>
-                    struct get_inner_tuple_f {
-                        template <class Types>
-                        using apply = from_types<Tup, Types>;
-                    };
+                template <class Tup,
+                    class First = meta::first<to_types<Tup>>,
+                    class Accessors = meta::transform<get_accessors, get_accessors<Tup>>,
+                    class Types = meta::transpose<Accessors>,
+                    class InnerTuples = meta::transform<get_inner_tuple_f<Tup>::template apply, Types>,
+                    class Res = from_types<First, InnerTuples>>
+                GT_FORCE_INLINE constexpr Res operator()(Tup &&tup) const {
+                    using inner_indices_t = meta::make_indices_for<to_types<First>>;
+                    using generators_t = meta::transform<get_generator, inner_indices_t>;
+                    return generate_f<generators_t, Res>{}(std::forward<Tup>(tup));
+                }
+            };
 
+            struct reverse_f {
+                template <class N>
+                struct generator_f {
                     template <class I>
-                    using get_generator = transform_f<get_nth_f<I::value>>;
-
-                    template <class Tup>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR
-                        std::enable_if_t<tuple_util::size<std::decay_t<Tup>>::value == 0>
-                        operator()(Tup &&) const {
-                        static_assert(tuple_util::size<std::decay_t<Tup>>::value,
-                            "tuple_util::transpose input should not be empty");
-                    }
-
-                    template <class Tup,
-                        class First = meta::first<to_types<Tup>>,
-                        class Accessors = meta::transform<get_accessors, get_accessors<Tup>>,
-                        class Types = meta::transpose<Accessors>,
-                        class InnerTuples = meta::transform<get_inner_tuple_f<Tup>::template apply, Types>,
-                        class Res = from_types<First, InnerTuples>>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res operator()(Tup &&tup) const {
-                        using inner_indices_t = meta::make_indices_for<to_types<First>>;
-                        using generators_t = meta::transform<get_generator, inner_indices_t>;
-                        return generate_f<generators_t, Res>{}(wstd::forward<Tup>(tup));
-                    }
-                };
-
-                struct reverse_f {
-                    template <class N>
-                    struct generator_f {
-                        template <class I>
-                        using apply = get_nth_f<N::value - 1 - I::value>;
-                    };
-
-                    template <class Tup,
-                        class Accessors = get_accessors<Tup>,
-                        class Res = from_types<Tup, meta::reverse<Accessors>>>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res operator()(Tup &&tup) const {
-                        using n_t = size<std::decay_t<Tup>>;
-                        using generators_t = meta::transform<generator_f<n_t>::template apply, meta::make_indices<n_t>>;
-                        return generate_f<generators_t, Res>{}(wstd::forward<Tup>(tup));
-                    }
+                    using apply = get_f<N::value - 1 - I::value>;
                 };
 
-                template <size_t I>
-                struct insert_tup_generator_f {
-                    using type = insert_tup_generator_f;
+                template <class Tup,
+                    class Accessors = get_accessors<Tup>,
+                    class Res = from_types<Tup, meta::reverse<Accessors>>>
+                GT_FORCE_INLINE constexpr Res operator()(Tup &&tup) const {
+                    using n_t = size<std::decay_t<Tup>>;
+                    using generators_t = meta::transform<generator_f<n_t>::template apply, meta::make_indices<n_t>>;
+                    return generate_f<generators_t, Res>{}(std::forward<Tup>(tup));
+                }
+            };
 
-                    template <class Tup, class Val>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) operator()(Tup &&tup, Val &&) const {
-                        return GT_TARGET_NAMESPACE_NAME::get<I>(wstd::forward<Tup>(tup));
-                    }
-                };
+            template <size_t I>
+            struct insert_tup_generator_f {
+                using type = insert_tup_generator_f;
 
-                struct insert_val_generator_f {
-                    using type = insert_val_generator_f;
-                    template <class Tup, class Val>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Val operator()(Tup &&, Val &&val) const {
-                        return wstd::forward<Val>(val);
-                    }
-                };
+                template <class Tup, class Val>
+                GT_FORCE_INLINE constexpr decltype(auto) operator()(Tup &&tup, Val &&) const {
+                    return get<I>(std::forward<Tup>(tup));
+                }
+            };
 
-                template <size_t N, class Val>
-                struct insert_f {
-                    Val m_val;
+            struct insert_val_generator_f {
+                using type = insert_val_generator_f;
+                template <class Tup, class Val>
+                GT_FORCE_INLINE constexpr Val operator()(Tup &&, Val &&val) const {
+                    return std::forward<Val>(val);
+                }
+            };
 
-                    template <class I>
-                    using get_generator =
-                        meta::if_c <
-                        I::value<N,
-                            insert_tup_generator_f<I::value>,
-                            meta::if_c<I::value == N, insert_val_generator_f, insert_tup_generator_f<I::value - 1>>>;
-
-                    template <class Tup,
-                        class Accessors = get_accessors<Tup>,
-                        class Types = meta::insert_c<N, Accessors, Val>,
-                        class Res = from_types<Tup, Types>>
-                    GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res operator()(Tup &&tup) const {
-                        using generators_t = meta::transform<get_generator, meta::make_indices_for<Types>>;
-                        return generate_f<generators_t, Res>{}(wstd::forward<Tup>(tup), m_val);
-                    }
-                };
-            } // namespace detail
-
-            /**
-             * @brief Transforms each tuple element by a function.
-             *
-             * Transformations with functions with more than one argument are supported by passing multiple tuples of
-             * the same size.
-             *
-             * @tparam Fun Functor type.
-             * @tparam Tup Optional tuple-like type.
-             * @tparam Tups Optional Tuple-like types.
-             *
-             * @param fun Function that should be applied to all elements of the given tuple(s).
-             * @param tup First tuple-like object, serves as first arguments to `fun` if given.
-             * @param tups Further tuple-like objects, serve as additional arguments to `fun` if given.
-             *
-             * Example code:
-             * @code
-             * #include <functional>
-             * using namespace std::placeholders;
-             *
-             * struct add {
-             *     template < class A, class B >
-             *     auto operator()(A a, B b) -> decltype(a + b) {
-             *         return a + b;
-             *     }
-             * };
-             *
-             * // Unary function, like boost::fusion::transform
-             * auto tup = std::tuple(1, 2, 3.5);
-             * auto fun = std::bind(add{}, 2, _1);
-             * auto res = transform(fun, tup);
-             * // res == {3, 4, 5.5}
-             *
-             * // Binary function
-             * auto tup2 = std::tuple(1.5, 3, 4.1);
-             * auto res2 = transform(add{}, tup, tup2);
-             * // res2 == {2.5, 5, 7.6}
-             * @endcode
-             */
-            template <class Fun, class Tup, class... Tups>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR auto transform(Fun && fun, Tup && tup, Tups && ...tups) {
-                return detail::transform_f<Fun>{{wstd::forward<Fun>(fun)}}(
-                    wstd::forward<Tup>(tup), wstd::forward<Tups>(tups)...);
-            }
+            template <size_t N, class Val>
+            struct insert_f {
+                Val m_val;
 
-            /**
-             * @brief Returns a functor that transforms each tuple element by a function.
-             *
-             * Composable version of `transform` that returns a functor which can be invoked with (one or multiple)
-             * tuples.
-             *
-             * @tparam Fun Functor type.
-             *
-             * @param fun Function that should be applied to all elements of the given tuple(s).
-             *
-             * Example code:
-             * @code
-             * struct add {
-             *     template < class A, class B >
-             *     auto operator()(A a, B b) -> decltype(a + b) {
-             *         return a + b;
-             *     }
-             * };
-             *
-             * // Composable usage with only a function argument
-             * auto addtuples = transform(add{});
-             * // addtuples takes now two tuples as arguments
-             * auto tup1 = std::tuple(1, 2, 3.5);
-             * auto tup2 = std::tuple(1.5, 3, 4.1);
-             * auto res = addtuples(tup1, tup2)
-             * // res == {2.5, 5, 7.6}
-             * @endcode
-             */
-            template <class Fun>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR detail::transform_f<Fun> transform(Fun fun) {
-                return {wstd::move(fun)};
-            }
-
-            template <class Fun, class Tup, class... Tups>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR auto transform_index(
-                Fun && fun, Tup && tup, Tups && ...tups) {
-                return detail::transform_index_f<Fun>{wstd::forward<Fun>(fun)}(
-                    wstd::forward<Tup>(tup), wstd::forward<Tups>(tups)...);
-            }
+                template <class I>
+                using get_generator =
+                    meta::if_c <
+                    I::value<N,
+                        insert_tup_generator_f<I::value>,
+                        meta::if_c<I::value == N, insert_val_generator_f, insert_tup_generator_f<I::value - 1>>>;
+
+                template <class Tup,
+                    class Accessors = get_accessors<Tup>,
+                    class Types = meta::insert_c<N, Accessors, Val>,
+                    class Res = from_types<Tup, Types>>
+                GT_FORCE_INLINE constexpr Res operator()(Tup &&tup) const {
+                    using generators_t = meta::transform<get_generator, meta::make_indices_for<Types>>;
+                    return generate_f<generators_t, Res>{}(std::forward<Tup>(tup), m_val);
+                }
+            };
 
-            template <class Fun>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR detail::transform_index_f<Fun> transform_index(Fun fun) {
-                return {wstd::move(fun)};
+            template <class Fun, class Tup, std::size_t... Is>
+            GT_FORCE_INLINE constexpr decltype(auto) apply_impl(Fun &&f, Tup &&tup, std::index_sequence<Is...>) {
+                return std::forward<Fun>(f)(get<Is>(std::forward<Tup>(tup))...);
             }
+        } // namespace impl_
+
+        /**
+         * @brief Transforms each tuple element by a function.
+         *
+         * Transformations with functions with more than one argument are supported by passing multiple tuples of
+         * the same size.
+         *
+         * @tparam Fun Functor type.
+         * @tparam Tup Optional tuple-like type.
+         * @tparam Tups Optional Tuple-like types.
+         *
+         * @param fun Function that should be applied to all elements of the given tuple(s).
+         * @param tup First tuple-like object, serves as first arguments to `fun` if given.
+         * @param tups Further tuple-like objects, serve as additional arguments to `fun` if given.
+         *
+         * Example code:
+         * @code
+         * #include <functional>
+         * using namespace std::placeholders;
+         *
+         * struct add {
+         *     template < class A, class B >
+         *     auto operator()(A a, B b) -> decltype(a + b) {
+         *         return a + b;
+         *     }
+         * };
+         *
+         * // Unary function, like boost::fusion::transform
+         * auto tup = std::tuple(1, 2, 3.5);
+         * auto fun = std::bind(add{}, 2, _1);
+         * auto res = transform(fun, tup);
+         * // res == {3, 4, 5.5}
+         *
+         * // Binary function
+         * auto tup2 = std::tuple(1.5, 3, 4.1);
+         * auto res2 = transform(add{}, tup, tup2);
+         * // res2 == {2.5, 5, 7.6}
+         * @endcode
+         */
+        template <class Fun, class Tup, class... Tups>
+        GT_FORCE_INLINE constexpr auto transform(Fun &&fun, Tup &&tup, Tups &&...tups) {
+            return impl_::transform_f<Fun>{{std::forward<Fun>(fun)}}(
+                std::forward<Tup>(tup), std::forward<Tups>(tups)...);
+        }
 
-            /**
-             * @brief Calls a function for each element in a tuple.
-             *
-             * Functions with more than one argument are supported by passing multiple tuples of the same size. If only
-             * a function but no tuples are passed, a composable functor is returned.
-             *
-             * @tparam Fun Functor type.
-             * @tparam Tup Optional tuple-like type.
-             * @tparam Tups Optional Tuple-like types.
-             *
-             * @param fun Function that should be called for each element of the given tuple(s).
-             * @param tup First tuple-like object, serves as first arguments to `fun` if given.
-             * @param tups Further tuple-like objects, serve as additional arguments to `fun` if given.
-             *
-             * Example code:
-             * @code
-             * struct sum {
-             *     double& value;
-             *     template < class A >
-             *     void operator()(A a, bool mask = true) const {
-             *         if (mask)
-             *             value += a;
-             *     }
-             * };
-             *
-             * // Unary function, like boost::fusion::for_each
-             * auto tup = std::tuple(1, 2, 3.5);
-             * double sum_value = 0.0;
-             * for_each(sum{sum_value}, tup);
-             * // sum_value == 6.5
-             *
-             * // Binary function
-             * auto tup2 = std::tuple(false, true, true);
-             * sum_value = 0.0;
-             * for_each(sum{sum_value}, tup, tup2);
-             * // sum_value == 5.5
-             * @endcode
-             */
-            template <class Fun, class Tup, class... Tups>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR void for_each(Fun && fun, Tup && tup, Tups && ...tups) {
-                transform_index(detail::for_each_adaptor_f<Fun>{wstd::forward<Fun>(fun)},
-                    wstd::forward<Tup>(tup),
-                    wstd::forward<Tups>(tups)...);
-            }
+        /**
+         * @brief Returns a functor that transforms each tuple element by a function.
+         *
+         * Composable version of `transform` that returns a functor which can be invoked with (one or multiple)
+         * tuples.
+         *
+         * @tparam Fun Functor type.
+         *
+         * @param fun Function that should be applied to all elements of the given tuple(s).
+         *
+         * Example code:
+         * @code
+         * struct add {
+         *     template < class A, class B >
+         *     auto operator()(A a, B b) -> decltype(a + b) {
+         *         return a + b;
+         *     }
+         * };
+         *
+         * // Composable usage with only a function argument
+         * auto addtuples = transform(add{});
+         * // addtuples takes now two tuples as arguments
+         * auto tup1 = std::tuple(1, 2, 3.5);
+         * auto tup2 = std::tuple(1.5, 3, 4.1);
+         * auto res = addtuples(tup1, tup2)
+         * // res == {2.5, 5, 7.6}
+         * @endcode
+         */
+        template <class Fun>
+        GT_FORCE_INLINE constexpr impl_::transform_f<Fun> transform(Fun fun) {
+            return {std::move(fun)};
+        }
 
-            /**
-             * @brief Returns a functor that calls a function for each element in a tuple.
-             *
-             * Composable version of `for_each` that returns a functor which can be invoked with (one or multiple)
-             * tuples.
-             *
-             * @tparam Fun Functor type.
-             *
-             * @param fun Function that should be called for each element of the given tuple(s).
-             *
-             * Example code:
-             * @code
-             * struct sum {
-             *     double& value;
-             *     template < class A >
-             *     void operator()(A a, bool mask = true) const {
-             *         if (mask)
-             *             value += a;
-             *     }
-             * };
-             *
-             * // Composable usage with only a function argument
-             * sum_value = 0.0;
-             * auto sumtuples = for_each(sum{sum_value});
-             * // sumtuples takes now two tuples as arguments
-             * auto tup1 = std::tuple(1, 2, 3.5);
-             * auto tup2 = std::tuple(false, true, true);
-             * auto res = sumtuples(tup1, tup2)
-             * // sum_value == 5.5
-             * @endcode
-             */
-            template <class Fun>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR detail::transform_index_f<detail::for_each_adaptor_f<Fun>>
-            for_each(Fun fun) {
-                return {{wstd::move(fun)}};
-            }
+        template <class Fun, class Tup, class... Tups>
+        GT_FORCE_INLINE constexpr auto transform_index(Fun &&fun, Tup &&tup, Tups &&...tups) {
+            return impl_::transform_index_f<Fun>{std::forward<Fun>(fun)}(
+                std::forward<Tup>(tup), std::forward<Tups>(tups)...);
+        }
 
-            template <class Fun, class Tup, class... Tups>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR void for_each_index(Fun && fun, Tup && tup, Tups && ...tups) {
-                transform_index(detail::for_each_index_adaptor_f<Fun>{wstd::forward<Fun>(fun)},
-                    wstd::forward<Tup>(tup),
-                    wstd::forward<Tups>(tups)...);
-            }
+        template <class Fun>
+        GT_FORCE_INLINE constexpr impl_::transform_index_f<Fun> transform_index(Fun fun) {
+            return {std::move(fun)};
+        }
 
-            template <class Fun>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR
-                detail::transform_index_f<detail::for_each_index_adaptor_f<Fun>>
-                for_each_index(Fun fun) {
-                return {{wstd::move(fun)}};
-            }
+        /**
+         * @brief Calls a function for each element in a tuple.
+         *
+         * Functions with more than one argument are supported by passing multiple tuples of the same size. If only
+         * a function but no tuples are passed, a composable functor is returned.
+         *
+         * @tparam Fun Functor type.
+         * @tparam Tup Optional tuple-like type.
+         * @tparam Tups Optional Tuple-like types.
+         *
+         * @param fun Function that should be called for each element of the given tuple(s).
+         * @param tup First tuple-like object, serves as first arguments to `fun` if given.
+         * @param tups Further tuple-like objects, serve as additional arguments to `fun` if given.
+         *
+         * Example code:
+         * @code
+         * struct sum {
+         *     double& value;
+         *     template < class A >
+         *     void operator()(A a, bool mask = true) const {
+         *         if (mask)
+         *             value += a;
+         *     }
+         * };
+         *
+         * // Unary function, like boost::fusion::for_each
+         * auto tup = std::tuple(1, 2, 3.5);
+         * double sum_value = 0.0;
+         * for_each(sum{sum_value}, tup);
+         * // sum_value == 6.5
+         *
+         * // Binary function
+         * auto tup2 = std::tuple(false, true, true);
+         * sum_value = 0.0;
+         * for_each(sum{sum_value}, tup, tup2);
+         * // sum_value == 5.5
+         * @endcode
+         */
+        template <class Fun, class Tup, class... Tups>
+        GT_FORCE_INLINE constexpr void for_each(Fun &&fun, Tup &&tup, Tups &&...tups) {
+            transform_index(impl_::for_each_adaptor_f<Fun>{std::forward<Fun>(fun)},
+                std::forward<Tup>(tup),
+                std::forward<Tups>(tups)...);
+        }
 
-            /**
-             * @brief Calls a function for each element in a cartesian product of the given tuples.
-             *
-             * If only a function but no tuples are passed, a composable functor is returned.
-             *
-             * @tparam Fun Functor type.
-             * @tparam Tup Optional tuple-like type.
-             * @tparam Tups Optional Tuple-like types.
-             *
-             * @param fun Function that should be called for each element in a cartesian product of the given tuples.
-             * @param tup First tuple-like object, serves as first arguments to `fun` if given.
-             * @param tups Further tuple-like objects, serve as additional arguments to `fun` if given.
-             *
-             * Example code:
-             * @code
-             * struct sum {
-             *     double& value;
-             *     template < class A, class B >
-             *     void operator()(A a, B b) const {
-             *         value += a * b;
-             *     }
-             * };
-             *
-             * // Binary function
-             * sum_value = 0.;
-             * for_each_in_cartesian_product(sum{sum_value}, std::tuple(1, 2, 3), std::tuple(1, 10));
-             * // sum_value == 66.
-             * @endcode
-             */
-            template <class Fun, class Tup, class... Tups>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR void for_each_in_cartesian_product(
-                Fun && fun, Tup && tup, Tups && ...tups) {
-                detail::for_each_in_cartesian_product_f<Fun>{wstd::forward<Fun>(fun)}(
-                    wstd::forward<Tup>(tup), wstd::forward<Tups>(tups)...);
-            }
+        /**
+         * @brief Returns a functor that calls a function for each element in a tuple.
+         *
+         * Composable version of `for_each` that returns a functor which can be invoked with (one or multiple)
+         * tuples.
+         *
+         * @tparam Fun Functor type.
+         *
+         * @param fun Function that should be called for each element of the given tuple(s).
+         *
+         * Example code:
+         * @code
+         * struct sum {
+         *     double& value;
+         *     template < class A >
+         *     void operator()(A a, bool mask = true) const {
+         *         if (mask)
+         *             value += a;
+         *     }
+         * };
+         *
+         * // Composable usage with only a function argument
+         * sum_value = 0.0;
+         * auto sumtuples = for_each(sum{sum_value});
+         * // sumtuples takes now two tuples as arguments
+         * auto tup1 = std::tuple(1, 2, 3.5);
+         * auto tup2 = std::tuple(false, true, true);
+         * auto res = sumtuples(tup1, tup2)
+         * // sum_value == 5.5
+         * @endcode
+         */
+        template <class Fun>
+        GT_FORCE_INLINE constexpr impl_::transform_index_f<impl_::for_each_adaptor_f<Fun>> for_each(Fun fun) {
+            return {{std::move(fun)}};
+        }
 
-            template <class Fun>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR detail::for_each_in_cartesian_product_f<Fun>
-            for_each_in_cartesian_product(Fun fun) {
-                return {wstd::move(fun)};
-            }
+        template <class Fun, class Tup, class... Tups>
+        GT_FORCE_INLINE constexpr void for_each_index(Fun &&fun, Tup &&tup, Tups &&...tups) {
+            transform_index(impl_::for_each_index_adaptor_f<Fun>{std::forward<Fun>(fun)},
+                std::forward<Tup>(tup),
+                std::forward<Tups>(tups)...);
+        }
 
-            /*
-             *  Concatenate several tuple-likes into one.
-             *  The type of result is deduced from the first argument
-             */
-            DEFINE_FUNCTOR_INSTANCE(concat, detail::concat_f<_impl::default_concat_result_maker_f>);
-
-            /*
-             * Variation of concat that allows to specify the resulting type.
-             *
-             * ResultMaker is a meta class with the following signature:
-             *   struct ResultMaker {
-             *     template <class FlattenTypesList,  ArgumentsOfConcatList>
-             *     using apply = ...;
-             *   }
-             */
-            template <class ResultMaker>
-            DEFINE_TEMPLATED_FUNCTOR_INSTANCE(concat_ex, detail::concat_f<ResultMaker>);
-
-            /**
-             * @brief Non-recursively flattens a tuple of tuples into a single tuple.
-             *
-             * Flattens only the first two levels of nested tuples into a single level. Does not flatten further levels
-             * of nesting.
-             *
-             * @tparam Tup Tuple-like type.
-             * @param tup Tuple-like object.
-             *
-             * Example:
-             * @code
-             * auto tup1 = std::tuple(1, 2);
-             * auto tup2 = std::tuple(3, 4, 5);
-             * auto flat = flatten(tup1, tup2);
-             * // flat == {1, 2, 3, 4, 5}
-             * @endcode
-             */
-            DEFINE_FUNCTOR_INSTANCE(flatten, detail::flatten_f<_impl::default_concat_result_maker_f>);
-
-            /*
-             * Extended variation of flatten. See concat_ex comments
-             */
-            template <class ResultMaker>
-            DEFINE_TEMPLATED_FUNCTOR_INSTANCE(flatten_ex, detail::flatten_f<ResultMaker>);
-
-            /**
-             * @brief Constructs an object from generator functors.
-             *
-             * `Generators` is a typelist of generator functors. Instances of those types are first default constructed,
-             * then invoked with `args` as arguments. The results of those calls are then passed to the constructor of
-             * `Res`.
-             *
-             * @tparam Generators A typelist of functors. All functor types must be default-constructible and callable
-             * with arguments of type `Args`.
-             * @tparam Res The type that should be constructed.
-             * @tparam Args Argument types for the generator functors.
-             *
-             * @param args Arguments that will be passed to the generator functors.
-             *
-             * Example:
-             * @code
-             * // Generators that extract some information from the given arguments (a single std::string in this
-             * example) struct ptr_extractor { const char* operator()(std::string const& s) const { return s.data();
-             *     }
-             * };
-             *
-             * struct size_extractor {
-             *     std::size_t operator()(std::string const& s) const {
-             *         return s.size();
-             *     }
-             * };
-             *
-             * // We want to generate a pair of a pointer and size,
-             * // that represents this string in a simple C-style manner
-             * std::string s = "Hello World!";
-             * // Target-type to construct
-             * using ptr_size_pair = std::pair< const char*, std::size_t >;
-             *
-             * // Typelist of generators
-             * using generators = std::tuple< ptr_extractor, size_extractor>;
-             *
-             * // Generate pair
-             * auto p = generate< generators, ptr_size_pair >(s);
-             * // p.first is now a pointer to the first character of s, p.second is the size of s
-             * @endcode
-             */
-            template <class Generators, class Res, class... Args>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR Res generate(Args && ...args) {
-                return detail::generate_f<Generators, Res>{}(wstd::forward<Args>(args)...);
-            }
+        template <class Fun>
+        GT_FORCE_INLINE constexpr impl_::transform_index_f<impl_::for_each_index_adaptor_f<Fun>> for_each_index(
+            Fun fun) {
+            return {{std::move(fun)}};
+        }
 
-            /**
-             * @brief Removes the first `N` elements from a tuple.
-             *
-             * @tparam N Number of elements to remove.
-             * @tparam Tup Tuple-like type.
-             *
-             * @param tup Tuple to remove first `N` elements from.
-             *
-             * Example:
-             * @code
-             * auto tup = std::tuple(1, 2, 3, 4);
-             * auto res = drop_front<2>(tup);
-             * // res == {3, 4}
-             * @endcode
-             */
-            template <size_t N>
-            DEFINE_TEMPLATED_FUNCTOR_INSTANCE(drop_front, detail::drop_front_f<N>);
-
-            /**
-             * @brief Appends elements to a tuple.
-             *
-             * @tparam Tup Tuple-like type.
-             * @tparam Args Argument types to append.
-             *
-             * @param tup Tuple-like object.
-             * @param args Arguments to append.
-             *
-             * Example:
-             * @code
-             * auto tup = std::tuple(1, 2);
-             * auto res = push_back(tup, 3, 4);
-             * // res = {1, 2, 3, 4}
-             * @endcode
-             */
-            DEFINE_FUNCTOR_INSTANCE(push_back, detail::push_back_f);
-
-            /**
-             * @brief Appends elements to a tuple from the front.
-             */
-            DEFINE_FUNCTOR_INSTANCE(push_front, detail::push_front_f);
-
-            /**
-             * @brief Removes elements to a tuple from the front.
-             */
-            DEFINE_FUNCTOR_INSTANCE(pop_front, detail::pop_front_f);
-
-            /**
-             * @brief Removes elements to a tuple from the back.
-             */
-            DEFINE_FUNCTOR_INSTANCE(pop_back, detail::pop_back_f);
-
-            /**
-             * @brief Left fold on tuple-like objects.
-             *
-             * This function accepts either two or three arguments. If three arguments are given, the second is the
-             * initial state and the third a tuple-like object to fold. If only two arguments are given, the second is a
-             * tuple-like object where the first element acts as the initial state.
-             *
-             * @tparam Fun Binary function type.
-             * @tparam Arg Either the initial state if three arguments are given or the tuple to fold if two arguments
-             * are given.
-             * @tparam Args The tuple type to fold (if three arguments are given).
-             *
-             * @param fun Binary function object.
-             * @param arg Either the initial state if three arguments are given or the tuple to fold if two arguments
-             * are given.
-             * @param args The tuple to fold (if three arguments are given).
-             *
-             * Example:
-             * @code
-             * auto tup = std::tuple(1, 2, 3);
-             *
-             * // Three arguments
-             * auto res = fold(std::plus<int>{}, 0, tup);
-             * // res == 6
-             *
-             * // Two arguments
-             * auto res2 = fold(std::plus<int>{}, tup);
-             * // res2 == 6
-             * @endcode
-             */
-            template <class Fun, class Arg, class... Args>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) fold(Fun && fun, Arg && arg, Args && ...args) {
-                return detail::fold_f<Fun>{wstd::forward<Fun>(fun)}(
-                    wstd::forward<Arg>(arg), wstd::forward<Args>(args)...);
-            }
+        /**
+         * @brief Calls a function for each element in a cartesian product of the given tuples.
+         *
+         * If only a function but no tuples are passed, a composable functor is returned.
+         *
+         * @tparam Fun Functor type.
+         * @tparam Tup Optional tuple-like type.
+         * @tparam Tups Optional Tuple-like types.
+         *
+         * @param fun Function that should be called for each element in a cartesian product of the given tuples.
+         * @param tup First tuple-like object, serves as first arguments to `fun` if given.
+         * @param tups Further tuple-like objects, serve as additional arguments to `fun` if given.
+         *
+         * Example code:
+         * @code
+         * struct sum {
+         *     double& value;
+         *     template < class A, class B >
+         *     void operator()(A a, B b) const {
+         *         value += a * b;
+         *     }
+         * };
+         *
+         * // Binary function
+         * sum_value = 0.;
+         * for_each_in_cartesian_product(sum{sum_value}, std::tuple(1, 2, 3), std::tuple(1, 10));
+         * // sum_value == 66.
+         * @endcode
+         */
+        template <class Fun, class Tup, class... Tups>
+        GT_FORCE_INLINE constexpr void for_each_in_cartesian_product(Fun &&fun, Tup &&tup, Tups &&...tups) {
+            impl_::for_each_in_cartesian_product_f<Fun>{std::forward<Fun>(fun)}(
+                std::forward<Tup>(tup), std::forward<Tups>(tups)...);
+        }
 
-            /**
-             * @brief Returns a functor that performs a left fold on tuple-like objects.
-             *
-             * The returned functor accepts either one or two arguments. If two arguments are given, the first is the
-             * initial state and the second a tuple-like object to fold. If only one argument is given, the argument
-             * must be a tuple-like object where the first element acts as the initial state.
-             *
-             * @tparam Fun Binary function type.
-             * @param fun Binary function object.
-             *
-             * Example:
-             * @code
-             * auto tup = std::tuple(1, 2, 3);
-             * auto folder = fold(std::plus<int>{});
-             *
-             * // Three arguments
-             * auto res = folder(0, tup);
-             * // res == 6
-             *
-             * // Two arguments
-             * auto res2 = folder(tup);
-             * // res2 == 6
-             * @endcode
-             */
-            template <class Fun>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR detail::fold_f<Fun> fold(Fun fun) {
-                return {wstd::move(fun)};
-            }
+        template <class Fun>
+        GT_FORCE_INLINE constexpr impl_::for_each_in_cartesian_product_f<Fun> for_each_in_cartesian_product(Fun fun) {
+            return {std::move(fun)};
+        }
 
-            template <class Pred, class... Tups>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR bool all_of(Pred && pred, Tups && ...tups) {
-                return detail::all_of_f<Pred>{wstd::forward<Pred>(pred)}(wstd::forward<Tups>(tups)...);
-            }
+        /*
+         *  Concatenate several tuple-likes into one.
+         *  The type of result is deduced from the first argument
+         */
+        DEFINE_FUNCTOR_INSTANCE(concat, impl_::concat_f<impl_::default_concat_result_maker_f>);
+
+        /*
+         * Variation of concat that allows to specify the resulting type.
+         *
+         * ResultMaker is a meta class with the following signature:
+         *   struct ResultMaker {
+         *     template <class FlattenTypesList,  ArgumentsOfConcatList>
+         *     using apply = ...;
+         *   }
+         */
+        template <class ResultMaker>
+        DEFINE_TEMPLATED_FUNCTOR_INSTANCE(concat_ex, impl_::concat_f<ResultMaker>);
+
+        /**
+         * @brief Non-recursively flattens a tuple of tuples into a single tuple.
+         *
+         * Flattens only the first two levels of nested tuples into a single level. Does not flatten further levels
+         * of nesting.
+         *
+         * @tparam Tup Tuple-like type.
+         * @param tup Tuple-like object.
+         *
+         * Example:
+         * @code
+         * auto tup1 = std::tuple(1, 2);
+         * auto tup2 = std::tuple(3, 4, 5);
+         * auto flat = flatten(tup1, tup2);
+         * // flat == {1, 2, 3, 4, 5}
+         * @endcode
+         */
+        DEFINE_FUNCTOR_INSTANCE(flatten, impl_::flatten_f<impl_::default_concat_result_maker_f>);
+
+        /*
+         * Extended variation of flatten. See concat_ex comments
+         */
+        template <class ResultMaker>
+        DEFINE_TEMPLATED_FUNCTOR_INSTANCE(flatten_ex, impl_::flatten_f<ResultMaker>);
+
+        /**
+         * @brief Constructs an object from generator functors.
+         *
+         * `Generators` is a typelist of generator functors. Instances of those types are first default constructed,
+         * then invoked with `args` as arguments. The results of those calls are then passed to the constructor of
+         * `Res`.
+         *
+         * @tparam Generators A typelist of functors. All functor types must be default-constructible and callable
+         * with arguments of type `Args`.
+         * @tparam Res The type that should be constructed.
+         * @tparam Args Argument types for the generator functors.
+         *
+         * @param args Arguments that will be passed to the generator functors.
+         *
+         * Example:
+         * @code
+         * // Generators that extract some information from the given arguments (a single std::string in this
+         * example) struct ptr_extractor { const char* operator()(std::string const& s) const { return s.data();
+         *     }
+         * };
+         *
+         * struct size_extractor {
+         *     std::size_t operator()(std::string const& s) const {
+         *         return s.size();
+         *     }
+         * };
+         *
+         * // We want to generate a pair of a pointer and size,
+         * // that represents this string in a simple C-style manner
+         * std::string s = "Hello World!";
+         * // Target-type to construct
+         * using ptr_size_pair = std::pair< const char*, std::size_t >;
+         *
+         * // Typelist of generators
+         * using generators = std::tuple< ptr_extractor, size_extractor>;
+         *
+         * // Generate pair
+         * auto p = generate< generators, ptr_size_pair >(s);
+         * // p.first is now a pointer to the first character of s, p.second is the size of s
+         * @endcode
+         */
+        template <class Generators, class Res, class... Args>
+        GT_FORCE_INLINE constexpr Res generate(Args &&...args) {
+            return impl_::generate_f<Generators, Res>{}(std::forward<Args>(args)...);
+        }
 
-            template <class Pred>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR detail::all_of_f<Pred> all_of(Pred pred) {
-                return {wstd::move(pred)};
-            }
+        /**
+         * @brief Removes the first `N` elements from a tuple.
+         *
+         * @tparam N Number of elements to remove.
+         * @tparam Tup Tuple-like type.
+         *
+         * @param tup Tuple to remove first `N` elements from.
+         *
+         * Example:
+         * @code
+         * auto tup = std::tuple(1, 2, 3, 4);
+         * auto res = drop_front<2>(tup);
+         * // res == {3, 4}
+         * @endcode
+         */
+        template <size_t N>
+        DEFINE_TEMPLATED_FUNCTOR_INSTANCE(drop_front, impl_::drop_front_f<N>);
+
+        /**
+         * @brief Appends elements to a tuple.
+         *
+         * @tparam Tup Tuple-like type.
+         * @tparam Args Argument types to append.
+         *
+         * @param tup Tuple-like object.
+         * @param args Arguments to append.
+         *
+         * Example:
+         * @code
+         * auto tup = std::tuple(1, 2);
+         * auto res = push_back(tup, 3, 4);
+         * // res = {1, 2, 3, 4}
+         * @endcode
+         */
+        DEFINE_FUNCTOR_INSTANCE(push_back, impl_::push_back_f);
+
+        /**
+         * @brief Appends elements to a tuple from the front.
+         */
+        DEFINE_FUNCTOR_INSTANCE(push_front, impl_::push_front_f);
+
+        /**
+         * @brief Removes elements to a tuple from the front.
+         */
+        DEFINE_FUNCTOR_INSTANCE(pop_front, impl_::pop_front_f);
+
+        /**
+         * @brief Removes elements to a tuple from the back.
+         */
+        DEFINE_FUNCTOR_INSTANCE(pop_back, impl_::pop_back_f);
+
+        /**
+         * @brief Left fold on tuple-like objects.
+         *
+         * This function accepts either two or three arguments. If three arguments are given, the second is the
+         * initial state and the third a tuple-like object to fold. If only two arguments are given, the second is a
+         * tuple-like object where the first element acts as the initial state.
+         *
+         * @tparam Fun Binary function type.
+         * @tparam Arg Either the initial state if three arguments are given or the tuple to fold if two arguments
+         * are given.
+         * @tparam Args The tuple type to fold (if three arguments are given).
+         *
+         * @param fun Binary function object.
+         * @param arg Either the initial state if three arguments are given or the tuple to fold if two arguments
+         * are given.
+         * @param args The tuple to fold (if three arguments are given).
+         *
+         * Example:
+         * @code
+         * auto tup = std::tuple(1, 2, 3);
+         *
+         * // Three arguments
+         * auto res = fold(std::plus<int>{}, 0, tup);
+         * // res == 6
+         *
+         * // Two arguments
+         * auto res2 = fold(std::plus<int>{}, tup);
+         * // res2 == 6
+         * @endcode
+         */
+        template <class Fun, class Arg, class... Args>
+        GT_FORCE_INLINE constexpr decltype(auto) fold(Fun &&fun, Arg &&arg, Args &&...args) {
+            return impl_::fold_f<Fun>{std::forward<Fun>(fun)}(std::forward<Arg>(arg), std::forward<Args>(args)...);
+        }
 
-            /**
-             * transposes a `tuple like` of `tuple like`.
-             *
-             * Ex.
-             *   transpose(array{array{1, 2, 3}, array{10, 20, 30}}) returns the same as
-             *   array{array{1, 10}, array{2, 20}, array{3, 30}};
-             */
-            DEFINE_FUNCTOR_INSTANCE(transpose, detail::transpose_f);
-
-            /**
-             * @brief Replaces reference types by value types in a tuple.
-             *
-             * @tparam Tup Tuple-like type.
-             * @param tup Tuple-like object, possibly containing references.
-             *
-             * Example:
-             * @code
-             * int foo = 3;
-             * std::tuple<int&> tup(foo);
-             * auto tupcopy = deep_copy(tup);
-             * ++foo;
-             * // tup == {4}, tupcopy == {3}
-             * @endcode
-             */
-            DEFINE_FUNCTOR_INSTANCE(deep_copy, detail::transform_f<gridtools::GT_TARGET_NAMESPACE_NAME::clone>);
-
-            namespace detail {
-                // in impl as it is not as powerful as std::invoke (does not support invoking member functions)
-                template <class Fun, class... Args>
-                GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) invoke_impl(Fun &&f, Args &&...args) {
-                    return wstd::forward<Fun>(f)(wstd::forward<Args>(args)...);
-                }
+        /**
+         * @brief Returns a functor that performs a left fold on tuple-like objects.
+         *
+         * The returned functor accepts either one or two arguments. If two arguments are given, the first is the
+         * initial state and the second a tuple-like object to fold. If only one argument is given, the argument
+         * must be a tuple-like object where the first element acts as the initial state.
+         *
+         * @tparam Fun Binary function type.
+         * @param fun Binary function object.
+         *
+         * Example:
+         * @code
+         * auto tup = std::tuple(1, 2, 3);
+         * auto folder = fold(std::plus<int>{});
+         *
+         * // Three arguments
+         * auto res = folder(0, tup);
+         * // res == 6
+         *
+         * // Two arguments
+         * auto res2 = folder(tup);
+         * // res2 == 6
+         * @endcode
+         */
+        template <class Fun>
+        GT_FORCE_INLINE constexpr impl_::fold_f<Fun> fold(Fun fun) {
+            return {std::move(fun)};
+        }
 
-                template <class Fun, class Tup, std::size_t... Is>
-                GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) apply_impl(
-                    Fun &&f, Tup &&tup, std::index_sequence<Is...>) {
-                    return invoke_impl(wstd::forward<Fun>(f), get<Is>(wstd::forward<Tup>(tup))...);
-                }
-            } // namespace detail
-
-            /**
-             * @brief Invoke callable f with tuple of arguments.
-             *
-             * @tparam Fun Functor type.
-             * @tparam Tup Tuple-like type.
-             * @param tup Tuple-like object containing arguments
-             * @param fun Function that should be called with the arguments in tup
-             *
-             * See std::apply (c++17), with the limitation that it only works for FunctionObjects (not for any Callable)
-             */
-            template <class Fun, class Tup>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR decltype(auto) apply(Fun && fun, Tup && tup) {
-                return detail::apply_impl(wstd::forward<Fun>(fun),
-                    wstd::forward<Tup>(tup),
-                    std::make_index_sequence<size<std::decay_t<Tup>>::value>{});
-            }
+        /**
+         * transposes a `tuple like` of `tuple like`.
+         *
+         * Ex.
+         *   transpose(array{array{1, 2, 3}, array{10, 20, 30}}) returns the same as
+         *   array{array{1, 10}, array{2, 20}, array{3, 30}};
+         */
+        DEFINE_FUNCTOR_INSTANCE(transpose, impl_::transpose_f);
+
+        /**
+         * @brief Replaces reference types by value types in a tuple.
+         *
+         * @tparam Tup Tuple-like type.
+         * @param tup Tuple-like object, possibly containing references.
+         *
+         * Example:
+         * @code
+         * int foo = 3;
+         * std::tuple<int&> tup(foo);
+         * auto tupcopy = deep_copy(tup);
+         * ++foo;
+         * // tup == {4}, tupcopy == {3}
+         * @endcode
+         */
+        DEFINE_FUNCTOR_INSTANCE(deep_copy, impl_::transform_f<clone>);
+
+        /**
+         * @brief Invoke callable f with tuple of arguments.
+         *
+         * @tparam Fun Functor type.
+         * @tparam Tup Tuple-like type.
+         * @param tup Tuple-like object containing arguments
+         * @param fun Function that should be called with the arguments in tup
+         *
+         * See std::apply (c++17), with the limitation that it only works for FunctionObjects (not for any Callable)
+         */
+        template <class Fun, class Tup>
+        GT_FORCE_INLINE constexpr decltype(auto) apply(Fun &&fun, Tup &&tup) {
+            return impl_::apply_impl(std::forward<Fun>(fun),
+                std::forward<Tup>(tup),
+                std::make_index_sequence<size<std::decay_t<Tup>>::value>{});
+        }
 
-            /// Generalization of `std::tie`
-            //
-            template <template <class...> class L, class... Ts>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR L<Ts &...> tie(Ts & ...elems) {
-                return L<Ts &...>{elems...};
-            }
+        /// Generalization of `std::tie`
+        //
+        template <template <class...> class L, class... Ts>
+        GT_FORCE_INLINE constexpr L<Ts &...> tie(Ts &...elems) {
+            return L<Ts &...>{elems...};
+        }
 
-            /**
-             *   The family of `convert_to` functions.
-             *
-             *   First template parameter could be either some tuple [`std::tuple`, `std::pair` or gridtools clones]
-             *   or some array [`std::array` or gridtools clone]
-             *   Array vaiants can take additional parameter -- the desired type of array. If it is not provided,
-             *   the type is deduced
-             *   Runtime parameter is any "tuple like" or none. Variants without runtime parameter return functors as
-             *   usual.
-             *
-             *   Examples of valid appllcations:
-             *
-             *   convert_to<std::tuple>(some_tuple_like);
-             *   convert_to<std::pair>()(some_tuple_like_with_two_elements);
-             *   convert_to<std::array>(some_tuple_like);
-             *   convert_to<gridtools::array, int>(some_tuple_like);
-             */
-            template <template <class...> class L
+        /**
+         *   The family of `convert_to` functions.
+         *
+         *   First template parameter could be either some tuple [`std::tuple`, `std::pair` or gridtools clones]
+         *   or some array [`std::array` or gridtools clone]
+         *   Array vaiants can take additional parameter -- the desired type of array. If it is not provided,
+         *   the type is deduced
+         *   Runtime parameter is any "tuple like" or none. Variants without runtime parameter return functors as
+         *   usual.
+         *
+         *   Examples of valid appllcations:
+         *
+         *   convert_to<std::tuple>(some_tuple_like);
+         *   convert_to<std::pair>()(some_tuple_like_with_two_elements);
+         *   convert_to<std::array>(some_tuple_like);
+         *   convert_to<gridtools::array, int>(some_tuple_like);
+         */
+        template <template <class...> class L
 #if defined(__NVCC__) && defined(__CUDACC_VER_MAJOR__) && \
     (__CUDACC_VER_MAJOR__ < 11 || __CUDACC_VER_MAJOR__ == 11 && __CUDACC_VER_MINOR__ <= 5)
-                // workaround against nvcc bug: https://godbolt.org/z/orrev1xnM
-                ,
-                int = 0,
-                class = std::void_t<L<int, int>>
+            // workaround against nvcc bug: https://godbolt.org/z/orrev1xnM
+            ,
+            int = 0,
+            class = std::void_t<L<int, int>>
 #endif
-                >
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR detail::convert_to_f<_impl::to_tuple_converter_helper<L>>
-            convert_to() {
-                return {};
-            }
+            >
+        GT_FORCE_INLINE constexpr impl_::convert_to_f<impl_::to_tuple_converter_helper<L>> convert_to() {
+            return {};
+        }
 
-            template <template <class...> class L
+        template <template <class...> class L
 #if defined(__NVCC__) && defined(__CUDACC_VER_MAJOR__) && \
     (__CUDACC_VER_MAJOR__ < 11 || __CUDACC_VER_MAJOR__ == 11 && __CUDACC_VER_MINOR__ <= 5)
 
-                // workaround against nvcc bug: https://godbolt.org/z/orrev1xnM
-                ,
-                int = 0,
-                class = std::void_t<L<int, int>>
+            // workaround against nvcc bug: https://godbolt.org/z/orrev1xnM
+            ,
+            int = 0,
+            class = std::void_t<L<int, int>>
 #endif
-                ,
-                class Tup>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR auto convert_to(Tup && tup) {
-                return detail::convert_to_f<_impl::to_tuple_converter_helper<L>>{}(wstd::forward<Tup>(tup));
-            }
+            ,
+            class Tup>
+        GT_FORCE_INLINE constexpr auto convert_to(Tup &&tup) {
+            return impl_::convert_to_f<impl_::to_tuple_converter_helper<L>>{}(std::forward<Tup>(tup));
+        }
 
-            template <template <class, size_t> class Arr, class D = void>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR detail::convert_to_f<_impl::to_array_converter_helper<Arr, D>>
-            convert_to() {
-                return {};
-            }
+        template <template <class, size_t> class Arr, class D = void>
+        GT_FORCE_INLINE constexpr impl_::convert_to_f<impl_::to_array_converter_helper<Arr, D>> convert_to() {
+            return {};
+        }
 
-            template <template <class, size_t> class Arr, class D = void, class Tup>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR auto convert_to(Tup && tup) {
-                return (detail::convert_to_f<_impl::to_array_converter_helper<Arr, D>>{}(wstd::forward<Tup>(tup)));
-            }
+        template <template <class, size_t> class Arr, class D = void, class Tup>
+        GT_FORCE_INLINE constexpr auto convert_to(Tup &&tup) {
+            return (impl_::convert_to_f<impl_::to_array_converter_helper<Arr, D>>{}(std::forward<Tup>(tup)));
+        }
 
-            DEFINE_FUNCTOR_INSTANCE(reverse, detail::reverse_f);
+        DEFINE_FUNCTOR_INSTANCE(reverse, impl_::reverse_f);
 
-            template <size_t I, class Val>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR detail::insert_f<I, Val> insert(Val && val) {
-                return {wstd::forward<Val>(val)};
-            }
+        template <size_t I, class Val>
+        GT_FORCE_INLINE constexpr impl_::insert_f<I, Val> insert(Val &&val) {
+            return {std::forward<Val>(val)};
+        }
 
-            template <size_t I, class Val, class Tup>
-            GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR auto insert(Val && val, Tup && tup) {
-                return insert<I>(wstd::forward<Val>(val))(wstd::forward<Tup>(tup));
-            }
+        template <size_t I, class Val, class Tup>
+        GT_FORCE_INLINE constexpr auto insert(Val &&val, Tup &&tup) {
+            return insert<I>(std::forward<Val>(val))(std::forward<Tup>(tup));
         }
     } // namespace tuple_util
+
+    using tuple_util::is_tuple_like;
+
+#ifdef __cpp_concepts
+    namespace concepts {
+        template <class T>
+        concept tuple_like = is_tuple_like<T>::value;
+
+        template <class T, class... Ts>
+        concept tuple_like_of = tuple_like<T> &&
+            std::is_same_v<meta::rename<meta::list, tuple_util::traits::to_types<T>>, meta::list<Ts...>>;
+    } // namespace concepts
+#endif
+
 } // namespace gridtools
 
 #undef DEFINE_TEMPLATED_FUNCTOR_INSTANCE
 #undef DEFINE_FUNCTOR_INSTANCE
 
-#endif // GT_TARGET_ITERATING
-
 /** @} */
 /** @} */
diff --git a/include/gridtools/common/utility.hpp b/include/gridtools/common/utility.hpp
deleted file mode 100644
index bc71c700f1..0000000000
--- a/include/gridtools/common/utility.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
- * GridTools
- *
- * Copyright (c) 2014-2021, ETH Zurich
- * All rights reserved.
- *
- * Please, refer to the LICENSE file in the root directory.
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-#pragma once
-
-#include <tuple>
-#include <type_traits>
-#include <utility>
-
-#include "defs.hpp"
-#include "host_device.hpp"
-
-namespace gridtools {
-    /**
-     *  `std::forward`/`std::move` versions that are guaranteed to be not constexpr. They are needed because
-     *  some compilers, especially nvcc have problems with functions that return references in constexpr functions,
-     *  if they are not used in constexpr context. As the `std` versions are constexpr, we must have separate
-     *  functions that are constexpr only if the compiler is known to not mess up with them.
-     */
-    namespace wstd {
-        template <class T>
-        GT_CONSTEXPR GT_HOST_DEVICE std::remove_reference_t<T> &&move(T &&obj) noexcept {
-            return static_cast<std::remove_reference_t<T> &&>(obj);
-        }
-        template <class T>
-        GT_CONSTEXPR GT_HOST_DEVICE T &&forward(std::remove_reference_t<T> &obj) noexcept {
-            return static_cast<T &&>(obj);
-        }
-        template <class T>
-        GT_CONSTEXPR GT_HOST_DEVICE T &&forward(std::remove_reference_t<T> &&obj) noexcept {
-            static_assert(
-                !std::is_lvalue_reference<T>::value, "Error: obj is instantiated with an lvalue reference type");
-            return static_cast<T &&>(obj);
-        }
-
-    } // namespace wstd
-} // namespace gridtools
diff --git a/include/gridtools/fn/backend/naive/fencil.hpp b/include/gridtools/fn/backend/naive/fencil.hpp
index d4fd4a23ef..dd7a144191 100644
--- a/include/gridtools/fn/backend/naive/fencil.hpp
+++ b/include/gridtools/fn/backend/naive/fencil.hpp
@@ -58,7 +58,7 @@ namespace gridtools::fn {
                 using tree_t = ast::popup_tmps<raw_tree_t>;
                 using specs_t = ast::flatten_tmps_tree<tree_t, input_types_t>;
                 using stages_t = meta::transform<make_stage_from_spec, specs_t>;
-                auto alloc = sid::make_allocator(&std::make_unique<char[]>);
+                auto alloc = sid::allocator(&std::make_unique<char[]>);
                 auto tmps = make_tmps<meta::pop_back<specs_t>>(alloc, domain);
                 fn_fencil(naive(), stages_t(), domain, tuple_util::push_back(tuple_util::concat(inputs, tmps), output));
             } else {
diff --git a/include/gridtools/fn/extents.hpp b/include/gridtools/fn/extents.hpp
index 1ec9359f0e..096a08b797 100644
--- a/include/gridtools/fn/extents.hpp
+++ b/include/gridtools/fn/extents.hpp
@@ -26,10 +26,10 @@
 #include <algorithm>
 #include <cstddef>
 #include <type_traits>
+#include <utility>
 
 #include "../common/int_vector.hpp"
 #include "../common/integral_constant.hpp"
-#include "../common/utility.hpp"
 #include "../meta.hpp"
 
 namespace gridtools {
@@ -61,12 +61,12 @@ namespace gridtools {
             static_assert(meta::is_set<meta::list<typename Ts::dim_t...>>::value);
             using keys_t = hymap::keys<typename Ts::dim_t...>;
 
-            static GT_CONSTEVAL GT_FUNCTION auto offsets() {
+            static GT_CONSTEVAL auto offsets() {
                 return int_vector::prune_zeros(typename keys_t::template values<typename Ts::lower_t...>());
             }
             using offsets_t = decltype(offsets());
 
-            static GT_CONSTEVAL GT_FUNCTION auto sizes() {
+            static GT_CONSTEVAL auto sizes() {
                 return int_vector::prune_zeros(typename keys_t::template values<typename Ts::size_t...>());
             }
             using sizes_t = decltype(sizes());
@@ -86,19 +86,19 @@ namespace gridtools {
 #endif
 
         template <class Extents, class Offsets>
-        decltype(auto) GT_FUNCTION GT_CONSTEXPR extend_offsets(Offsets &&src) {
+        GT_FORCE_INLINE constexpr decltype(auto) extend_offsets(Offsets &&src) {
             static_assert(is_extents<Extents>::value);
             static_assert(is_int_vector<std::decay_t<Offsets>>::value);
             using namespace int_vector::arithmetic;
-            return wstd::forward<Offsets>(src) + Extents::offsets();
+            return std::forward<Offsets>(src) + Extents::offsets();
         }
 
         template <class Extents, class Sizes>
-        decltype(auto) GT_FUNCTION GT_CONSTEXPR extend_sizes(Sizes &&sizes) {
+        GT_FORCE_INLINE constexpr decltype(auto) extend_sizes(Sizes &&sizes) {
             static_assert(is_extents<Extents>::value);
             static_assert(is_int_vector<std::decay_t<Sizes>>::value);
             using namespace int_vector::arithmetic;
-            return wstd::forward<Sizes>(sizes) + Extents::sizes();
+            return std::forward<Sizes>(sizes) + Extents::sizes();
         }
 
         namespace extent_impl_ {
diff --git a/include/gridtools/fn/scan.hpp b/include/gridtools/fn/scan.hpp
index c0f5bbe368..6ff2a3627b 100644
--- a/include/gridtools/fn/scan.hpp
+++ b/include/gridtools/fn/scan.hpp
@@ -11,16 +11,18 @@
 
 #include <cassert>
 #include <type_traits>
+#include <utility>
 
 #include "../common/functional.hpp"
 #include "../common/integral_constant.hpp"
 #include "../common/tuple.hpp"
+#include "../common/host_device.hpp"
 #include "../meta/is_instantiation_of.hpp"
 #include "../sid/concept.hpp"
 
 namespace gridtools::fn {
     namespace scan_impl_ {
-        template <class F, class Projector = host_device::identity>
+        template <class F, class Projector = gridtools::identity>
         struct scan_pass {
             F m_f;
             Projector m_p;
@@ -32,8 +34,8 @@ namespace gridtools::fn {
 
         template <bool IsBackward>
         struct base : std::bool_constant<IsBackward> {
-            static GT_FUNCTION constexpr auto prologue() { return tuple<>(); }
-            static GT_FUNCTION constexpr auto epilogue() { return tuple<>(); }
+            static GT_FORCE_INLINE constexpr auto prologue() { return tuple<>(); }
+            static GT_FORCE_INLINE constexpr auto epilogue() { return tuple<>(); }
         };
 
         using fwd = base<false>;
@@ -45,7 +47,8 @@ namespace gridtools::fn {
             GT_FUNCTION auto operator()(Seed seed, std::size_t size, Ptr ptr, Strides const &strides) const {
                 constexpr std::size_t prologue_size = std::tuple_size_v<decltype(ScanOrFold::prologue())>;
                 constexpr std::size_t epilogue_size = std::tuple_size_v<decltype(ScanOrFold::epilogue())>;
-                assert(size >= prologue_size + epilogue_size);
+                if constexpr (prologue_size + epilogue_size > 0)
+                    assert(size >= prologue_size + epilogue_size);
                 using step_t = integral_constant<int, ScanOrFold::value ? -1 : 1>;
                 auto const &v_stride = sid::get_stride<Vertical>(strides);
                 auto inc = [&] { sid::shift(ptr, v_stride, step_t()); };
@@ -53,25 +56,25 @@ namespace gridtools::fn {
                     if constexpr (is_scan_pass<decltype(pass)>()) {
                         // scan
                         auto res =
-                            pass.m_f(wstd::move(acc), MakeIterator()()(integral_constant<int, Ins>(), ptr, strides)...);
-                        *host_device::at_key<integral_constant<int, Out>>(ptr) = pass.m_p(res);
+                            pass.m_f(std::move(acc), MakeIterator()()(integral_constant<int, Ins>(), ptr, strides)...);
+                        *at_key<integral_constant<int, Out>>(ptr) = pass.m_p(res);
                         inc();
                         return res;
                     } else {
                         // fold
                         auto res =
-                            pass(wstd::move(acc), MakeIterator()()(integral_constant<int, Ins>(), ptr, strides)...);
+                            pass(std::move(acc), MakeIterator()()(integral_constant<int, Ins>(), ptr, strides)...);
                         inc();
                         return res;
                     }
                 };
                 if constexpr (ScanOrFold::value)
                     sid::shift(ptr, v_stride, size - 1);
-                auto acc = tuple_util::host_device::fold(next, wstd::move(seed), ScanOrFold::prologue());
+                auto acc = tuple_util::fold(next, std::move(seed), ScanOrFold::prologue());
                 std::size_t n = size - prologue_size - epilogue_size;
                 for (std::size_t i = 0; i < n; ++i)
-                    acc = next(wstd::move(acc), ScanOrFold::body());
-                return tuple_util::host_device::fold(next, wstd::move(acc), ScanOrFold::epilogue());
+                    acc = next(std::move(acc), ScanOrFold::body());
+                return tuple_util::fold(next, std::move(acc), ScanOrFold::epilogue());
             }
         };
 
@@ -79,9 +82,8 @@ namespace gridtools::fn {
         struct merged_column_stage {
             template <class Seed, class Ptr, class Strides>
             GT_FUNCTION auto operator()(Seed seed, std::size_t size, Ptr ptr, Strides const &strides) const {
-                return tuple_util::host_device::fold(
-                    [&](auto acc, auto stage) { return stage(wstd::move(acc), size, ptr, strides); },
-                    wstd::move(seed),
+                return tuple_util::fold([&](auto acc, auto stage) { return stage(std::move(acc), size, ptr, strides); },
+                    std::move(seed),
                     tuple(ColumnStages()...));
             }
         };
diff --git a/include/gridtools/gcl/high_level/wrap_argument.hpp b/include/gridtools/gcl/high_level/wrap_argument.hpp
index 15bf598904..9ac757f08a 100644
--- a/include/gridtools/gcl/high_level/wrap_argument.hpp
+++ b/include/gridtools/gcl/high_level/wrap_argument.hpp
@@ -12,12 +12,36 @@
 struct wrap_argument {
     int data[27];
 
-    GT_FUNCTION wrap_argument(int const *ptr) {
-        for (int i = 0; i < 27; ++i)
-            data[i] = ptr[i];
-    }
+    constexpr wrap_argument(int const *ptr)
+        : data{ptr[0],
+              ptr[1],
+              ptr[2],
+              ptr[3],
+              ptr[4],
+              ptr[5],
+              ptr[6],
+              ptr[7],
+              ptr[8],
+              ptr[9],
+              ptr[10],
+              ptr[11],
+              ptr[12],
+              ptr[13],
+              ptr[14],
+              ptr[15],
+              ptr[16],
+              ptr[17],
+              ptr[18],
+              ptr[19],
+              ptr[20],
+              ptr[21],
+              ptr[22],
+              ptr[23],
+              ptr[24],
+              ptr[25],
+              ptr[26]} {}
 
-    GT_FUNCTION int &operator[](int i) { return data[i]; }
+    constexpr int &operator[](int i) { return data[i]; }
 
-    GT_FUNCTION int const &operator[](int i) const { return data[i]; }
+    constexpr int const &operator[](int i) const { return data[i]; }
 };
diff --git a/include/gridtools/gcl/low_level/proc_grids_3D.hpp b/include/gridtools/gcl/low_level/proc_grids_3D.hpp
index bb06fbb5c6..9f01ac32d0 100644
--- a/include/gridtools/gcl/low_level/proc_grids_3D.hpp
+++ b/include/gridtools/gcl/low_level/proc_grids_3D.hpp
@@ -210,11 +210,9 @@ namespace gridtools {
                 return res;
             }
 
-            GT_FUNCTION
-            array<int, ndims> const &coordinates() const { return m_coordinates; }
+            constexpr array<int, ndims> const &coordinates() const { return m_coordinates; }
 
-            GT_FUNCTION
-            array<int, ndims> const &dimensions() const { return m_dimensions; }
+            constexpr array<int, ndims> const &dimensions() const { return m_dimensions; }
 
             /** Returns the process ID of the process with absolute coordinates specified by the input array of
                coordinates
diff --git a/include/gridtools/layout_transformation/gpu.hpp b/include/gridtools/layout_transformation/gpu.hpp
index 95b3df0b35..c647d7fb5f 100644
--- a/include/gridtools/layout_transformation/gpu.hpp
+++ b/include/gridtools/layout_transformation/gpu.hpp
@@ -38,7 +38,7 @@ namespace gridtools {
                 for (auto &&i = m_hyper_cube.begin(); i != e; ++i) {
                     T *d = dst;
                     T const *__restrict__ s = src;
-                    tuple_util::device::for_each(
+                    tuple_util::for_each(
                         [&](auto i, auto d_stride, auto s_stride) {
                             d += i * d_stride;
                             s += i * s_stride;
@@ -77,19 +77,19 @@ namespace gridtools {
             OuterLoop outer_loop) {
 
             uint_t i = blockIdx.x * block_size_1d_t::value + threadIdx.x;
-            if (i >= tuple_util::device::get<0>(dims))
+            if (i >= tuple_util::get<0>(dims))
                 return;
             uint_t j = blockIdx.y * block_size_1d_t::value + threadIdx.y;
-            if (j >= tuple_util::device::get<1>(dims))
+            if (j >= tuple_util::get<1>(dims))
                 return;
             uint_t k = blockIdx.z * block_size_1d_t::value + threadIdx.z;
-            if (k >= tuple_util::device::get<2>(dims))
+            if (k >= tuple_util::get<2>(dims))
                 return;
 
-            outer_loop(dst + i * tuple_util::device::get<0>(dst_strides) + j * tuple_util::device::get<1>(dst_strides) +
-                           k * tuple_util::device::get<2>(dst_strides),
-                src + i * tuple_util::device::get<0>(src_strides) + j * tuple_util::device::get<1>(src_strides) +
-                    k * tuple_util::device::get<2>(src_strides));
+            outer_loop(dst + i * tuple_util::get<0>(dst_strides) + j * tuple_util::get<1>(dst_strides) +
+                           k * tuple_util::get<2>(dst_strides),
+                src + i * tuple_util::get<0>(src_strides) + j * tuple_util::get<1>(src_strides) +
+                    k * tuple_util::get<2>(src_strides));
         }
 
         template <class T, class Dims, class DstStrides, class SrcSrides>
diff --git a/include/gridtools/meta/debug.hpp b/include/gridtools/meta/debug.hpp
index 16d19eb88b..a3eb313d08 100644
--- a/include/gridtools/meta/debug.hpp
+++ b/include/gridtools/meta/debug.hpp
@@ -18,7 +18,7 @@
  *  Works also with parameter packs. I.e you can both `GT_META_PRINT_TYPE(SomeType)` and
  * `GT_META_PRINT_TYPE(SomeTypes...)`
  */
-#define GT_META_PRINT_TYPE(x) static_assert(::gridtools::meta::debug::type<BOOST_PP_REMOVE_PARENS(x)>::_, "")
+#define GT_META_PRINT_TYPE(x) static_assert(::gridtools::meta::debug::type<BOOST_PP_REMOVE_PARENS(x)>::_)
 
 /**
  *  This macro expands to the code snippet that generates a compiler error that refers to the compile time value(s) of
@@ -30,8 +30,7 @@
 #define GT_META_PRINT_VALUE(x)                                                                                \
     static_assert(                                                                                            \
         ::gridtools::meta::debug::value<decltype(::gridtools::meta::debug::first(BOOST_PP_REMOVE_PARENS(x))), \
-            BOOST_PP_REMOVE_PARENS(x)>::_,                                                                    \
-        "")
+            BOOST_PP_REMOVE_PARENS(x)>::_)
 
 namespace gridtools {
     namespace meta {
diff --git a/include/gridtools/reduction/cpu.hpp b/include/gridtools/reduction/cpu.hpp
index 05a1bb0275..b27c318d46 100644
--- a/include/gridtools/reduction/cpu.hpp
+++ b/include/gridtools/reduction/cpu.hpp
@@ -53,7 +53,7 @@ namespace gridtools {
 
         template <class T, std::enable_if_t<std::is_integral<T>::value, int> = 0>
         T reduction_reduce(cpu, T res, bitwise_xor, T const *buff, size_t n) {
-#pragma omp parallel for reduction (^ : res)
+#pragma omp parallel for reduction(^ : res)
             for (size_t i = 0; i < n; i++)
                 res ^= buff[i];
             return res;
@@ -61,10 +61,10 @@ namespace gridtools {
 
         template <class F, class T>
         T reduction_reduce(cpu, T res, F, T const *buff, size_t n) {
-            static_assert(std::is_empty<F>(), "OpenMP reduction supports only stateless functors.");
+            static_assert(std::is_empty_v<F>, "OpenMP reduction supports only stateless functors.");
             static_assert(
-                std::is_default_constructible<F>(), "OpenMP reduction supports only default constructible functors.");
-#pragma omp declare reduction(gridtools_generic : T : omp_out = F()(omp_out, omp_in)) initializer(omp_priv = omp_orig)
+                std::is_default_constructible_v<F>, "OpenMP reduction supports only default constructible functors.");
+#pragma omp declare reduction(gridtools_generic:T : omp_out = F()(omp_out, omp_in)) initializer(omp_priv = omp_orig)
 #pragma omp parallel for reduction(gridtools_generic : res)
             for (size_t i = 0; i < n; i++)
                 res = F()(res, buff[i]);
diff --git a/include/gridtools/reduction/frontend.hpp b/include/gridtools/reduction/frontend.hpp
index e9037971fc..d0889400d8 100644
--- a/include/gridtools/reduction/frontend.hpp
+++ b/include/gridtools/reduction/frontend.hpp
@@ -32,6 +32,11 @@ namespace gridtools {
             template <class Sizes>
             using zeros_type = decltype(zeros(std::declval<Sizes const &>()));
 
+            template <class StorageTraits>
+            struct alloc_fun {
+                auto operator()(size_t size) const { return storage::traits::allocate<StorageTraits, char>(size); }
+            };
+
             template <class Backend, class T, class Origin, class Strides, class StridesKind, class Sizes>
             struct reducible {
                 std::shared_ptr<void> m_alloc;
@@ -58,8 +63,7 @@ namespace gridtools {
 
             template <class Backend, class StorageTraits, class Id = void, class T, class... Dims>
             auto make_reducible(T const &neutral_value, Dims... dims) {
-                auto alloc = sid::host_device::make_cached_allocator(
-                    [](size_t size) { return storage::traits::allocate<StorageTraits, char>(size); });
+                sid::cached_allocator<alloc_fun<StorageTraits>> alloc;
                 auto lengths = tuple(dims...);
                 auto info = storage::traits::make_info<StorageTraits, T>(lengths);
                 auto strides = info.native_strides();
diff --git a/include/gridtools/reduction/functions.hpp b/include/gridtools/reduction/functions.hpp
index a2c958949c..fd171e1d3f 100644
--- a/include/gridtools/reduction/functions.hpp
+++ b/include/gridtools/reduction/functions.hpp
@@ -15,43 +15,43 @@ namespace gridtools {
     namespace reduction {
         struct plus {
             template <class T>
-            GT_FUNCTION auto operator()(T const &x, T const &y) const {
+            GT_FORCE_INLINE constexpr auto operator()(T const &x, T const &y) const {
                 return x + y;
             }
         };
         struct mul {
             template <class T>
-            GT_FUNCTION auto operator()(T const &x, T const &y) const {
+            GT_FORCE_INLINE constexpr auto operator()(T const &x, T const &y) const {
                 return x * y;
             }
         };
         struct min {
             template <class T>
-            GT_FUNCTION auto operator()(T const &x, T const &y) const {
+            GT_FORCE_INLINE constexpr auto operator()(T const &x, T const &y) const {
                 return x < y ? x : y;
             }
         };
         struct max {
             template <class T>
-            GT_FUNCTION auto operator()(T const &x, T const &y) const {
+            GT_FORCE_INLINE constexpr auto operator()(T const &x, T const &y) const {
                 return x > y ? x : y;
             }
         };
         struct bitwise_and {
             template <class T>
-            GT_FUNCTION auto operator()(T const &x, T const &y) const {
+            GT_FORCE_INLINE constexpr auto operator()(T const &x, T const &y) const {
                 return x & y;
             }
         };
         struct bitwise_or {
             template <class T>
-            GT_FUNCTION auto operator()(T const &x, T const &y) const {
+            GT_FORCE_INLINE constexpr auto operator()(T const &x, T const &y) const {
                 return x | y;
             }
         };
         struct bitwise_xor {
             template <class T>
-            GT_FUNCTION auto operator()(T const &x, T const &y) const {
+            GT_FORCE_INLINE constexpr auto operator()(T const &x, T const &y) const {
                 return x ^ y;
             }
         };
diff --git a/include/gridtools/sid/allocator.hpp b/include/gridtools/sid/allocator.hpp
index e20bb63ec2..f8f8803c2f 100644
--- a/include/gridtools/sid/allocator.hpp
+++ b/include/gridtools/sid/allocator.hpp
@@ -7,10 +7,7 @@
  * Please, refer to the LICENSE file in the root directory.
  * SPDX-License-Identifier: BSD-3-Clause
  */
-#ifndef GT_TARGET_ITERATING
-// DON'T USE #pragma once HERE!!!
-#ifndef GT_SID_ALLOCATOR_HPP_
-#define GT_SID_ALLOCATOR_HPP_
+#pragma once
 
 #include <map>
 #include <memory>
@@ -47,15 +44,13 @@
  *
  *  Both are templated with the functor that takes the size in bytes and returns `std::unique_ptr`
  *
- *  There are also correspondent generators: `make_allocator` and `make_cached_allocator`.
- *
  *  Semantics:
  *    - `allocator` keeps the resources that are allocated and releases them in dtor.
  *    - `cached_allocator` keeps resources during its lifetime. On dtor it stashes the resources in the internal static
  *      storage. The newly created instances of `cached_allocator` will attempt to reuse the stashed resources.
  *
  *  To make the simplest possible allocator one can do:
- *    `auto alloc = make_allocator(&std::make_unique<char[]>);`
+ *    `auto alloc = allocator(&std::make_unique<char[]>);`
  *
  */
 
@@ -96,57 +91,35 @@ namespace gridtools {
                 }
             };
         } // namespace allocator_impl_
-    }     // namespace sid
-} // namespace gridtools
 
-#define GT_FILENAME <gridtools/sid/allocator.hpp>
-#include GT_ITERATE_ON_TARGETS()
-#undef GT_FILENAME
+        template <class Impl, class Ptr = decltype(std::declval<Impl const>()(size_t{}))>
+        class allocator;
 
-#endif
-#else
+        template <class Impl, class T, class Deleter>
+        class allocator<Impl, std::unique_ptr<T, Deleter>> {
+            Impl m_impl;
+            std::vector<std::unique_ptr<T, Deleter>> m_buffers;
 
-namespace gridtools {
-    namespace sid {
-        GT_TARGET_NAMESPACE {
-            template <class Impl, class Ptr = decltype(std::declval<Impl const>()(size_t{}))>
-            class allocator;
+          public:
+            allocator() = default;
+            allocator(Impl impl) : m_impl(std::move(impl)) {}
 
-            template <class Impl, class T, class Deleter>
-            class allocator<Impl, std::unique_ptr<T, Deleter>> {
-                Impl m_impl;
-                std::vector<std::unique_ptr<T, Deleter>> m_buffers;
-
-              public:
-                allocator() = default;
-                allocator(Impl impl) : m_impl(std::move(impl)) {}
-
-                template <class LazyT>
-                friend auto allocate(allocator &self, LazyT, size_t size) {
-                    using type = typename LazyT::type;
-                    auto ptr = self.m_impl(sizeof(type) * size);
-                    self.m_buffers.push_back(self.m_impl(sizeof(type) * size));
-                    return make_simple_ptr_holder(reinterpret_cast<type *>(self.m_buffers.back().get()));
-                }
-            };
-
-            template <class Impl>
-            struct cached_allocator : allocator<allocator_impl_::cached_proxy_f<Impl>> {
-                cached_allocator() = default;
-                cached_allocator(Impl impl) : cached_allocator::allocator({std::move(impl)}) {}
-            };
-
-            template <class Impl>
-            allocator<Impl> make_allocator(Impl impl) {
-                return {std::move(impl)};
+            template <class LazyT>
+            friend auto allocate(allocator &self, LazyT, size_t size) {
+                using type = typename LazyT::type;
+                auto ptr = self.m_impl(sizeof(type) * size);
+                self.m_buffers.push_back(self.m_impl(sizeof(type) * size));
+                return simple_ptr_holder(reinterpret_cast<type *>(self.m_buffers.back().get()));
             }
+        };
 
-            template <class Impl>
-            cached_allocator<Impl> make_cached_allocator(Impl impl) {
-                return {std::move(impl)};
-            }
-        }
+        template <class Impl>
+        allocator(Impl) -> allocator<Impl>;
+
+        template <class Impl>
+        struct cached_allocator : allocator<allocator_impl_::cached_proxy_f<Impl>> {
+            cached_allocator() = default;
+            cached_allocator(Impl impl) : cached_allocator::allocator({std::move(impl)}) {}
+        };
     } // namespace sid
 } // namespace gridtools
-
-#endif
diff --git a/include/gridtools/sid/as_const.hpp b/include/gridtools/sid/as_const.hpp
index 3a0a292127..9e1632e6f3 100644
--- a/include/gridtools/sid/as_const.hpp
+++ b/include/gridtools/sid/as_const.hpp
@@ -26,11 +26,11 @@ namespace gridtools {
                 struct const_ptr_holder {
                     ptr_holder_type<Sid> m_impl;
 
-                    GT_CONSTEXPR GT_FUNCTION std::add_const_t<sid::element_type<Sid>> *operator()() const {
+                    GT_FORCE_INLINE constexpr std::add_const_t<sid::element_type<Sid>> *operator()() const {
                         return m_impl();
                     }
 
-                    friend GT_CONSTEXPR GT_FUNCTION const_ptr_holder operator+(
+                    friend GT_FORCE_INLINE constexpr const_ptr_holder operator+(
                         const_ptr_holder const &obj, ptr_diff_type<Sid> offset) {
                         return {obj.m_impl + offset};
                     }
diff --git a/include/gridtools/sid/block.hpp b/include/gridtools/sid/block.hpp
index a60f8e55a4..c61e90e1a7 100644
--- a/include/gridtools/sid/block.hpp
+++ b/include/gridtools/sid/block.hpp
@@ -32,10 +32,9 @@ namespace gridtools {
             };
 
             template <class Ptr, class Stride, class BlockSize, class Offset>
-            GT_FUNCTION decltype(auto) sid_shift(
+            GT_FORCE_INLINE constexpr decltype(auto) sid_shift(
                 Ptr &ptr, blocked_stride<Stride, BlockSize> const &stride, Offset const &offset) {
-                return shift(
-                    ptr, tuple_util::host_device::get<0>(stride), tuple_util::host_device::get<1>(stride) * offset);
+                return shift(ptr, tuple_util::get<0>(stride), tuple_util::get<1>(stride) * offset);
             }
 
             template <class Stride, class BlockSize, std::enable_if_t<!std::is_integral<Stride>::value, int> = 0>
diff --git a/include/gridtools/sid/composite.hpp b/include/gridtools/sid/composite.hpp
index da95d961b7..b87969a4c3 100644
--- a/include/gridtools/sid/composite.hpp
+++ b/include/gridtools/sid/composite.hpp
@@ -10,9 +10,11 @@
 #pragma once
 
 #include <cassert>
+#include <functional>
 #include <type_traits>
 #include <utility>
 
+#include "../common/compose.hpp"
 #include "../common/defs.hpp"
 #include "../common/enable_maker.hpp"
 #include "../common/for_each.hpp"
@@ -20,7 +22,6 @@
 #include "../common/hymap.hpp"
 #include "../common/tuple.hpp"
 #include "../common/tuple_util.hpp"
-#include "../common/utility.hpp"
 #include "../meta.hpp"
 #include "concept.hpp"
 #include "unknown_kind.hpp"
@@ -111,12 +112,13 @@ namespace gridtools {
                 };
 
                 template <class ObjTup, class StrideTup, class Offset>
-                GT_FUNCTION void composite_shift_impl(ObjTup &obj_tup, StrideTup &&stride_tup, Offset offset) {
-                    tuple_util::host_device::for_each(
+                GT_FORCE_INLINE constexpr void composite_shift_impl(
+                    ObjTup &obj_tup, StrideTup &&stride_tup, Offset offset) {
+                    tuple_util::for_each(
                         [offset](auto &obj, auto &&stride)
-                            GT_FORCE_INLINE_LAMBDA { shift(obj, wstd::forward<decltype(stride)>(stride), offset); },
+                            GT_FORCE_INLINE_LAMBDA { shift(obj, std::forward<decltype(stride)>(stride), offset); },
                         obj_tup,
-                        wstd::forward<StrideTup>(stride_tup));
+                        std::forward<StrideTup>(stride_tup));
                 }
 
                 template <class Key, class Strides, class I = meta::st_position<get_keys<Strides>, Key>>
@@ -137,13 +139,6 @@ namespace gridtools {
                 };
 
                 struct ctor_tag {};
-
-                struct sum {
-                    template <class Lhs, class Rhs>
-                    GT_FUNCTION GT_CONSTEXPR auto operator()(Lhs &&lhs, Rhs &&rhs) const {
-                        return wstd::forward<Lhs>(lhs) + wstd::forward<Rhs>(rhs);
-                    }
-                };
             } // namespace impl_
 
             /**
@@ -192,12 +187,13 @@ namespace gridtools {
 
                 template <class... Args,
                     std::enable_if_t<std::conjunction_v<std::is_constructible<Ptrs, Args>...>, int> = 0>
-                constexpr GT_FUNCTION composite_ptr(Args &&...args) noexcept : m_vals{wstd::forward<Args>(args)...} {}
+                GT_FORCE_INLINE constexpr composite_ptr(Args &&...args) noexcept
+                    : m_vals{std::forward<Args>(args)...} {}
 
-                constexpr GT_FUNCTION composite_ptr(Ptrs const &...args) noexcept : m_vals(args...) {}
+                GT_FORCE_INLINE constexpr composite_ptr(Ptrs const &...args) noexcept : m_vals(args...) {}
 
-                constexpr GT_FUNCTION composite_ptr(tuple<Ptrs...> &&args) noexcept : m_vals(wstd::move(args)) {}
-                constexpr GT_FUNCTION composite_ptr(tuple<Ptrs...> const &args) noexcept : m_vals(args) {}
+                GT_FORCE_INLINE constexpr composite_ptr(tuple<Ptrs...> &&args) noexcept : m_vals(std::move(args)) {}
+                GT_FORCE_INLINE constexpr composite_ptr(tuple<Ptrs...> const &args) noexcept : m_vals(args) {}
 
                 composite_ptr() = default;
                 composite_ptr(composite_ptr const &) = default;
@@ -207,14 +203,14 @@ namespace gridtools {
 
                 GT_TUPLE_UTIL_FORWARD_GETTER_TO_MEMBER(composite_ptr, m_vals);
 
-                GT_CONSTEXPR GT_FUNCTION decltype(auto) operator*() const {
-                    return tuple_util::host_device::convert_to<hymap::keys<Keys...>::template values>(
-                        tuple_util::host_device::transform([](auto const &ptr)
+                GT_FORCE_INLINE constexpr decltype(auto) operator*() const {
+                    return tuple_util::convert_to<hymap::keys<Keys...>::template values>(
+                        tuple_util::transform([](auto const &ptr)
 // Workaround for GCC 9 bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=90333
 // The failure is observed with 9.3 as well even though they say it was already fixed there.
 // gcc 10.1, 10.2 fails here as well. Disabling for all gcc 9 and 10 versions...
 #if defined(__clang__) || !defined(__GNUC__) || (__GNUC__ != 9 && __GNUC__ != 10)
-                                                               GT_FORCE_INLINE_LAMBDA
+                                                  GT_FORCE_INLINE_LAMBDA
 #endif
                             -> decltype(auto) { return *ptr; },
                             m_vals));
@@ -223,6 +219,11 @@ namespace gridtools {
                 friend keys hymap_get_keys(composite_ptr const &) { return {}; }
             };
 
+            template <class Fun, class Tup, std::size_t... Is>
+            GT_FORCE_INLINE constexpr decltype(auto) my_apply_impl(Fun &&f, Tup &&tup, std::index_sequence<Is...>) {
+                return std::forward<Fun>(f)(get<Is>(std::forward<Tup>(tup))...);
+            }
+
             template <class... Keys>
             template <class... PtrHolders>
             struct keys<Keys...>::composite_ptr_holder {
@@ -232,14 +233,15 @@ namespace gridtools {
 
                 template <class... Args,
                     std::enable_if_t<std::conjunction_v<std::is_constructible<PtrHolders, Args>...>, int> = 0>
-                constexpr GT_FUNCTION composite_ptr_holder(Args &&...args) noexcept
-                    : m_vals{wstd::forward<Args>(args)...} {}
+                GT_FORCE_INLINE constexpr composite_ptr_holder(Args &&...args) noexcept
+                    : m_vals{std::forward<Args>(args)...} {}
 
-                constexpr GT_FUNCTION composite_ptr_holder(PtrHolders const &...args) noexcept : m_vals(args...) {}
+                GT_FORCE_INLINE constexpr composite_ptr_holder(PtrHolders const &...args) noexcept : m_vals(args...) {}
 
-                constexpr GT_FUNCTION composite_ptr_holder(tuple<PtrHolders...> &&args) noexcept
-                    : m_vals(wstd::move(args)) {}
-                constexpr GT_FUNCTION composite_ptr_holder(tuple<PtrHolders...> const &args) noexcept : m_vals(args) {}
+                GT_FORCE_INLINE constexpr composite_ptr_holder(tuple<PtrHolders...> &&args) noexcept
+                    : m_vals(std::move(args)) {}
+                GT_FORCE_INLINE constexpr composite_ptr_holder(tuple<PtrHolders...> const &args) noexcept
+                    : m_vals(args) {}
 
                 composite_ptr_holder() = default;
                 composite_ptr_holder(composite_ptr_holder const &) = default;
@@ -249,9 +251,12 @@ namespace gridtools {
 
                 GT_TUPLE_UTIL_FORWARD_GETTER_TO_MEMBER(composite_ptr_holder, m_vals);
 
-                GT_CONSTEXPR GT_FUNCTION auto operator()() const {
-                    return tuple_util::host_device::convert_to<composite_ptr>(tuple_util::host_device::transform(
-                        [](auto const &obj) GT_FORCE_INLINE_LAMBDA { return obj(); }, m_vals));
+                GT_FORCE_INLINE constexpr auto operator()() const {
+                    return tuple_util::apply(
+                        [](auto const &...holders) {
+                            return composite_ptr<std::decay_t<decltype(holders())>...>(holders()...);
+                        },
+                        m_vals);
                 }
 
                 friend keys hymap_get_keys(composite_ptr_holder const &) { return {}; }
@@ -292,8 +297,8 @@ namespace gridtools {
                     class T,
                     class Item = meta::mp_find<Map, std::integral_constant<size_t, I>>,
                     class Pos = meta::second<Item>>
-                static GT_CONSTEXPR GT_FUNCTION decltype(auto) get(T &&obj) {
-                    return tuple_util::host_device::get<Pos::value>(wstd::forward<T>(obj).m_vals);
+                static GT_FORCE_INLINE constexpr decltype(auto) get(T &&obj) {
+                    return tuple_util::get<Pos::value>(std::forward<T>(obj).m_vals);
                 }
 
                 template <class... Ts>
@@ -308,7 +313,7 @@ namespace gridtools {
                     vals_t m_vals;
 
                     template <template <class...> class L, class... Args>
-                    composite_entity(impl_::ctor_tag, L<Args...> &&tup) noexcept
+                    GT_FORCE_INLINE constexpr composite_entity(impl_::ctor_tag, L<Args...> &&tup) noexcept
                         : m_vals{tuple_util::generate<generators_t, vals_t>(std::move(tup))} {
                         static_assert(sizeof...(Args) == sizeof...(Keys), GT_INTERNAL_ERROR);
                     }
@@ -322,48 +327,49 @@ namespace gridtools {
                     friend compressed tuple_getter(composite_entity const &) { return {}; }
 
                     template <class... Ptrs>
-                    friend GT_CONSTEXPR GT_FUNCTION composite_ptr<Ptrs...> operator+(
+                    friend GT_FORCE_INLINE constexpr composite_ptr<Ptrs...> operator+(
                         composite_ptr<Ptrs...> const &lhs, composite_entity const &rhs) {
-                        return tuple_util::host_device::transform(impl_::sum(), lhs, rhs);
+                        return tuple_util::transform(std::plus<>(), lhs, rhs);
                     }
 
                     template <class... PtrHolders>
-                    friend composite_ptr_holder<PtrHolders...> operator+(
+                    friend GT_FORCE_INLINE constexpr composite_ptr_holder<PtrHolders...> operator+(
                         composite_ptr_holder<PtrHolders...> const &lhs, composite_entity const &rhs) {
-                        return tuple_util::transform(impl_::sum(), lhs, rhs);
+                        return tuple_util::transform(std::plus<>(), lhs, rhs);
                     }
 
                     template <class... Ptrs, class Offset>
-                    friend GT_FUNCTION void sid_shift(
+                    friend GT_FORCE_INLINE constexpr void sid_shift(
                         composite_ptr<Ptrs...> &ptr, composite_entity const &stride, Offset offset) {
                         impl_::composite_shift_impl(ptr.m_vals, stride, offset);
                     }
 
                     template <class... Ptrs, class Offset>
-                    friend GT_FUNCTION void sid_shift(
+                    friend GT_FORCE_INLINE constexpr void sid_shift(
                         composite_ptr<Ptrs...> &ptr, composite_entity &&stride, Offset offset) {
-                        impl_::composite_shift_impl(ptr.m_vals, wstd::move(stride), offset);
+                        impl_::composite_shift_impl(ptr.m_vals, std::move(stride), offset);
                     }
 
                     friend keys hymap_get_keys(composite_entity const &) { return {}; }
                 };
 
                 template <class... PtrDiffs, class... Strides, class Offset>
-                friend GT_FUNCTION void sid_shift(composite_entity<PtrDiffs...> &ptr_diff,
+                friend GT_FORCE_INLINE constexpr void sid_shift(composite_entity<PtrDiffs...> &ptr_diff,
                     composite_entity<Strides...> const &stride,
                     Offset offset) {
                     impl_::composite_shift_impl(ptr_diff.m_vals, stride.m_vals, offset);
                 }
 
                 template <class... PtrDiffs, class... Strides, class Offset>
-                friend GT_FUNCTION void sid_shift(
+                friend GT_FORCE_INLINE constexpr void sid_shift(
                     composite_entity<PtrDiffs...> &ptr_diff, composite_entity<Strides...> &&stride, Offset offset) {
-                    impl_::composite_shift_impl(ptr_diff.m_vals, wstd::move(stride.m_vals), offset);
+                    impl_::composite_shift_impl(ptr_diff.m_vals, std::move(stride.m_vals), offset);
                 }
 
                 struct convert_f {
                     template <template <class...> class L, class... Ts>
-                    composite_entity<std::remove_reference_t<Ts>...> operator()(L<Ts...> &&tup) const {
+                    GT_FORCE_INLINE constexpr composite_entity<std::remove_reference_t<Ts>...> operator()(
+                        L<Ts...> &&tup) const {
                         return {impl_::ctor_tag(), std::move(tup)};
                     }
                 };
@@ -375,11 +381,10 @@ namespace gridtools {
                 static_assert(sizeof...(Keys) == sizeof...(Sids), GT_INTERNAL_ERROR);
 #if defined(__CUDACC_VER_MAJOR__) && __CUDACC_VER_MAJOR__ == 11 && __CUDACC_VER_MINOR__ < 1
 #else
-                static_assert(std::conjunction<is_sid<Sids>...>::value, GT_INTERNAL_ERROR);
+                static_assert(std::conjunction_v<is_sid<Sids>...>, GT_INTERNAL_ERROR);
 #endif
                 static_assert(meta::all<meta::mp_make<impl_::check_strides_of_the_same_kind,
-                                  meta::list<meta::list<strides_kind<Sids>, strides_type<Sids>>...>>>(),
-                    "");
+                        meta::list<meta::list<strides_kind<Sids>, strides_type<Sids>>...>>>());
 
                 tuple<Sids...> m_sids;
 
@@ -474,9 +479,9 @@ namespace gridtools {
             template <>
             template <>
             struct keys<>::values<> {
-                constexpr GT_FUNCTION values operator()() const { return {}; }
-                constexpr GT_FUNCTION values operator*() const { return {}; }
-                friend constexpr GT_FUNCTION values operator+(values, values) { return {}; }
+                constexpr values operator()() const { return {}; }
+                constexpr values operator*() const { return {}; }
+                friend constexpr values operator+(values, values) { return {}; }
                 friend values sid_get_origin(values) { return {}; }
                 friend values sid_get_ptr_diff(values) { return {}; }
                 friend values tuple_getter(values) { return {}; }
diff --git a/include/gridtools/sid/concept.hpp b/include/gridtools/sid/concept.hpp
index 1d2f2c9892..5bde37444c 100644
--- a/include/gridtools/sid/concept.hpp
+++ b/include/gridtools/sid/concept.hpp
@@ -11,6 +11,7 @@
 
 #include <limits>
 #include <type_traits>
+#include <utility>
 
 #include "../common/defs.hpp"
 #include "../common/host_device.hpp"
@@ -215,7 +216,7 @@ namespace gridtools {
              *  C-array specialization
              */
             template <class T, class Res = std::add_pointer_t<std::remove_all_extents_t<T>>>
-            std::enable_if_t<std::is_array<T>::value, host_device::simple_ptr_holder<Res>> get_origin(T &obj) {
+            std::enable_if_t<std::is_array<T>::value, simple_ptr_holder<Res>> get_origin(T &obj) {
                 return {(Res)obj};
             }
 
@@ -449,8 +450,8 @@ namespace gridtools {
              *  noop `shift` overload
              */
             template <class T, class Stride, class Offset>
-            GT_FUNCTION std::enable_if_t<!(std::is_lvalue_reference<T>::value &&
-                                           need_shift<std::remove_reference_t<T>, std::decay_t<Stride>, Offset>::value)>
+            constexpr std::enable_if_t<!(std::is_lvalue_reference<T>::value &&
+                                         need_shift<std::remove_reference_t<T>, std::decay_t<Stride>, Offset>::value)>
             shift(T &&, Stride &&, Offset) {}
 
             /**
@@ -464,8 +465,8 @@ namespace gridtools {
                 std::enable_if_t<need_shift<T, std::decay_t<Stride>, Offset>::value &&
                                      !is_default_shiftable<T, std::decay_t<Stride>>::value,
                     int> = 0>
-            GT_FUNCTION decltype(auto) shift(T &obj, Stride &&stride, Offset offset) {
-                return sid_shift(obj, wstd::forward<Stride>(stride), offset);
+            constexpr decltype(auto) shift(T &obj, Stride &&stride, Offset offset) {
+                return sid_shift(obj, std::forward<Stride>(stride), offset);
             }
 
             /**
@@ -475,10 +476,10 @@ namespace gridtools {
                 class Stride,
                 class Offset,
                 int_t PtrOffset = get_static_const_value<Stride>::value *Offset::value>
-            GT_FUNCTION
-                std::enable_if_t<need_shift<T, Stride, Offset>::value && is_default_shiftable<T, Stride>::value &&
-                                 !(has_inc<T>::value && PtrOffset == 1) && !(has_dec<T>::value && PtrOffset == -1)>
-                shift(T &obj, Stride, Offset) {
+            constexpr std::enable_if_t<need_shift<T, Stride, Offset>::value && is_default_shiftable<T, Stride>::value &&
+                                       !(has_inc<T>::value && PtrOffset == 1) &&
+                                       !(has_dec<T>::value && PtrOffset == -1)>
+            shift(T &obj, Stride, Offset) {
                 obj += integral_constant<int_t, PtrOffset>{};
             }
 
@@ -489,8 +490,8 @@ namespace gridtools {
                 class Stride,
                 class Offset,
                 int_t PtrOffset = get_static_const_value<Stride>::value *Offset::value>
-            GT_FUNCTION std::enable_if_t<need_shift<T, Stride, Offset>::value &&
-                                         is_default_shiftable<T, Stride>::value && has_inc<T>::value && PtrOffset == 1>
+            constexpr std::enable_if_t<need_shift<T, Stride, Offset>::value && is_default_shiftable<T, Stride>::value &&
+                                       has_inc<T>::value && PtrOffset == 1>
             shift(T &obj, Stride, Offset) {
                 ++obj;
             }
@@ -502,8 +503,8 @@ namespace gridtools {
                 class Stride,
                 class Offset,
                 int_t PtrOffset = get_static_const_value<Stride>::value *Offset::value>
-            GT_FUNCTION std::enable_if_t<need_shift<T, Stride, Offset>::value &&
-                                         is_default_shiftable<T, Stride>::value && has_dec<T>::value && PtrOffset == -1>
+            constexpr std::enable_if_t<need_shift<T, Stride, Offset>::value && is_default_shiftable<T, Stride>::value &&
+                                       has_dec<T>::value && PtrOffset == -1>
             shift(T &obj, Stride, Offset) {
                 --obj;
             }
@@ -512,10 +513,10 @@ namespace gridtools {
              *  `shift` overload where the offset is 1
              */
             template <class T, class Stride, class Offset>
-            GT_FUNCTION
-                std::enable_if_t<need_shift<T, Stride, Offset>::value && is_default_shiftable<T, Stride>::value &&
-                                 !is_integral_constant<Stride>::value && is_integral_constant_of<Offset, 1>::value>
-                shift(T &obj, Stride const &stride, Offset) {
+            constexpr std::enable_if_t<need_shift<T, Stride, Offset>::value && is_default_shiftable<T, Stride>::value &&
+                                       !is_integral_constant<Stride>::value &&
+                                       is_integral_constant_of<Offset, 1>::value>
+            shift(T &obj, Stride const &stride, Offset) {
                 obj += stride;
             }
 
@@ -523,11 +524,11 @@ namespace gridtools {
              *  `shift` overload where the offset is -1
              */
             template <class T, class Stride, class Offset>
-            GT_FUNCTION
-                std::enable_if_t<need_shift<T, Stride, Offset>::value && is_default_shiftable<T, Stride>::value &&
-                                 !is_integral_constant<Stride>::value && is_integral_constant_of<Offset, -1>::value &&
-                                 has_dec_assignment<T, Stride>::value>
-                shift(T &obj, Stride const &stride, Offset) {
+            constexpr std::enable_if_t<need_shift<T, Stride, Offset>::value && is_default_shiftable<T, Stride>::value &&
+                                       !is_integral_constant<Stride>::value &&
+                                       is_integral_constant_of<Offset, -1>::value &&
+                                       has_dec_assignment<T, Stride>::value>
+            shift(T &obj, Stride const &stride, Offset) {
                 obj -= stride;
             }
 
@@ -535,10 +536,10 @@ namespace gridtools {
              *  `shift` overload where the stride is 1
              */
             template <class T, class Stride, class Offset>
-            GT_FUNCTION
-                std::enable_if_t<need_shift<T, Stride, Offset>::value && is_default_shiftable<T, Stride>::value &&
-                                 is_integral_constant_of<Stride, 1>::value && !is_integral_constant<Offset>::value>
-                shift(T &obj, Stride, Offset offset) {
+            constexpr std::enable_if_t<need_shift<T, Stride, Offset>::value && is_default_shiftable<T, Stride>::value &&
+                                       is_integral_constant_of<Stride, 1>::value &&
+                                       !is_integral_constant<Offset>::value>
+            shift(T &obj, Stride, Offset offset) {
                 obj += offset;
             }
 
@@ -546,11 +547,10 @@ namespace gridtools {
              *  `shift` overload where the stride is -1
              */
             template <class T, class Stride, class Offset>
-            GT_FUNCTION
-                std::enable_if_t<need_shift<T, Stride, Offset>::value && is_default_shiftable<T, Stride>::value &&
-                                 is_integral_constant_of<Stride, -1>::value && !is_integral_constant<Offset>::value &&
-                                 has_dec_assignment<T, Stride>::value>
-                shift(T &obj, Stride, Offset offset) {
+            constexpr std::enable_if_t<need_shift<T, Stride, Offset>::value && is_default_shiftable<T, Stride>::value &&
+                                       is_integral_constant_of<Stride, -1>::value &&
+                                       !is_integral_constant<Offset>::value && has_dec_assignment<T, Stride>::value>
+            shift(T &obj, Stride, Offset offset) {
                 obj -= offset;
             }
 
@@ -558,14 +558,14 @@ namespace gridtools {
              *  `shift` overload, default version
              */
             template <class T, class Stride, class Offset, class Decayed = std::decay_t<Stride>>
-            GT_FUNCTION std::enable_if_t<
+            constexpr std::enable_if_t<
                 need_shift<T, Decayed, Offset>::value && is_default_shiftable<T, Decayed>::value &&
                 !(is_integral_constant<Decayed>::value && is_integral_constant<Offset>::value) &&
                 !(is_integral_constant_of<Decayed, 1>::value || is_integral_constant_of<Offset, 1>::value) &&
                 !(has_dec_assignment<T, Decayed>::value &&
                     (is_integral_constant_of<Decayed, -1>::value || is_integral_constant_of<Offset, -1>::value))>
             shift(T &obj, Stride &&stride, Offset offset) {
-                obj += wstd::forward<Stride>(stride) * offset;
+                obj += std::forward<Stride>(stride) * offset;
             }
 
             // END `shift` PART
@@ -611,7 +611,8 @@ namespace gridtools {
                 class UpperBoundsType = upper_bounds_type<Sid>>
             using is_sid = std::conjunction<
 
-                // `is_trivially_copyable` check is applied to the types that are will be passed from host to device
+                // `is_trivially_copy_constructible` check is applied to the types that are will be passed from host to
+                // device
                 std::is_trivially_copy_constructible<PtrHolder>,
                 std::is_trivially_copy_constructible<StridesType>,
 
@@ -692,8 +693,8 @@ namespace gridtools {
          *  Which allows to silently ignore the offsets in non existing dimensions.
          */
         template <class Key, class Strides>
-        GT_CONSTEXPR GT_FUNCTION decltype(auto) get_stride(Strides &&strides) {
-            return gridtools::host_device::at_key_with_default<Key, default_stride>(wstd::forward<Strides>(strides));
+        constexpr decltype(auto) get_stride(Strides &&strides) {
+            return at_key_with_default<Key, default_stride>(std::forward<Strides>(strides));
         }
 
         /**
@@ -704,16 +705,15 @@ namespace gridtools {
             class Dim,
             class Strides,
             std::enable_if_t<has_key<std::decay_t<Strides>, Dim>::value, int> = 0>
-        GT_CONSTEXPR GT_FUNCTION decltype(auto) get_stride_element(Strides &&strides) {
-            return gridtools::host_device::at_key<Key>(
-                gridtools::host_device::at_key<Dim>(wstd::forward<Strides>(strides)));
+        constexpr decltype(auto) get_stride_element(Strides &&strides) {
+            return at_key<Key>(at_key<Dim>(std::forward<Strides>(strides)));
         }
 
         template <class Key,
             class Dim,
             class Strides,
             std::enable_if_t<!has_key<std::decay_t<Strides>, Dim>::value, int> = 0>
-        GT_CONSTEXPR GT_FUNCTION integral_constant<int_t, 0> get_stride_element(Strides &&) {
+        constexpr integral_constant<int_t, 0> get_stride_element(Strides &&) {
             return {};
         }
 
@@ -724,17 +724,17 @@ namespace gridtools {
          */
         template <class Key, class Bounds>
         decltype(auto) get_lower_bound(Bounds &&bounds) {
-            return gridtools::host_device::at_key_with_default<Key,
-                integral_constant<int_t, std::numeric_limits<int_t>::min()>>(wstd::forward<Bounds>(bounds));
+            return at_key_with_default<Key, integral_constant<int_t, std::numeric_limits<int_t>::min()>>(
+                std::forward<Bounds>(bounds));
         }
         template <class Key, class Bounds>
         decltype(auto) get_upper_bound(Bounds &&bounds) {
-            return gridtools::host_device::at_key_with_default<Key,
-                integral_constant<int_t, std::numeric_limits<int_t>::max()>>(wstd::forward<Bounds>(bounds));
+            return at_key_with_default<Key, integral_constant<int_t, std::numeric_limits<int_t>::max()>>(
+                std::forward<Bounds>(bounds));
         }
 
         template <class T, class Stride, class Offset>
-        GT_FUNCTION T shifted(T obj, Stride const &stride, Offset offset) {
+        constexpr T shifted(T obj, Stride const &stride, Offset offset) {
             shift(obj, stride, offset);
             return obj;
         }
diff --git a/include/gridtools/sid/loop.hpp b/include/gridtools/sid/loop.hpp
index 49e1fc35f6..75a10c3585 100644
--- a/include/gridtools/sid/loop.hpp
+++ b/include/gridtools/sid/loop.hpp
@@ -27,7 +27,7 @@ namespace gridtools {
 
             template <class Key, class T>
             struct generic_loop {
-                static_assert(std::is_signed<T>::value, GT_INTERNAL_ERROR);
+                static_assert(std::is_signed_v<T>, GT_INTERNAL_ERROR);
 
                 T m_num_steps;
                 T m_step;
@@ -39,7 +39,7 @@ namespace gridtools {
                     T m_step;
 
                     template <class Ptr, class Strides>
-                    void GT_FUNCTION operator()(Ptr &&ptr, Strides const &strides) const {
+                    GT_FORCE_INLINE constexpr void operator()(Ptr &&ptr, Strides const &strides) const {
                         assert(m_num_steps >= 0);
                         if (m_num_steps <= 0)
                             return;
@@ -48,13 +48,13 @@ namespace gridtools {
                             m_fun(ptr, strides);
                             shift(ptr, stride, m_step);
                         }
-                        shift(wstd::forward<Ptr>(ptr), stride, -m_step * m_num_steps);
+                        shift(std::forward<Ptr>(ptr), stride, -m_step * m_num_steps);
                     }
                 };
 
                 template <class Fun>
-                GT_CONSTEXPR GT_FUNCTION loop_f<Fun> operator()(Fun &&fun) const {
-                    return {wstd::forward<Fun>(fun), m_num_steps, m_step};
+                GT_FORCE_INLINE constexpr loop_f<Fun> operator()(Fun &&fun) const {
+                    return {std::forward<Fun>(fun), m_num_steps, m_step};
                 }
 
                 template <class Outer>
@@ -65,25 +65,25 @@ namespace gridtools {
                     T m_pos;
 
                     template <class Ptr, class Strides>
-                    void GT_FUNCTION next(Ptr &&ptr, Strides const &strides) {
+                    GT_FORCE_INLINE constexpr void next(Ptr &&ptr, Strides const &strides) {
                         assert(m_num_steps >= 0);
                         if (m_num_steps <= 0)
                             return;
                         if (++m_pos == m_num_steps) {
                             shift(ptr, get_stride<Key>(strides), m_step * (1 - m_num_steps));
                             m_pos = 0;
-                            m_outer.next(wstd::forward<Ptr>(ptr), strides);
+                            m_outer.next(std::forward<Ptr>(ptr), strides);
                         } else {
-                            shift(wstd::forward<Ptr>(ptr), get_stride<Key>(strides), m_step);
+                            shift(std::forward<Ptr>(ptr), get_stride<Key>(strides), m_step);
                         }
                     }
 
-                    GT_FUNCTION bool done() const { return m_num_steps <= 0 || m_outer.done(); }
+                    GT_FORCE_INLINE constexpr bool done() const { return m_num_steps <= 0 || m_outer.done(); }
                 };
 
                 template <class Outer>
-                GT_CONSTEXPR GT_FUNCTION cursor_f<Outer> make_cursor(Outer &&outer) const {
-                    return {wstd::forward<Outer>(outer), m_num_steps, m_step, 0};
+                GT_FORCE_INLINE constexpr cursor_f<Outer> make_cursor(Outer &&outer) const {
+                    return {std::forward<Outer>(outer), m_num_steps, m_step, 0};
                 }
 
                 struct outer_most_cursor_f {
@@ -91,20 +91,20 @@ namespace gridtools {
                     T m_pos;
 
                     template <class Ptr, class Strides>
-                    void GT_FUNCTION next(Ptr &&ptr, Strides const &strides) {
+                    GT_FORCE_INLINE constexpr void next(Ptr &&ptr, Strides const &strides) {
                         --m_pos;
-                        shift(wstd::forward<Ptr>(ptr), get_stride<Key>(strides), m_step);
+                        shift(std::forward<Ptr>(ptr), get_stride<Key>(strides), m_step);
                     }
 
-                    GT_FUNCTION bool done() const { return m_pos > 0; }
+                    GT_FORCE_INLINE constexpr bool done() const { return m_pos > 0; }
                 };
 
-                GT_CONSTEXPR GT_FUNCTION outer_most_cursor_f make_cursor() const { return {m_step, m_num_steps}; }
+                GT_FORCE_INLINE constexpr outer_most_cursor_f make_cursor() const { return {m_step, m_num_steps}; }
             };
 
             template <class Key, class T, ptrdiff_t Step>
             struct known_step_loop {
-                static_assert(std::is_signed<T>::value, GT_INTERNAL_ERROR);
+                static_assert(std::is_signed_v<T>, GT_INTERNAL_ERROR);
 
                 T m_num_steps;
 
@@ -114,7 +114,7 @@ namespace gridtools {
                     T m_num_steps;
 
                     template <class Ptr, class Strides>
-                    void GT_FUNCTION operator()(Ptr &&ptr, Strides const &strides) const {
+                    GT_FORCE_INLINE constexpr void operator()(Ptr &&ptr, Strides const &strides) const {
                         assert(m_num_steps >= 0);
                         if (m_num_steps <= 0)
                             return;
@@ -123,14 +123,13 @@ namespace gridtools {
                             m_fun(ptr, strides);
                             shift(ptr, stride, integral_constant<T, Step>{});
                         }
-                        static constexpr T minus_step = -Step;
-                        shift(wstd::forward<Ptr>(ptr), stride, minus_step * m_num_steps);
+                        shift(std::forward<Ptr>(ptr), stride, - Step * m_num_steps);
                     }
                 };
 
                 template <class Fun>
-                GT_FUNCTION loop_f<Fun> operator()(Fun &&fun) const {
-                    return {wstd::forward<Fun>(fun), m_num_steps};
+                GT_FORCE_INLINE constexpr loop_f<Fun> operator()(Fun &&fun) const {
+                    return {std::forward<Fun>(fun), m_num_steps};
                 }
 
                 template <class Outer>
@@ -140,45 +139,45 @@ namespace gridtools {
                     T m_pos;
 
                     template <class Ptr, class Strides>
-                    void GT_FUNCTION next(Ptr &&ptr, Strides const &strides) {
+                    GT_FORCE_INLINE constexpr void next(Ptr &&ptr, Strides const &strides) {
                         assert(m_num_steps >= 0);
                         if (m_num_steps <= 0)
                             return;
                         if (++m_pos == m_num_steps) {
                             shift(ptr, get_stride<Key>(strides), Step * (1 - m_num_steps));
                             m_pos = 0;
-                            m_outer.next(wstd::forward<Ptr>(ptr), strides);
+                            m_outer.next(std::forward<Ptr>(ptr), strides);
                         } else {
-                            shift(wstd::forward<Ptr>(ptr), get_stride<Key>(strides), integral_constant<T, Step>{});
+                            shift(std::forward<Ptr>(ptr), get_stride<Key>(strides), integral_constant<T, Step>{});
                         }
                     }
 
-                    GT_FUNCTION bool done() const { return m_num_steps <= 0 || m_outer.done(); }
+                    GT_FORCE_INLINE constexpr bool done() const { return m_num_steps <= 0 || m_outer.done(); }
                 };
 
                 template <class Outer>
-                GT_CONSTEXPR GT_FUNCTION cursor_f<Outer> make_cursor(Outer &&outer) const {
-                    return {wstd::forward<Outer>(outer), m_num_steps, 0};
+                GT_FORCE_INLINE constexpr cursor_f<Outer> make_cursor(Outer &&outer) const {
+                    return {std::forward<Outer>(outer), m_num_steps, 0};
                 }
 
                 struct outer_most_cursor_f {
                     T m_pos;
 
                     template <class Ptr, class Strides>
-                    void GT_FUNCTION next(Ptr &&ptr, Strides const &strides) {
+                    GT_FORCE_INLINE constexpr void next(Ptr &&ptr, Strides const &strides) {
                         --m_pos;
-                        shift(wstd::forward<Ptr>(ptr), get_stride<Key>(strides), integral_constant<T, Step>{});
+                        shift(std::forward<Ptr>(ptr), get_stride<Key>(strides), integral_constant<T, Step>{});
                     }
 
-                    GT_FUNCTION bool done() const { return m_pos > 0; }
+                    GT_FORCE_INLINE constexpr bool done() const { return m_pos > 0; }
                 };
 
-                GT_CONSTEXPR GT_FUNCTION outer_most_cursor_f make_cursor() const { return {m_num_steps}; }
+                GT_FORCE_INLINE constexpr outer_most_cursor_f make_cursor() const { return {m_num_steps}; }
             };
 
             template <class Key, class T>
             struct known_step_loop<Key, T, 0> {
-                static_assert(std::is_signed<T>::value, GT_INTERNAL_ERROR);
+                static_assert(std::is_signed_v<T>, GT_INTERNAL_ERROR);
 
                 T m_num_steps;
 
@@ -188,16 +187,16 @@ namespace gridtools {
                     T m_num_steps;
 
                     template <class Ptr, class Strides>
-                    void GT_FUNCTION operator()(Ptr &&ptr, const Strides &strides) const {
+                    GT_FORCE_INLINE constexpr void operator()(Ptr &&ptr, const Strides &strides) const {
                         assert(m_num_steps >= 0);
                         for (T i = 0; i < m_num_steps; ++i)
-                            m_fun(wstd::forward<Ptr>(ptr), strides);
+                            m_fun(std::forward<Ptr>(ptr), strides);
                     }
                 };
 
                 template <class Fun>
-                GT_CONSTEXPR GT_FUNCTION loop_f<Fun> operator()(Fun &&fun) const {
-                    return {wstd::forward<Fun>(fun), m_num_steps};
+                GT_FORCE_INLINE constexpr loop_f<Fun> operator()(Fun &&fun) const {
+                    return {std::forward<Fun>(fun), m_num_steps};
                 }
 
                 template <class Outer>
@@ -207,41 +206,41 @@ namespace gridtools {
                     T m_pos;
 
                     template <class Ptr, class Strides>
-                    void GT_FUNCTION next(Ptr &&ptr, Strides const &strides) {
+                    GT_FORCE_INLINE constexpr void next(Ptr &&ptr, Strides const &strides) {
                         assert(m_num_steps >= 0);
                         if (m_num_steps <= 0)
                             return;
                         if (++m_pos == m_num_steps) {
                             m_pos = 0;
-                            m_outer.next(wstd::forward<Ptr>(ptr), strides);
+                            m_outer.next(std::forward<Ptr>(ptr), strides);
                         }
                     }
 
-                    GT_FUNCTION bool done() const { return m_num_steps <= 0 || m_outer.done(); }
+                    GT_FORCE_INLINE constexpr bool done() const { return m_num_steps <= 0 || m_outer.done(); }
                 };
 
                 template <class Outer>
-                GT_CONSTEXPR GT_FUNCTION cursor_f<Outer> make_cursor(Outer &&outer) const {
-                    return {wstd::forward<Outer>(outer), m_num_steps, 0};
+                GT_FORCE_INLINE constexpr cursor_f<Outer> make_cursor(Outer &&outer) const {
+                    return {std::forward<Outer>(outer), m_num_steps, 0};
                 }
 
                 struct outer_most_cursor_f {
                     T m_pos;
 
                     template <class Ptr, class Strides>
-                    void GT_FUNCTION next(Ptr &&, Strides const &) {
+                    GT_FORCE_INLINE constexpr void next(Ptr &&, Strides const &) {
                         --m_pos;
                     }
 
-                    GT_FUNCTION bool done() const { return m_pos > 0; }
+                    GT_FORCE_INLINE constexpr bool done() const { return m_pos > 0; }
                 };
 
-                GT_CONSTEXPR GT_FUNCTION outer_most_cursor_f make_cursor() const { return {m_num_steps}; }
+                GT_FORCE_INLINE constexpr outer_most_cursor_f make_cursor() const { return {m_num_steps}; }
             };
 
             template <class Key, class T, T NumSteps>
             struct known_num_steps_loop {
-                static_assert(std::is_signed<T>::value, GT_INTERNAL_ERROR);
+                static_assert(std::is_signed_v<T>, GT_INTERNAL_ERROR);
 
                 T m_step;
 
@@ -251,21 +250,20 @@ namespace gridtools {
                     T m_step;
 
                     template <class Ptr, class Strides>
-                    void GT_FUNCTION operator()(Ptr &&ptr, const Strides &strides) const {
+                    GT_FORCE_INLINE constexpr void operator()(Ptr &&ptr, const Strides &strides) const {
                         auto &&stride = get_stride<Key>(strides);
                         // TODO(anstaf): to figure out if for_each<make_indices_c<NumSteps>>(...) produces better code.
                         for (T i = 0; i < NumSteps; ++i) {
                             m_fun(ptr, strides);
                             shift(ptr, stride, m_step);
                         }
-                        static constexpr T minus_num_steps = -NumSteps;
-                        shift(wstd::forward<Ptr>(ptr), stride, m_step * minus_num_steps);
+                        shift(std::forward<Ptr>(ptr), stride, - m_step * NumSteps);
                     }
                 };
 
                 template <class Fun>
-                GT_CONSTEXPR GT_FUNCTION loop_f<Fun> operator()(Fun &&fun) const {
-                    return {wstd::forward<Fun>(fun), m_step};
+                GT_FORCE_INLINE constexpr loop_f<Fun> operator()(Fun &&fun) const {
+                    return {std::forward<Fun>(fun), m_step};
                 }
 
                 template <class Outer>
@@ -275,23 +273,22 @@ namespace gridtools {
                     T m_pos;
 
                     template <class Ptr, class Strides>
-                    void GT_FUNCTION next(Ptr &&ptr, Strides const &strides) {
+                    GT_FORCE_INLINE constexpr void next(Ptr &&ptr, Strides const &strides) {
                         if (++m_pos == NumSteps) {
-                            constexpr T num_steps_back = 1 - NumSteps;
-                            shift(ptr, get_stride<Key>(strides), m_step * num_steps_back);
+                            shift(ptr, get_stride<Key>(strides), m_step * (1 - NumSteps));
                             m_pos = 0;
-                            m_outer.next(wstd::forward<Ptr>(ptr), strides);
+                            m_outer.next(std::forward<Ptr>(ptr), strides);
                         } else {
-                            shift(wstd::forward<Ptr>(ptr), get_stride<Key>(strides), m_step);
+                            shift(std::forward<Ptr>(ptr), get_stride<Key>(strides), m_step);
                         }
                     }
 
-                    GT_FUNCTION bool done() const { return m_outer.done(); }
+                    GT_FORCE_INLINE constexpr bool done() const { return m_outer.done(); }
                 };
 
                 template <class Outer>
-                GT_CONSTEXPR GT_FUNCTION cursor_f<Outer> make_cursor(Outer &&outer) const {
-                    return {wstd::forward<Outer>(outer), m_step, 0};
+                GT_FORCE_INLINE constexpr cursor_f<Outer> make_cursor(Outer &&outer) const {
+                    return {std::forward<Outer>(outer), m_step, 0};
                 }
 
                 struct outer_most_cursor_f {
@@ -299,39 +296,39 @@ namespace gridtools {
                     T m_pos;
 
                     template <class Ptr, class Strides>
-                    void GT_FUNCTION next(Ptr &&ptr, Strides const &strides) {
+                    GT_FORCE_INLINE constexpr void next(Ptr &&ptr, Strides const &strides) {
                         --m_pos;
-                        shift(wstd::forward<Ptr>(ptr), get_stride<Key>(strides), m_step);
+                        shift(std::forward<Ptr>(ptr), get_stride<Key>(strides), m_step);
                     }
 
-                    GT_FUNCTION bool done() const { return m_pos > 0; }
+                    GT_FORCE_INLINE constexpr bool done() const { return m_pos > 0; }
                 };
 
-                GT_CONSTEXPR GT_FUNCTION outer_most_cursor_f make_cursor() const { return {m_step, NumSteps}; }
+                GT_FORCE_INLINE constexpr outer_most_cursor_f make_cursor() const { return {m_step, NumSteps}; }
             };
 
             template <class Key, class T, ptrdiff_t NumSteps, ptrdiff_t Step>
             struct all_known_loop {
-                static_assert(std::is_signed<T>::value, GT_INTERNAL_ERROR);
+                static_assert(std::is_signed_v<T>, GT_INTERNAL_ERROR);
 
                 template <class Fun>
                 struct loop_f {
                     Fun m_fun;
 
                     template <class Ptr, class Strides>
-                    void GT_FUNCTION operator()(Ptr &&ptr, const Strides &strides) const {
+                    GT_FORCE_INLINE constexpr void operator()(Ptr &&ptr, const Strides &strides) const {
                         auto &&stride = get_stride<Key>(strides);
                         for (T i = 0; i < (T)NumSteps; ++i) {
                             m_fun(ptr, strides);
                             shift(ptr, stride, integral_constant<T, Step>{});
                         }
-                        shift(wstd::forward<Ptr>(ptr), stride, integral_constant<T, -Step * NumSteps>{});
+                        shift(std::forward<Ptr>(ptr), stride, integral_constant<T, -Step * NumSteps>{});
                     }
                 };
 
                 template <class Fun>
-                GT_CONSTEXPR GT_FUNCTION loop_f<Fun> operator()(Fun &&fun) const {
-                    return {wstd::forward<Fun>(fun)};
+                GT_FORCE_INLINE constexpr loop_f<Fun> operator()(Fun &&fun) const {
+                    return {std::forward<Fun>(fun)};
                 }
 
                 template <class Outer>
@@ -340,58 +337,57 @@ namespace gridtools {
                     T m_pos;
 
                     template <class Ptr, class Strides>
-                    void GT_FUNCTION next(Ptr &&ptr, Strides const &strides) {
+                    GT_FORCE_INLINE constexpr void next(Ptr &&ptr, Strides const &strides) {
                         if (++m_pos == NumSteps) {
-                            constexpr T offset_back = Step * (1 - NumSteps);
-                            shift(ptr, get_stride<Key>(strides), offset_back);
+                            shift(ptr, get_stride<Key>(strides), Step * (1 - NumSteps));
                             m_pos = 0;
-                            m_outer.next(wstd::forward<Ptr>(ptr), strides);
+                            m_outer.next(std::forward<Ptr>(ptr), strides);
                         } else {
-                            shift(wstd::forward<Ptr>(ptr), get_stride<Key>(strides), Step);
+                            shift(std::forward<Ptr>(ptr), get_stride<Key>(strides), Step);
                         }
                     }
 
-                    GT_FUNCTION bool done() const { return m_outer.done(); }
+                    GT_FORCE_INLINE constexpr bool done() const { return m_outer.done(); }
                 };
 
                 template <class Outer>
-                GT_CONSTEXPR GT_FUNCTION cursor_f<Outer> make_cursor(Outer &&outer) const {
-                    return {wstd::forward<Outer>(outer), 0};
+                GT_FORCE_INLINE constexpr cursor_f<Outer> make_cursor(Outer &&outer) const {
+                    return {std::forward<Outer>(outer), 0};
                 }
 
                 struct outer_most_cursor_f {
                     T m_pos;
 
                     template <class Ptr, class Strides>
-                    void GT_FUNCTION next(Ptr &&ptr, Strides const &strides) {
+                    GT_FORCE_INLINE constexpr void next(Ptr &&ptr, Strides const &strides) {
                         --m_pos;
-                        shift(wstd::forward<Ptr>(ptr), get_stride<Key>(strides), Step);
+                        shift(std::forward<Ptr>(ptr), get_stride<Key>(strides), Step);
                     }
 
-                    GT_FUNCTION bool done() const { return m_pos > 0; }
+                    GT_FORCE_INLINE constexpr bool done() const { return m_pos > 0; }
                 };
 
-                GT_CONSTEXPR GT_FUNCTION outer_most_cursor_f make_cursor() const { return {NumSteps}; }
+                GT_FORCE_INLINE constexpr outer_most_cursor_f make_cursor() const { return {NumSteps}; }
             };
 
             template <class Key, class T, ptrdiff_t NumSteps>
             struct all_known_loop<Key, T, NumSteps, 0> {
-                static_assert(std::is_signed<T>::value, GT_INTERNAL_ERROR);
+                static_assert(std::is_signed_v<T>, GT_INTERNAL_ERROR);
 
                 template <class Fun>
                 struct loop_f {
                     Fun m_fun;
 
                     template <class Ptr, class Strides>
-                    void GT_FUNCTION operator()(Ptr &&ptr, Strides const &strides) const {
+                    GT_FORCE_INLINE constexpr void operator()(Ptr &&ptr, Strides const &strides) const {
                         for (T i = 0; i < (T)NumSteps; ++i)
                             m_fun(ptr, strides);
                     }
                 };
 
                 template <class Fun>
-                GT_CONSTEXPR GT_FUNCTION loop_f<Fun> operator()(Fun &&fun) const {
-                    return {wstd::forward<Fun>(fun)};
+                GT_FORCE_INLINE constexpr loop_f<Fun> operator()(Fun &&fun) const {
+                    return {std::forward<Fun>(fun)};
                 }
 
                 template <class Outer>
@@ -400,102 +396,102 @@ namespace gridtools {
                     T m_pos;
 
                     template <class Ptr, class Strides>
-                    void GT_FUNCTION next(Ptr &&ptr, Strides const &strides) {
+                    GT_FORCE_INLINE constexpr void next(Ptr &&ptr, Strides const &strides) {
                         if (++m_pos == NumSteps) {
                             m_pos = 0;
-                            m_outer.next(wstd::forward<Ptr>(ptr), strides);
+                            m_outer.next(std::forward<Ptr>(ptr), strides);
                         }
                     }
 
-                    GT_FUNCTION bool done() const { return m_outer.done(); }
+                    GT_FORCE_INLINE constexpr bool done() const { return m_outer.done(); }
                 };
 
                 template <class Outer>
-                GT_CONSTEXPR GT_FUNCTION cursor_f<Outer> make_cursor(Outer &&outer) const {
-                    return {wstd::forward<Outer>(outer), 0};
+                GT_FORCE_INLINE constexpr cursor_f<Outer> make_cursor(Outer &&outer) const {
+                    return {std::forward<Outer>(outer), 0};
                 }
 
                 struct outer_most_cursor_f {
                     T m_pos;
 
                     template <class Ptr, class Strides>
-                    void GT_FUNCTION next(Ptr &&, Strides const &) {
+                    GT_FORCE_INLINE constexpr void next(Ptr &&, Strides const &) {
                         --m_pos;
                     }
 
-                    GT_FUNCTION bool done() const { return m_pos > 0; }
+                    GT_FORCE_INLINE constexpr bool done() const { return m_pos > 0; }
                 };
 
-                GT_CONSTEXPR GT_FUNCTION outer_most_cursor_f make_cursor() const { return {NumSteps}; }
+                GT_FORCE_INLINE constexpr outer_most_cursor_f make_cursor() const { return {NumSteps}; }
             };
 
             template <class Key, class T>
             struct all_known_loop<Key, T, 1, 0> {
-                static_assert(std::is_signed<T>::value, GT_INTERNAL_ERROR);
+                static_assert(std::is_signed_v<T>, GT_INTERNAL_ERROR);
 
                 template <class Fun>
-                GT_CONSTEXPR GT_FUNCTION Fun operator()(Fun &&fun) const {
+                GT_FORCE_INLINE constexpr Fun operator()(Fun &&fun) const {
                     return fun;
                 }
 
                 template <class Outer>
-                GT_CONSTEXPR GT_FUNCTION Outer make_cursor(Outer &&outer) const {
-                    return wstd::forward<Outer>(outer);
+                GT_FORCE_INLINE constexpr Outer make_cursor(Outer &&outer) const {
+                    return std::forward<Outer>(outer);
                 }
 
                 struct outer_most_cursor_f {
                     bool m_done;
 
                     template <class Ptr, class Strides>
-                    void GT_FUNCTION next(Ptr &&, Strides const &) {
+                    GT_FORCE_INLINE constexpr void next(Ptr &&, Strides const &) {
                         m_done = true;
                     }
 
-                    GT_FUNCTION bool done() const { return m_done; }
+                    GT_FORCE_INLINE constexpr bool done() const { return m_done; }
                 };
 
-                GT_CONSTEXPR GT_FUNCTION outer_most_cursor_f make_cursor() const { return {false}; }
+                GT_FORCE_INLINE constexpr outer_most_cursor_f make_cursor() const { return {false}; }
             };
 
             template <class Key, class T>
             struct all_known_loop<Key, T, 0, 0> {
-                static_assert(std::is_signed<T>::value, GT_INTERNAL_ERROR);
+                static_assert(std::is_signed_v<T>, GT_INTERNAL_ERROR);
 
                 template <class Fun>
-                GT_CONSTEXPR GT_FUNCTION gridtools::host_device::noop operator()(Fun &&) const {
+                GT_FORCE_INLINE constexpr noop operator()(Fun &&) const {
                     return {};
                 }
 
                 struct cursor_f {
                     template <class Ptr, class Strides>
-                    void GT_FUNCTION next(Ptr &&, Strides const &) {}
+                    GT_FORCE_INLINE constexpr void next(Ptr &&, Strides const &) {}
 
-                    GT_FUNCTION bool done() const { return true; }
+                    GT_FORCE_INLINE constexpr bool done() const { return true; }
                 };
 
                 template <class... Ts>
-                GT_CONSTEXPR GT_FUNCTION cursor_f make_cursor(Ts &&...) const {
+                GT_FORCE_INLINE constexpr cursor_f make_cursor(Ts &&...) const {
                     return {};
                 }
             };
 
             struct make_cursor_f {
                 template <class Cursor, class Loop>
-                GT_CONSTEXPR GT_FUNCTION auto operator()(Cursor &&cursor, Loop const &loop) const {
-                    return loop.make_cursor(wstd::forward<Cursor>(cursor));
+                GT_FORCE_INLINE constexpr auto operator()(Cursor &&cursor, Loop const &loop) const {
+                    return loop.make_cursor(std::forward<Cursor>(cursor));
                 }
             };
 
             template <class Loops>
-            GT_CONSTEXPR GT_FUNCTION auto make_cursor_r(Loops &&loops) {
-                return tuple_util::host_device::fold(make_cursor_f{},
-                    tuple_util::host_device::get<0>(wstd::forward<Loops>(loops)).make_cursor(),
-                    tuple_util::host_device::drop_front<1>(wstd::forward<Loops>(loops)));
+            GT_FORCE_INLINE constexpr auto make_cursor_r(Loops &&loops) {
+                return tuple_util::fold(make_cursor_f{},
+                    tuple_util::get<0>(std::forward<Loops>(loops)).make_cursor(),
+                    tuple_util::drop_front<1>(std::forward<Loops>(loops)));
             }
 
             template <class Loops>
-            GT_CONSTEXPR GT_FUNCTION auto make_cursor(Loops &&loops) {
-                return make_cursor_r(tuple_util::host_device::reverse(wstd::forward<Loops>(loops)));
+            GT_FORCE_INLINE constexpr auto make_cursor(Loops &&loops) {
+                return make_cursor_r(tuple_util::reverse(std::forward<Loops>(loops)));
             }
 
             template <class Ptr, class Strides, class Cursor>
@@ -504,21 +500,21 @@ namespace gridtools {
                 Strides const &m_strides;
                 Cursor m_cursor;
 
-                GT_FUNCTION decltype(auto) operator*() const { return *m_ptr; }
-                GT_FUNCTION void operator++() { m_cursor.next(m_ptr, m_strides); }
+                GT_FORCE_INLINE constexpr decltype(auto) operator*() const { return *m_ptr; }
+                GT_FORCE_INLINE constexpr void operator++() { m_cursor.next(m_ptr, m_strides); }
                 template <class T>
-                GT_FUNCTION bool operator!=(T &&) const {
+                GT_FORCE_INLINE constexpr bool operator!=(T &&) const {
                     return m_cursor.done();
                 }
 
-                range begin() const { return *this; }
-                range end() const { return *this; }
+                GT_FORCE_INLINE constexpr range begin() const { return *this; }
+                GT_FORCE_INLINE constexpr range end() const { return *this; }
             };
 
             template <class Ptr, class Strides, class Cursor>
-            GT_CONSTEXPR GT_FUNCTION range<Ptr, Strides const &, Cursor> make_range(
+            GT_FORCE_INLINE constexpr range<Ptr, Strides const &, Cursor> make_range(
                 Ptr ptr, Strides const &strides, Cursor &&cursor) {
-                return {wstd::move(ptr), strides, wstd::forward<Cursor>(cursor)};
+                return {std::move(ptr), strides, std::forward<Cursor>(cursor)};
             }
         } // namespace loop_impl_
 
@@ -587,7 +583,8 @@ namespace gridtools {
             class T2,
             class T = std::common_type_t<T1, T2>,
             std::enable_if_t<std::is_integral<T1>::value && std::is_integral<T2>::value, int> = 0>
-        GT_CONSTEXPR GT_FUNCTION loop_impl_::generic_loop<Key, std::make_signed_t<T>> make_loop(T1 num_steps, T2 step) {
+        GT_FORCE_INLINE constexpr loop_impl_::generic_loop<Key, std::make_signed_t<T>> make_loop(
+            T1 num_steps, T2 step) {
             return {std::make_signed_t<T>(num_steps), step};
         }
 
@@ -597,7 +594,7 @@ namespace gridtools {
             T2 Step = 1,
             class T = std::common_type_t<T1, T2>,
             std::enable_if_t<std::is_integral<T1>::value, int> = 0>
-        GT_CONSTEXPR GT_FUNCTION loop_impl_::known_step_loop<Key, std::make_signed_t<T>, Step> make_loop(
+        GT_FORCE_INLINE constexpr loop_impl_::known_step_loop<Key, std::make_signed_t<T>, Step> make_loop(
             T1 num_steps, std::integral_constant<T2, Step> = {}) {
             return {std::make_signed_t<T>(num_steps)};
         }
@@ -608,7 +605,7 @@ namespace gridtools {
             class T2,
             class T = std::common_type_t<T1, T2>,
             std::enable_if_t<std::is_integral<T1>::value && (NumStepsV > 1), int> = 0>
-        GT_CONSTEXPR GT_FUNCTION loop_impl_::known_num_steps_loop<Key, std::make_signed_t<T>, NumStepsV> make_loop(
+        GT_FORCE_INLINE constexpr loop_impl_::known_num_steps_loop<Key, std::make_signed_t<T>, NumStepsV> make_loop(
             std::integral_constant<T1, NumStepsV>, T2 step) {
             return {step};
         }
@@ -619,7 +616,7 @@ namespace gridtools {
             class T2,
             class T = std::common_type_t<T1, T2>,
             std::enable_if_t<std::is_integral<T1>::value && (NumStepsV == 0 || NumStepsV == 1), int> = 0>
-        GT_CONSTEXPR GT_FUNCTION loop_impl_::all_known_loop<Key, std::make_signed_t<T>, NumStepsV, 0> make_loop(
+        GT_FORCE_INLINE constexpr loop_impl_::all_known_loop<Key, std::make_signed_t<T>, NumStepsV, 0> make_loop(
             std::integral_constant<T1, NumStepsV>, T2) {
             return {};
         }
@@ -631,8 +628,8 @@ namespace gridtools {
             T2 StepV = 1,
             class T = std::common_type_t<T1, T2>,
             std::enable_if_t<(NumStepsV >= 0), int> = 0>
-        GT_CONSTEXPR
-            GT_FUNCTION loop_impl_::all_known_loop<Key, std::make_signed_t<T>, NumStepsV, (NumStepsV > 1) ? StepV : 0>
+        GT_FORCE_INLINE constexpr loop_impl_::
+            all_known_loop<Key, std::make_signed_t<T>, NumStepsV, (NumStepsV > 1) ? StepV : 0>
             make_loop(std::integral_constant<T1, NumStepsV>, std::integral_constant<T2, StepV> = {}) {
             return {};
         }
@@ -652,12 +649,12 @@ namespace gridtools {
          *   }
          */
         template <class Ptr, class Strides, class OuterMostLoop, class... Loops>
-        GT_CONSTEXPR GT_FUNCTION auto make_range(
-            Ptr ptr, Strides const &strides, OuterMostLoop &&outer_most_loop, Loops &&... loops) {
-            return loop_impl_::make_range(wstd::move(ptr),
+        GT_FORCE_INLINE constexpr auto make_range(
+            Ptr ptr, Strides const &strides, OuterMostLoop &&outer_most_loop, Loops &&...loops) {
+            return loop_impl_::make_range(std::move(ptr),
                 strides,
                 loop_impl_::make_cursor(tuple<OuterMostLoop, Loops...>{
-                    wstd::forward<OuterMostLoop>(outer_most_loop), wstd::forward<Loops>(loops)...}));
+                    std::forward<OuterMostLoop>(outer_most_loop), std::forward<Loops>(loops)...}));
         }
 
     } // namespace sid
diff --git a/include/gridtools/sid/multi_shift.hpp b/include/gridtools/sid/multi_shift.hpp
index d1db2a192d..adeeb47157 100644
--- a/include/gridtools/sid/multi_shift.hpp
+++ b/include/gridtools/sid/multi_shift.hpp
@@ -10,6 +10,7 @@
 #pragma once
 
 #include <type_traits>
+#include <utility>
 
 #include "../common/defs.hpp"
 #include "../common/host_device.hpp"
@@ -25,17 +26,16 @@ namespace gridtools {
             template <template <class...> class L, class... Dims>
             struct for_each_dim<L<Dims...>> {
                 template <class Ptr, class Strides, class Offsets>
-                GT_FUNCTION for_each_dim(Ptr &ptr, Strides const &strides, Offsets offsets) {
+                GT_FORCE_INLINE constexpr for_each_dim(Ptr &ptr, Strides const &strides, Offsets offsets) {
                     using array_t = int[sizeof...(Dims)];
-                    (void)array_t{
-                        (shift(ptr, get_stride<Dims>(strides), gridtools::host_device::at_key<Dims>(offsets)), 0)...};
+                    (void)array_t{(shift(ptr, get_stride<Dims>(strides), at_key<Dims>(offsets)), 0)...};
                 }
             };
 
             template <template <class...> class L>
             struct for_each_dim<L<>> {
                 template <class Ptr, class Strides, class Offsets>
-                GT_FUNCTION for_each_dim(Ptr &ptr, Strides const &strides, Offsets offsets) {}
+                GT_FORCE_INLINE constexpr for_each_dim(Ptr &ptr, Strides const &strides, Offsets offsets) {}
             };
 
             template <class Arg, class Dims>
@@ -44,20 +44,10 @@ namespace gridtools {
             template <class Arg, template <class...> class L, class... Dims>
             struct for_each_dim_a<Arg, L<Dims...>> {
                 template <class Ptr, class Strides, class Offsets>
-                GT_FUNCTION for_each_dim_a(Ptr &ptr, Strides const &strides, Offsets offsets) {
-                    using array_t = int[sizeof...(Dims)];
-                    (void)array_t{(
-                        shift(
-                            ptr, get_stride_element<Arg, Dims>(strides), gridtools::host_device::at_key<Dims>(offsets)),
-                        0)...};
+                GT_FORCE_INLINE constexpr for_each_dim_a(Ptr &ptr, Strides const &strides, Offsets offsets) {
+                    (..., shift(ptr, get_stride_element<Arg, Dims>(strides), at_key<Dims>(offsets)));
                 }
             };
-
-            template <class Arg, template <class...> class L>
-            struct for_each_dim_a<Arg, L<>> {
-                template <class Ptr, class Strides, class Offsets>
-                GT_FUNCTION for_each_dim_a(Ptr &ptr, Strides const &strides, Offsets offsets) {}
-            };
         } // namespace multi_shift_impl_
 
         /**
@@ -65,13 +55,13 @@ namespace gridtools {
          *   `offsets` should be a hymap of individual offsets.
          */
         template <class Ptr, class Strides, class Offsets>
-        GT_FUNCTION void multi_shift(Ptr &ptr, Strides const &strides, Offsets offsets) {
-            multi_shift_impl_::for_each_dim<get_keys<Offsets>>(ptr, strides, wstd::move(offsets));
+        GT_FORCE_INLINE constexpr void multi_shift(Ptr &ptr, Strides const &strides, Offsets offsets) {
+            multi_shift_impl_::for_each_dim<get_keys<Offsets>>(ptr, strides, std::move(offsets));
         }
 
         template <class Ptr, class Strides, class Offsets>
-        GT_FUNCTION Ptr multi_shifted(Ptr ptr, Strides const &strides, Offsets offsets) {
-            multi_shift(ptr, strides, wstd::move(offsets));
+        GT_FORCE_INLINE constexpr Ptr multi_shifted(Ptr ptr, Strides const &strides, Offsets offsets) {
+            multi_shift(ptr, strides, std::move(offsets));
             return ptr;
         }
 
@@ -79,13 +69,13 @@ namespace gridtools {
          *   Variation of multi_shift that works with the strides of composite sid.
          */
         template <class Arg, class Ptr, class Strides, class Offsets>
-        GT_FUNCTION void multi_shift(Ptr &ptr, Strides const &strides, Offsets offsets) {
-            multi_shift_impl_::for_each_dim_a<Arg, get_keys<Offsets>>(ptr, strides, wstd::move(offsets));
+        GT_FORCE_INLINE constexpr void multi_shift(Ptr &ptr, Strides const &strides, Offsets offsets) {
+            multi_shift_impl_::for_each_dim_a<Arg, get_keys<Offsets>>(ptr, strides, std::move(offsets));
         }
 
         template <class Arg, class Ptr, class Strides, class Offsets>
-        GT_FUNCTION Ptr multi_shifted(Ptr ptr, Strides const &strides, Offsets offsets) {
-            multi_shift<Arg>(ptr, strides, wstd::move(offsets));
+        GT_FORCE_INLINE constexpr Ptr multi_shifted(Ptr ptr, Strides const &strides, Offsets offsets) {
+            multi_shift<Arg>(ptr, strides, std::move(offsets));
             return ptr;
         }
     } // namespace sid
diff --git a/include/gridtools/sid/simple_ptr_holder.hpp b/include/gridtools/sid/simple_ptr_holder.hpp
index b07dabd7b7..db95f00996 100644
--- a/include/gridtools/sid/simple_ptr_holder.hpp
+++ b/include/gridtools/sid/simple_ptr_holder.hpp
@@ -7,48 +7,32 @@
  * Please, refer to the LICENSE file in the root directory.
  * SPDX-License-Identifier: BSD-3-Clause
  */
-#ifndef GT_TARGET_ITERATING
-// DON'T USE #pragma once HERE!!!
-#ifndef GT_SID_SIMPLE_PTR_HOLDER_HPP_
-#define GT_SID_SIMPLE_PTR_HOLDER_HPP_
+#pragma once
 
 #include <utility>
 
-#include "../common/defs.hpp"
 #include "../common/host_device.hpp"
 
-#define GT_FILENAME <gridtools/sid/simple_ptr_holder.hpp>
-#include GT_ITERATE_ON_TARGETS()
-#undef GT_FILENAME
-
-#endif
-#else
-
 namespace gridtools {
     namespace sid {
-        GT_TARGET_NAMESPACE {
-            template <class T>
-            struct simple_ptr_holder {
-                T m_val;
-                GT_TARGET GT_FORCE_INLINE GT_TARGET_CONSTEXPR T const &operator()() const { return m_val; }
-            };
+        template <class T>
+        struct simple_ptr_holder {
+            T m_val;
+            simple_ptr_holder() = default;
 
-            template <class T>
-            constexpr simple_ptr_holder<T> make_simple_ptr_holder(T const &ptr) {
-                return {ptr};
-            }
+            GT_FORCE_INLINE constexpr simple_ptr_holder(T const& val) : m_val(val) {}
 
-            template <class T, class Arg>
-            constexpr auto operator+(simple_ptr_holder<T> const &obj, Arg &&arg) {
-                return make_simple_ptr_holder(obj.m_val + std::forward<Arg>(arg));
-            }
+            GT_FORCE_INLINE constexpr T const &operator()() const { return m_val; }
+        };
 
-            template <class T, class Arg>
-            constexpr auto operator+(simple_ptr_holder<T> &&obj, Arg &&arg) {
-                return make_simple_ptr_holder(std::move(obj).m_val + std::forward<Arg>(arg));
-            }
+        template <class T, class Arg>
+        constexpr auto operator+(simple_ptr_holder<T> const &obj, Arg &&arg) {
+            return simple_ptr_holder(obj.m_val + std::forward<Arg>(arg));
+        }
+
+        template <class T, class Arg>
+        constexpr auto operator+(simple_ptr_holder<T> &&obj, Arg &&arg) {
+            return simple_ptr_holder(std::move(obj.m_val) + std::forward<Arg>(arg));
         }
     } // namespace sid
 } // namespace gridtools
-
-#endif
diff --git a/include/gridtools/stencil/be_api.hpp b/include/gridtools/stencil/be_api.hpp
index 2f90f9d64a..5201290b51 100644
--- a/include/gridtools/stencil/be_api.hpp
+++ b/include/gridtools/stencil/be_api.hpp
@@ -82,15 +82,15 @@ namespace gridtools {
                 using extent_t = Extent;
                 using cache_io_policies_t = meta::list<CacheIoPolicies...>;
 
-                static GT_FUNCTION key_t key() { return {}; }
-                static GT_FUNCTION plh_t plh() { return {}; }
-                static GT_FUNCTION caches_t caches() { return {}; }
-                static GT_FUNCTION is_tmp_t is_tmp() { return {}; }
+                static GT_FORCE_INLINE constexpr key_t key() { return {}; }
+                static GT_FORCE_INLINE constexpr plh_t plh() { return {}; }
+                static GT_FORCE_INLINE constexpr caches_t caches() { return {}; }
+                static GT_FORCE_INLINE constexpr is_tmp_t is_tmp() { return {}; }
                 static data_t data();
-                static GT_FUNCTION num_colors_t num_colors() { return {}; }
-                static GT_FUNCTION is_const_t is_const() { return {}; }
-                static GT_FUNCTION extent_t extent() { return {}; }
-                static GT_FUNCTION cache_io_policies_t cache_io_policies() { return {}; }
+                static GT_FORCE_INLINE constexpr num_colors_t num_colors() { return {}; }
+                static GT_FORCE_INLINE constexpr is_const_t is_const() { return {}; }
+                static GT_FORCE_INLINE constexpr extent_t extent() { return {}; }
+                static GT_FORCE_INLINE constexpr cache_io_policies_t cache_io_policies() { return {}; }
             };
 
             template <template <class...> class GetKey = get_plh, class PlhMap, class Fun>
@@ -180,23 +180,23 @@ namespace gridtools {
                 using plhs_t = meta::transform<get_plh, plh_map_t>;
                 using k_step_t = integral_constant<int_t, core::is_backward<Execution>::value ? -1 : 1>;
 
-                static GT_FUNCTION Funs funs() { return {}; }
-                static GT_FUNCTION Interval interval() { return {}; }
-                static GT_FUNCTION PlhMap plh_map() { return {}; }
-                static GT_FUNCTION Extent extent() { return {}; }
-                static GT_FUNCTION Execution execution() { return {}; }
-                static GT_FUNCTION NeedSync need_sync() { return {}; }
+                static GT_FORCE_INLINE constexpr Funs funs() { return {}; }
+                static GT_FORCE_INLINE constexpr Interval interval() { return {}; }
+                static GT_FORCE_INLINE constexpr PlhMap plh_map() { return {}; }
+                static GT_FORCE_INLINE constexpr Extent extent() { return {}; }
+                static GT_FORCE_INLINE constexpr Execution execution() { return {}; }
+                static GT_FORCE_INLINE constexpr NeedSync need_sync() { return {}; }
 
-                static GT_FUNCTION plhs_t plhs() { return {}; }
-                static GT_FUNCTION k_step_t k_step() { return {}; }
+                static GT_FORCE_INLINE constexpr plhs_t plhs() { return {}; }
+                static GT_FORCE_INLINE constexpr k_step_t k_step() { return {}; }
 
                 template <class Deref = void, class Ptr, class Strides>
                 GT_FUNCTION void operator()(Ptr const &ptr, Strides const &strides) const {
-                    host_device::for_each<Funs>(run_f<Deref, Ptr, Strides>{ptr, strides});
+                    for_each<Funs>(run_f<Deref, Ptr, Strides>{ptr, strides});
                 }
 
                 template <class Ptr, class Strides>
-                static GT_FUNCTION void inc_k(Ptr &ptr, Strides const &strides) {
+                static GT_FORCE_INLINE constexpr void inc_k(Ptr &ptr, Strides const &strides) {
                     sid::shift(ptr, sid::get_stride<dim::k>(strides), k_step());
                 }
             };
@@ -308,16 +308,16 @@ namespace gridtools {
 
                 using cells_t = meta::rename<tuple, meta::filter<meta::not_<is_cell_empty>::apply, interval_info>>;
 
-                static GT_FUNCTION execution_t execution() { return {}; }
-                static GT_FUNCTION extent_t extent() { return {}; }
-                static GT_FUNCTION plh_map_t plh_map() { return {}; }
-                static GT_FUNCTION plhs_t plhs() { return {}; }
-                static GT_FUNCTION interval_t interval() { return {}; }
-                static GT_FUNCTION k_step_t k_step() { return {}; }
-                static GT_FUNCTION cells_t cells() { return {}; }
+                static GT_FORCE_INLINE constexpr execution_t execution() { return {}; }
+                static GT_FORCE_INLINE constexpr extent_t extent() { return {}; }
+                static GT_FORCE_INLINE constexpr plh_map_t plh_map() { return {}; }
+                static GT_FORCE_INLINE constexpr plhs_t plhs() { return {}; }
+                static GT_FORCE_INLINE constexpr interval_t interval() { return {}; }
+                static GT_FORCE_INLINE constexpr k_step_t k_step() { return {}; }
+                static GT_FORCE_INLINE constexpr cells_t cells() { return {}; }
 
                 template <class Ptr, class Strides>
-                static GT_FUNCTION void inc_k(Ptr &ptr, Strides const &strides) {
+                static GT_FORCE_INLINE constexpr void inc_k(Ptr &ptr, Strides const &strides) {
                     sid::shift(ptr, sid::get_stride<dim::k>(strides), k_step());
                 }
             };
@@ -325,8 +325,8 @@ namespace gridtools {
             template <class... IntervalInfos>
             class fused_view_item {
                 static_assert(sizeof...(IntervalInfos) > 0, GT_INTERNAL_ERROR);
-                static_assert(std::conjunction<meta::is_instantiation_of<interval_info, IntervalInfos>...>::value,
-                    GT_INTERNAL_ERROR);
+                static_assert(
+                    std::conjunction_v<meta::is_instantiation_of<interval_info, IntervalInfos>...>, GT_INTERNAL_ERROR);
                 static_assert(meta::are_same<typename meta::length<IntervalInfos>::type...>::value, GT_INTERNAL_ERROR);
 
                 using item_t = meta::first<meta::list<IntervalInfos...>>;
@@ -344,14 +344,14 @@ namespace gridtools {
                     meta::reverse<meta::rename<tuple, fused_view_item>>,
                     meta::rename<tuple, fused_view_item>>;
 
-                static GT_FUNCTION execution_t execution() { return {}; }
-                static GT_FUNCTION extent_t extent() { return {}; }
-                static GT_FUNCTION plh_map_t plh_map() { return {}; }
-                static GT_FUNCTION plhs_t plhs() { return {}; }
-                static GT_FUNCTION interval_t interval() { return {}; }
-                static GT_FUNCTION k_step_t k_step() { return {}; }
+                static GT_FORCE_INLINE constexpr execution_t execution() { return {}; }
+                static GT_FORCE_INLINE constexpr extent_t extent() { return {}; }
+                static GT_FORCE_INLINE constexpr plh_map_t plh_map() { return {}; }
+                static GT_FORCE_INLINE constexpr plhs_t plhs() { return {}; }
+                static GT_FORCE_INLINE constexpr interval_t interval() { return {}; }
+                static GT_FORCE_INLINE constexpr k_step_t k_step() { return {}; }
 
-                static GT_FUNCTION interval_infos_t interval_infos() { return {}; }
+                static GT_FORCE_INLINE constexpr interval_infos_t interval_infos() { return {}; }
             };
 
             template <class... Cells>
@@ -371,14 +371,14 @@ namespace gridtools {
                     meta::reverse<meta::rename<tuple, split_view_item>>,
                     meta::rename<tuple, split_view_item>>;
 
-                static GT_FUNCTION execution_t execution() { return {}; }
-                static GT_FUNCTION extent_t extent() { return {}; }
-                static GT_FUNCTION plh_map_t plh_map() { return {}; }
-                static GT_FUNCTION plhs_t plhs() { return {}; }
-                static GT_FUNCTION interval_t interval() { return {}; }
-                static GT_FUNCTION k_step_t k_step() { return {}; }
+                static GT_FORCE_INLINE constexpr execution_t execution() { return {}; }
+                static GT_FORCE_INLINE constexpr extent_t extent() { return {}; }
+                static GT_FORCE_INLINE constexpr plh_map_t plh_map() { return {}; }
+                static GT_FORCE_INLINE constexpr plhs_t plhs() { return {}; }
+                static GT_FORCE_INLINE constexpr interval_t interval() { return {}; }
+                static GT_FORCE_INLINE constexpr k_step_t k_step() { return {}; }
 
-                static GT_FUNCTION cells_t cells() { return {}; }
+                static GT_FORCE_INLINE constexpr cells_t cells() { return {}; }
             };
 
             template <class... Items>
@@ -392,8 +392,8 @@ namespace gridtools {
 
                 using interval_t = core::enclosing_interval<typename Items::interval_t...>;
 
-                static GT_FUNCTION tmp_plh_map_t tmp_plh_map() { return {}; }
-                static GT_FUNCTION interval_t interval() { return {}; }
+                static GT_FORCE_INLINE constexpr tmp_plh_map_t tmp_plh_map() { return {}; }
+                static GT_FORCE_INLINE constexpr interval_t interval() { return {}; }
             };
 
             template <class Matrix>
diff --git a/include/gridtools/stencil/common/extent.hpp b/include/gridtools/stencil/common/extent.hpp
index dd179c86ae..cf9f9cefe6 100644
--- a/include/gridtools/stencil/common/extent.hpp
+++ b/include/gridtools/stencil/common/extent.hpp
@@ -36,16 +36,16 @@ namespace gridtools {
             using kminus = integral_constant<int_t, KMinus>;
             using kplus = integral_constant<int_t, KPlus>;
 
-            static GT_FUNCTION iminus minus(dim::i) { return {}; }
-            static GT_FUNCTION jminus minus(dim::j) { return {}; }
-            static GT_FUNCTION kminus minus(dim::k) { return {}; }
+            static GT_FORCE_INLINE constexpr iminus minus(dim::i) { return {}; }
+            static GT_FORCE_INLINE constexpr jminus minus(dim::j) { return {}; }
+            static GT_FORCE_INLINE constexpr kminus minus(dim::k) { return {}; }
 
-            static GT_FUNCTION iplus plus(dim::i) { return {}; }
-            static GT_FUNCTION jplus plus(dim::j) { return {}; }
-            static GT_FUNCTION kplus plus(dim::k) { return {}; }
+            static GT_FORCE_INLINE constexpr iplus plus(dim::i) { return {}; }
+            static GT_FORCE_INLINE constexpr jplus plus(dim::j) { return {}; }
+            static GT_FORCE_INLINE constexpr kplus plus(dim::k) { return {}; }
 
             template <class Dim, class Size>
-            static GT_FUNCTION auto extend(Dim dim, Size size) {
+            static GT_FORCE_INLINE constexpr auto extend(Dim dim, Size size) {
                 return size - minus(dim) + plus(dim);
             }
         };
diff --git a/include/gridtools/stencil/common/intent.hpp b/include/gridtools/stencil/common/intent.hpp
index c1cb329ead..2a5ee5b0a7 100644
--- a/include/gridtools/stencil/common/intent.hpp
+++ b/include/gridtools/stencil/common/intent.hpp
@@ -43,7 +43,7 @@ namespace gridtools {
         using apply_intent_t = typename apply_intent_type<Intent, T>::type;
 
         template <intent Intent, class T, class Res = typename apply_intent_type<Intent, T>::type>
-        GT_FUNCTION Res apply_intent(T &&obj) {
+        GT_FORCE_INLINE constexpr Res apply_intent(T &&obj) {
             return static_cast<Res>(obj);
         }
     } // namespace stencil
diff --git a/include/gridtools/stencil/core/functor_metafunctions.hpp b/include/gridtools/stencil/core/functor_metafunctions.hpp
index 9452cd9cee..b64fa56966 100644
--- a/include/gridtools/stencil/core/functor_metafunctions.hpp
+++ b/include/gridtools/stencil/core/functor_metafunctions.hpp
@@ -10,9 +10,9 @@
 #pragma once
 
 #include <type_traits>
+#include <utility>
 
 #include "../../common/host_device.hpp"
-#include "../../common/utility.hpp"
 #include "../../meta.hpp"
 #include "interval.hpp"
 #include "level.hpp"
@@ -215,7 +215,7 @@ namespace gridtools {
                 struct bound_functor : Functor {
                     template <class Eval>
                     static GT_FUNCTION void apply(Eval &&eval) {
-                        Functor::apply(wstd::forward<Eval>(eval), Param());
+                        Functor::apply(std::forward<Eval>(eval), Param());
                     }
                 };
 
diff --git a/include/gridtools/stencil/cpu_kfirst.hpp b/include/gridtools/stencil/cpu_kfirst.hpp
index 0a743a5542..0f1d9e4658 100644
--- a/include/gridtools/stencil/cpu_kfirst.hpp
+++ b/include/gridtools/stencil/cpu_kfirst.hpp
@@ -97,7 +97,7 @@ namespace gridtools {
                 DataStores external_data_stores) {
                 using stages_t = be_api::make_split_view<Spec>;
 
-                auto alloc = sid::make_cached_allocator(&std::make_unique<char[]>);
+                auto alloc = sid::cached_allocator(&std::make_unique<char[]>);
 
                 using tmp_plh_map_t = be_api::remove_caches_from_plh_map<typename stages_t::tmp_plh_map_t>;
                 auto temporaries = be_api::make_data_stores(tmp_plh_map_t(), [&grid, &alloc](auto info) {
diff --git a/include/gridtools/stencil/frontend/cartesian/accessor.hpp b/include/gridtools/stencil/frontend/cartesian/accessor.hpp
index a3f50eba47..f40a2fd3a0 100644
--- a/include/gridtools/stencil/frontend/cartesian/accessor.hpp
+++ b/include/gridtools/stencil/frontend/cartesian/accessor.hpp
@@ -45,17 +45,17 @@ namespace gridtools {
         namespace cartesian {
             namespace accessor_impl_ {
                 template <size_t I>
-                GT_FUNCTION GT_CONSTEXPR int_t pick_dimension() {
+                GT_FORCE_INLINE constexpr int_t pick_dimension() {
                     return 0;
                 }
 
                 template <size_t I, class... Ts>
-                GT_FUNCTION GT_CONSTEXPR int_t pick_dimension(dimension<I> src, Ts &&...) {
+                GT_FORCE_INLINE constexpr int_t pick_dimension(dimension<I> src, Ts &&...) {
                     return src.value;
                 }
 
                 template <size_t I, size_t J, class... Ts, std::enable_if_t<I != J, int> = 0>
-                GT_FUNCTION GT_CONSTEXPR int_t pick_dimension(dimension<J> src, Ts... srcs) {
+                GT_FORCE_INLINE constexpr int_t pick_dimension(dimension<J> src, Ts... srcs) {
                     return pick_dimension<I>(srcs...);
                 }
 
@@ -68,12 +68,12 @@ namespace gridtools {
                 using are_ints = std::conjunction<std::is_convertible<Ts, int_t>...>;
 
                 template <size_t Dim, size_t I, std::enable_if_t<(I > Dim), int> = 0>
-                GT_FUNCTION GT_CONSTEXPR int_t out_of_range_dim(dimension<I> obj) {
+                GT_FORCE_INLINE constexpr int_t out_of_range_dim(dimension<I> obj) {
                     return obj.value;
                 }
 
                 template <size_t Dim, size_t I, std::enable_if_t<(I <= Dim), int> = 0>
-                GT_FUNCTION GT_CONSTEXPR int_t out_of_range_dim(dimension<I>) {
+                GT_FORCE_INLINE constexpr int_t out_of_range_dim(dimension<I>) {
                     return 0;
                 }
 
@@ -95,26 +95,20 @@ namespace gridtools {
                 template <int_t IMinus, int_t IPlus, int_t JMinus, int_t JPlus, int_t KMinus, int_t KPlus>
                 struct minimal_requried_args<extent<IMinus, IPlus, JMinus, JPlus, KMinus, KPlus>>
                     : std::integral_constant<size_t,
-                          (KMinus > 0 || KPlus < 0 ? 3
-                                                   : JMinus > 0 || JPlus < 0 ? 2 : IMinus > 0 || IPlus < 0 ? 1 : 0)> {};
+                          (KMinus > 0 || KPlus < 0      ? 3
+                              : JMinus > 0 || JPlus < 0 ? 2
+                              : IMinus > 0 || IPlus < 0 ? 1
+                                                        : 0)> {};
 
 #ifndef NDEBUG
                 template <class Extent, size_t Dim>
-                GT_FUNCTION GT_CONSTEXPR bool check_offsets(array<int_t, Dim> const &offsets) {
+                constexpr bool check_offsets(array<int_t, Dim> const &offsets) {
                     int_t i = Dim > 0 ? offsets[0] : 0;
                     int_t j = Dim > 1 ? offsets[1] : 0;
                     int_t k = Dim > 2 ? offsets[2] : 0;
                     return i >= Extent::iminus::value && i <= Extent::iplus::value && j >= Extent::jminus::value &&
                            j <= Extent::jplus::value && k >= Extent::kminus::value && k <= Extent::kplus::value;
                 }
-
-                template <class... Ts>
-                GT_FUNCTION GT_CONSTEXPR bool all(Ts... args) {
-                    bool res = true;
-                    for (bool ok : (bool[]){args...})
-                        res = res && ok;
-                    return res;
-                }
 #endif
             } // namespace accessor_impl_
 
@@ -137,26 +131,26 @@ namespace gridtools {
                 template <class... Ts,
                     std::enable_if_t<sizeof...(Ts) < Dim && std::conjunction<std::is_convertible<Ts, int_t>...>::value,
                         int> = 0>
-                GT_FUNCTION GT_CONSTEXPR accessor(Ts... offsets) : base_t({offsets...}) {
+                GT_FORCE_INLINE constexpr accessor(Ts... offsets) : base_t({offsets...}) {
                     static_assert(sizeof...(Ts) >= accessor_impl_::minimal_requried_args<Extent>::value,
                         "zero offsets is out of the extents range");
                     assert(accessor_impl_::check_offsets<Extent>(*this));
                 }
 
                 template <class... Ts, std::enable_if_t<accessor_impl_::are_ints<Ts...>::value, int> = 0>
-                GT_FUNCTION GT_CONSTEXPR accessor(typename accessor_impl_::just_int<Is>::type... offsets, Ts... zeros)
+                GT_FORCE_INLINE constexpr accessor(typename accessor_impl_::just_int<Is>::type... offsets, Ts... zeros)
                     : base_t({offsets...}) {
-                    assert(accessor_impl_::all((zeros == 0)...));
+                    assert((true && ... && (zeros == 0)));
                     assert(accessor_impl_::check_offsets<Extent>(*this));
                 }
 
                 template <size_t J, size_t... Js>
-                GT_FUNCTION GT_CONSTEXPR accessor(dimension<J> src, dimension<Js>... srcs)
+                GT_FORCE_INLINE constexpr accessor(dimension<J> src, dimension<Js>... srcs)
                     : base_t({accessor_impl_::pick_dimension<Is + 1>(src, srcs...)...}) {
                     static_assert(meta::is_set_fast<meta::list<dimension<J>, dimension<Js>...>>::value,
                         "all dimensions should be of different indicies");
                     assert(accessor_impl_::out_of_range_dim<Dim>(src) == 0);
-                    assert(accessor_impl_::all((accessor_impl_::out_of_range_dim<Dim>(srcs) == 0)...));
+                    assert((true && ... && (accessor_impl_::out_of_range_dim<Dim>(srcs) == 0)));
                     assert(accessor_impl_::check_offsets<Extent>(*this));
                 }
             };
@@ -164,7 +158,7 @@ namespace gridtools {
             template <uint_t Id, class Extent, intent Intent>
             class accessor<Id, Intent, Extent, 0, std::index_sequence<>> : public tuple<> {
               public:
-                static_assert(std::is_same<Extent, extent<>>::value, GT_INTERNAL_ERROR);
+                static_assert(std::is_same_v<Extent, extent<>>, GT_INTERNAL_ERROR);
 
                 using index_t = integral_constant<uint_t, Id>;
                 static constexpr intent intent_v = Intent;
@@ -173,14 +167,13 @@ namespace gridtools {
                 accessor() = default;
 
                 template <class... Ts, std::enable_if_t<accessor_impl_::are_ints<Ts...>::value, int> = 0>
-                GT_FUNCTION GT_CONSTEXPR accessor(Ts... zeros) {
-                    assert(accessor_impl_::all((zeros == 0)...));
+                GT_FORCE_INLINE constexpr accessor(Ts... zeros) {
+                    assert((true && ... && (zeros == 0)));
                 }
 
                 template <size_t J, size_t... Js>
-                GT_FUNCTION GT_CONSTEXPR accessor(dimension<J> zero, dimension<Js>... zeros) {
-                    assert(zero.value == 0);
-                    assert(accessor_impl_::all((zeros.value == 0)...));
+                GT_FORCE_INLINE constexpr accessor(dimension<J> zero, dimension<Js>... zeros) {
+                    assert(((zero.value == 0) && ... && (zeros.value == 0)));
                 }
             };
 
diff --git a/include/gridtools/stencil/frontend/cartesian/dimension.hpp b/include/gridtools/stencil/frontend/cartesian/dimension.hpp
index f1a7caef95..ddb91beb05 100644
--- a/include/gridtools/stencil/frontend/cartesian/dimension.hpp
+++ b/include/gridtools/stencil/frontend/cartesian/dimension.hpp
@@ -26,11 +26,11 @@ namespace gridtools {
             struct dimension {
                 static_assert(Coordinate != 0, "The coordinate values passed to the accessor start from 1");
 
-                GT_FUNCTION constexpr dimension(int_t value = 0) : value(value) {}
+                GT_FORCE_INLINE constexpr dimension(int_t value = 0) : value(value) {}
                 int_t value;
 
-                friend GT_FUNCTION GT_CONSTEXPR dimension operator+(dimension, int_t offset) { return {offset}; }
-                friend GT_FUNCTION GT_CONSTEXPR dimension operator-(dimension, int_t offset) { return {-offset}; }
+                friend GT_FORCE_INLINE constexpr dimension operator+(dimension, int_t offset) { return {offset}; }
+                friend GT_FORCE_INLINE constexpr dimension operator-(dimension, int_t offset) { return {-offset}; }
             };
         } // namespace cartesian
     }     // namespace stencil
diff --git a/include/gridtools/stencil/frontend/cartesian/expressions/expr_base.hpp b/include/gridtools/stencil/frontend/cartesian/expressions/expr_base.hpp
index b24ddd0183..6ab53c2302 100644
--- a/include/gridtools/stencil/frontend/cartesian/expressions/expr_base.hpp
+++ b/include/gridtools/stencil/frontend/cartesian/expressions/expr_base.hpp
@@ -10,9 +10,9 @@
 #pragma once
 
 #include <type_traits>
+#include <utility>
 
 #include "../../../../common/host_device.hpp"
-#include "../../../../common/utility.hpp"
 #include "../../../../meta.hpp"
 #include "../accessor.hpp"
 
@@ -50,29 +50,29 @@ namespace gridtools {
                 template <class Op,
                     class... Args,
                     std::enable_if_t<std::disjunction<expr_or_accessor<Args>...>::value, int> = 0>
-                GT_FUNCTION GT_CONSTEXPR expr<Op, Args...> make_expr(Op, Args... args) {
+                GT_FORCE_INLINE constexpr expr<Op, Args...> make_expr(Op, Args... args) {
                     return {args...};
                 }
 
                 namespace evaluation {
                     template <class Eval, class Arg, std::enable_if_t<std::is_arithmetic<Arg>::value, int> = 0>
-                    GT_FUNCTION GT_CONSTEXPR Arg apply_eval(Eval &&, Arg arg) {
+                    GT_FORCE_INLINE constexpr Arg apply_eval(Eval &&, Arg arg) {
                         return arg;
                     }
 
                     template <class Eval, class Arg, std::enable_if_t<!std::is_arithmetic<Arg>::value, int> = 0>
-                    GT_FUNCTION GT_CONSTEXPR decltype(auto) apply_eval(Eval &&eval, Arg arg) {
-                        return wstd::forward<Eval>(eval)(wstd::move(arg));
+                    GT_FORCE_INLINE constexpr decltype(auto) apply_eval(Eval &&eval, Arg arg) {
+                        return std::forward<Eval>(eval)(std::move(arg));
                     }
 
                     template <class Eval, class Op, class Arg>
-                    GT_FUNCTION GT_CONSTEXPR auto value(Eval &&eval, expr<Op, Arg> arg) {
-                        return Op()(wstd::forward<Eval>(eval)(wstd::move(arg.m_arg)));
+                    GT_FORCE_INLINE constexpr auto value(Eval &&eval, expr<Op, Arg> arg) {
+                        return Op()(std::forward<Eval>(eval)(std::move(arg.m_arg)));
                     }
 
                     template <class Eval, class Op, class Lhs, class Rhs>
-                    GT_FUNCTION GT_CONSTEXPR auto value(Eval &&eval, expr<Op, Lhs, Rhs> arg) {
-                        return Op()(apply_eval(eval, wstd::move(arg.m_lhs)), apply_eval(eval, wstd::move(arg.m_rhs)));
+                    GT_FORCE_INLINE constexpr auto value(Eval &&eval, expr<Op, Lhs, Rhs> arg) {
+                        return Op()(apply_eval(eval, std::move(arg.m_lhs)), apply_eval(eval, std::move(arg.m_rhs)));
                     }
                 } // namespace evaluation
             }     // namespace expressions
diff --git a/include/gridtools/stencil/frontend/cartesian/expressions/expr_divide.hpp b/include/gridtools/stencil/frontend/cartesian/expressions/expr_divide.hpp
index 0ed5b43aa7..abde9f88ae 100644
--- a/include/gridtools/stencil/frontend/cartesian/expressions/expr_divide.hpp
+++ b/include/gridtools/stencil/frontend/cartesian/expressions/expr_divide.hpp
@@ -19,13 +19,13 @@ namespace gridtools {
             namespace expressions {
                 struct divide_f {
                     template <class Lhs, class Rhs>
-                    GT_FUNCTION GT_CONSTEXPR auto operator()(Lhs const &lhs, Rhs const &rhs) const {
+                    GT_FORCE_INLINE constexpr auto operator()(Lhs const &lhs, Rhs const &rhs) const {
                         return lhs / rhs;
                     }
                 };
 
                 template <class Lhs, class Rhs>
-                GT_FUNCTION GT_CONSTEXPR auto operator/(Lhs lhs, Rhs rhs)
+                GT_FORCE_INLINE constexpr auto operator/(Lhs lhs, Rhs rhs)
                     -> decltype(make_expr(divide_f(), Lhs(), Rhs())) {
                     return make_expr(divide_f(), lhs, rhs);
                 }
diff --git a/include/gridtools/stencil/frontend/cartesian/expressions/expr_minus.hpp b/include/gridtools/stencil/frontend/cartesian/expressions/expr_minus.hpp
index 0f42d291db..d39dae49d8 100644
--- a/include/gridtools/stencil/frontend/cartesian/expressions/expr_minus.hpp
+++ b/include/gridtools/stencil/frontend/cartesian/expressions/expr_minus.hpp
@@ -18,23 +18,23 @@ namespace gridtools {
             namespace expressions {
                 struct minus_f {
                     template <class Lhs, class Rhs>
-                    GT_FUNCTION GT_CONSTEXPR auto operator()(Lhs const &lhs, Rhs const &rhs) const {
+                    GT_FORCE_INLINE constexpr auto operator()(Lhs const &lhs, Rhs const &rhs) const {
                         return lhs - rhs;
                     }
                     template <class Arg>
-                    GT_FUNCTION GT_CONSTEXPR auto operator()(Arg const &arg) const {
+                    GT_FORCE_INLINE constexpr auto operator()(Arg const &arg) const {
                         return -arg;
                     }
                 };
 
                 template <class Lhs, class Rhs>
-                GT_FUNCTION GT_CONSTEXPR auto operator-(Lhs lhs, Rhs rhs)
+                GT_FORCE_INLINE constexpr auto operator-(Lhs lhs, Rhs rhs)
                     -> decltype(make_expr(minus_f(), Lhs(), Rhs())) {
                     return make_expr(minus_f(), lhs, rhs);
                 }
 
                 template <class Arg>
-                GT_FUNCTION GT_CONSTEXPR auto operator-(Arg arg) -> decltype(make_expr(minus_f(), Arg())) {
+                GT_FORCE_INLINE constexpr auto operator-(Arg arg) -> decltype(make_expr(minus_f(), Arg())) {
                     return make_expr(minus_f(), arg);
                 }
             } // namespace expressions
diff --git a/include/gridtools/stencil/frontend/cartesian/expressions/expr_plus.hpp b/include/gridtools/stencil/frontend/cartesian/expressions/expr_plus.hpp
index 240adccca2..e372cf9a97 100644
--- a/include/gridtools/stencil/frontend/cartesian/expressions/expr_plus.hpp
+++ b/include/gridtools/stencil/frontend/cartesian/expressions/expr_plus.hpp
@@ -19,23 +19,23 @@ namespace gridtools {
             namespace expressions {
                 struct plus_f {
                     template <class Lhs, class Rhs>
-                    GT_FUNCTION GT_CONSTEXPR auto operator()(Lhs const &lhs, Rhs const &rhs) const {
+                    GT_FORCE_INLINE constexpr auto operator()(Lhs const &lhs, Rhs const &rhs) const {
                         return lhs + rhs;
                     }
                     template <class Arg>
-                    GT_FUNCTION GT_CONSTEXPR auto operator()(Arg const &arg) const {
+                    GT_FORCE_INLINE constexpr auto operator()(Arg const &arg) const {
                         return +arg;
                     }
                 };
 
                 template <class Lhs, class Rhs>
-                GT_FUNCTION GT_CONSTEXPR auto operator+(Lhs lhs, Rhs rhs)
+                GT_FORCE_INLINE constexpr auto operator+(Lhs lhs, Rhs rhs)
                     -> decltype(make_expr(plus_f(), Lhs(), Rhs())) {
                     return make_expr(plus_f(), lhs, rhs);
                 }
 
                 template <class Arg>
-                GT_FUNCTION GT_CONSTEXPR auto operator+(Arg arg) -> decltype(make_expr(plus_f(), Arg())) {
+                GT_FORCE_INLINE constexpr auto operator+(Arg arg) -> decltype(make_expr(plus_f(), Arg())) {
                     return make_expr(plus_f(), arg);
                 }
             } // namespace expressions
diff --git a/include/gridtools/stencil/frontend/cartesian/expressions/expr_pow.hpp b/include/gridtools/stencil/frontend/cartesian/expressions/expr_pow.hpp
index e98f481d8c..77c593410c 100644
--- a/include/gridtools/stencil/frontend/cartesian/expressions/expr_pow.hpp
+++ b/include/gridtools/stencil/frontend/cartesian/expressions/expr_pow.hpp
@@ -20,13 +20,13 @@ namespace gridtools {
                 template <int I>
                 struct pow_f {
                     template <class Arg>
-                    GT_FUNCTION GT_CONSTEXPR auto operator()(Arg const &arg) const {
+                    GT_FORCE_INLINE constexpr auto operator()(Arg const &arg) const {
                         return gt_pow<I>::template apply(arg);
                     }
                 };
 
                 template <int I, class Arg>
-                GT_FUNCTION GT_CONSTEXPR auto pow(Arg arg) -> decltype(make_expr(pow_f<I>(), Arg())) {
+                GT_FORCE_INLINE constexpr auto pow(Arg arg) -> decltype(make_expr(pow_f<I>(), Arg())) {
                     return make_expr(pow_f<I>(), arg);
                 }
             } // namespace expressions
diff --git a/include/gridtools/stencil/frontend/cartesian/expressions/expr_times.hpp b/include/gridtools/stencil/frontend/cartesian/expressions/expr_times.hpp
index d5847c2b9c..9a43314b9d 100644
--- a/include/gridtools/stencil/frontend/cartesian/expressions/expr_times.hpp
+++ b/include/gridtools/stencil/frontend/cartesian/expressions/expr_times.hpp
@@ -19,13 +19,13 @@ namespace gridtools {
             namespace expressions {
                 struct times_f {
                     template <class Lhs, class Rhs>
-                    GT_FUNCTION GT_CONSTEXPR auto operator()(Lhs const &lhs, Rhs const &rhs) const {
+                    GT_FORCE_INLINE constexpr auto operator()(Lhs const &lhs, Rhs const &rhs) const {
                         return lhs * rhs;
                     }
                 };
 
                 template <class Lhs, class Rhs>
-                GT_FUNCTION GT_CONSTEXPR auto operator*(Lhs lhs, Rhs rhs) -> decltype(make_expr(times_f(), lhs, rhs)) {
+                GT_FORCE_INLINE constexpr auto operator*(Lhs lhs, Rhs rhs) -> decltype(make_expr(times_f(), lhs, rhs)) {
                     return make_expr(times_f(), lhs, rhs);
                 }
             } // namespace expressions
diff --git a/include/gridtools/stencil/frontend/cartesian/stage.hpp b/include/gridtools/stencil/frontend/cartesian/stage.hpp
index 84a84581f5..c1d1d31712 100644
--- a/include/gridtools/stencil/frontend/cartesian/stage.hpp
+++ b/include/gridtools/stencil/frontend/cartesian/stage.hpp
@@ -29,6 +29,7 @@
 #pragma once
 
 #include <type_traits>
+#include <utility>
 
 #include "../../../common/defs.hpp"
 #include "../../../common/host_device.hpp"
@@ -44,7 +45,7 @@ namespace gridtools {
             namespace stage_impl_ {
                 struct default_deref_f {
                     template <class Key, class T>
-                    GT_FUNCTION decltype(auto) operator()(Key, T ptr) const {
+                    GT_FORCE_INLINE constexpr decltype(auto) operator()(Key, T ptr) const {
                         return *ptr;
                     }
                 };
@@ -55,15 +56,15 @@ namespace gridtools {
                     Strides const &m_strides;
 
                     template <class Accessor>
-                    GT_FUNCTION decltype(auto) operator()(Accessor acc) const {
+                    GT_FORCE_INLINE constexpr decltype(auto) operator()(Accessor acc) const {
                         using key_t = meta::at_c<Keys, Accessor::index_t::value>;
-                        return apply_intent<Accessor::intent_v>(Deref()(key_t(),
-                            sid::multi_shifted<key_t>(host_device::at_key<key_t>(m_ptr), m_strides, wstd::move(acc))));
+                        return apply_intent<Accessor::intent_v>(Deref()(
+                            key_t(), sid::multi_shifted<key_t>(at_key<key_t>(m_ptr), m_strides, std::move(acc))));
                     }
 
                     template <class Op, class... Ts>
-                    GT_FUNCTION auto operator()(expr<Op, Ts...> arg) const {
-                        return expressions::evaluation::value(*this, wstd::move(arg));
+                    GT_FORCE_INLINE constexpr auto operator()(expr<Op, Ts...> arg) const {
+                        return expressions::evaluation::value(*this, std::move(arg));
                     }
                 };
 
diff --git a/include/gridtools/stencil/frontend/cartesian/stencil_functions.hpp b/include/gridtools/stencil/frontend/cartesian/stencil_functions.hpp
index 7ea2bcb74f..82ab95329f 100644
--- a/include/gridtools/stencil/frontend/cartesian/stencil_functions.hpp
+++ b/include/gridtools/stencil/frontend/cartesian/stencil_functions.hpp
@@ -11,6 +11,7 @@
 #pragma once
 
 #include <type_traits>
+#include <utility>
 
 #include "../../../common/hymap.hpp"
 #include "../../../common/tuple.hpp"
@@ -39,24 +40,23 @@ namespace gridtools {
                 template <class Key>
                 struct sum_offset_generator_f {
 
-                    using default_t = integral_constant<int_t, 0>;
+                    using default_t = integral_constant<int, 0>;
 
                     template <class Lhs, class Rhs>
-                    GT_FUNCTION auto operator()(Lhs &&lhs, Rhs &&rhs) const {
-                        return host_device::at_key_with_default<Key, default_t>(wstd::forward<Lhs>(lhs)) +
-                               host_device::at_key_with_default<Key, default_t>(wstd::forward<Rhs>(rhs));
+                    GT_FORCE_INLINE constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const {
+                        return at_key_with_default<Key, default_t>(std::forward<Lhs>(lhs)) +
+                               at_key_with_default<Key, default_t>(std::forward<Rhs>(rhs));
                     }
                 };
 
                 template <class Res, class Lhs, class Rhs>
-                GT_FUNCTION Res sum_offsets(Lhs &&lhs, Rhs rhs) {
+                GT_FORCE_INLINE constexpr Res sum_offsets(Lhs &&lhs, Rhs rhs) {
                     using generators_t = meta::transform<sum_offset_generator_f, get_keys<Res>>;
-                    return tuple_util::host_device::generate<generators_t, Res>(
-                        wstd::forward<Lhs>(lhs), wstd::move(rhs));
+                    return tuple_util::generate<generators_t, Res>(std::forward<Lhs>(lhs), std::move(rhs));
                 }
 
                 template <int_t I, int_t J, int_t K, class Accessor>
-                GT_FUNCTION std::enable_if_t<I == 0 && J == 0 && K == 0, Accessor> get_offsets(Accessor acc) {
+                GT_FORCE_INLINE constexpr std::enable_if_t<I == 0 && J == 0 && K == 0, Accessor> get_offsets(Accessor acc) {
                     return acc;
                 }
 
@@ -65,10 +65,10 @@ namespace gridtools {
                     int_t K,
                     class Accessor,
                     class Res = array<int_t, tuple_util::size<Accessor>::value>>
-                GT_FUNCTION std::enable_if_t<I != 0 || J != 0 || K != 0, Res> get_offsets(Accessor acc) {
+                GT_FORCE_INLINE constexpr std::enable_if_t<I != 0 || J != 0 || K != 0, Res> get_offsets(Accessor acc) {
                     using offset_t = hymap::keys<dim::i, dim::j, dim::k>::
                         values<integral_constant<int_t, I>, integral_constant<int_t, J>, integral_constant<int_t, K>>;
-                    return sum_offsets<Res>(wstd::move(acc), offset_t());
+                    return sum_offsets<Res>(std::move(acc), offset_t());
                 }
 
                 template <int_t I, int_t J, int_t K, class Params, class Eval, class Args>
@@ -82,10 +82,9 @@ namespace gridtools {
                         std::enable_if_t<is_accessor<Accessor>::value && is_accessor<Arg>::value &&
                                              !(Param::intent_v == intent::inout && Arg::intent_v == intent::in),
                             int> = 0>
-                    GT_FUNCTION decltype(auto) operator()(Accessor acc) const {
+                    GT_FORCE_INLINE constexpr decltype(auto) operator()(Accessor acc) const {
                         return m_eval(sum_offsets<Arg>(
-                            get_offsets<I, J, K>(tuple_util::host_device::get<Accessor::index_t::value>(m_args)),
-                            std::move(acc)));
+                            get_offsets<I, J, K>(tuple_util::get<Accessor::index_t::value>(m_args)), std::move(acc)));
                     }
 
                     template <class Accessor,
@@ -95,25 +94,25 @@ namespace gridtools {
                                              !(Param::intent_v == intent::inout &&
                                                  std::is_const<std::remove_reference_t<Arg>>::value),
                             int> = 0>
-                    GT_FUNCTION decltype(auto) operator()(Accessor) const {
-                        return tuple_util::host_device::get<Accessor::index_t::value>(m_args);
+                    GT_FORCE_INLINE constexpr decltype(auto) operator()(Accessor) const {
+                        return tuple_util::get<Accessor::index_t::value>(m_args);
                     }
 
                     template <class Op, class... Ts>
-                    GT_FUNCTION auto operator()(expr<Op, Ts...> arg) const {
-                        return expressions::evaluation::value(*this, wstd::move(arg));
+                    GT_FORCE_INLINE constexpr auto operator()(expr<Op, Ts...> arg) const {
+                        return expressions::evaluation::value(*this, std::move(arg));
                     }
                 };
 
                 template <int_t I, int_t J, int_t K, class Params, class Eval, class Args>
-                GT_CONSTEXPR GT_FUNCTION evaluator<I, J, K, Params, Eval, Args> make_evaluator(Eval &eval, Args args) {
-                    return {eval, wstd::move(args)};
+                GT_FORCE_INLINE constexpr evaluator<I, J, K, Params, Eval, Args> make_evaluator(Eval &eval, Args args) {
+                    return {eval, std::move(args)};
                 }
 
                 template <class Functor, class Region, int_t I, int_t J, int_t K, class Eval, class Args>
                 GT_FUNCTION void evaluate_bound_functor(Eval &eval, Args args) {
                     call_functor<Functor, Region>(
-                        make_evaluator<I, J, K, typename Functor::param_list>(eval, wstd::move(args)));
+                        make_evaluator<I, J, K, typename Functor::param_list>(eval, std::move(args)));
                 }
 
                 template <class Eval, class Arg, bool = is_accessor<Arg>::value>
@@ -189,11 +188,10 @@ namespace gridtools {
                     class Res =
                         typename call_interfaces_impl_::get_result_type<Eval, ReturnType, std::decay_t<Args>...>::type,
                     std::enable_if_t<sizeof...(Args) + 1 == meta::length<params_t>::value, int> = 0>
-                GT_FUNCTION static Res with(Eval &eval, Args &&... args) {
+                GT_FUNCTION static Res with(Eval &eval, Args &&...args) {
                     Res res;
-                    call_interfaces_impl_::evaluate_bound_functor<Functor, Region, OffI, OffJ, OffK>(eval,
-                        tuple_util::host_device::insert<out_param_index>(
-                            res, tuple<Args &&...>{wstd::forward<Args>(args)...}));
+                    call_interfaces_impl_::evaluate_bound_functor<Functor, Region, OffI, OffJ, OffK>(
+                        eval, tuple_util::insert<out_param_index>(res, tuple<Args &&...>{std::forward<Args>(args)...}));
                     return res;
                 }
             };
@@ -235,9 +233,9 @@ namespace gridtools {
                 template <class Eval, class... Args>
                 GT_FUNCTION static std::enable_if_t<sizeof...(Args) ==
                                                     meta::length<typename Functor::param_list>::value>
-                with(Eval &eval, Args &&... args) {
+                with(Eval &eval, Args &&...args) {
                     call_interfaces_impl_::evaluate_bound_functor<Functor, Region, OffI, OffJ, OffK>(
-                        eval, tuple<Args &&...>{wstd::forward<Args>(args)...});
+                        eval, tuple<Args &&...>{std::forward<Args>(args)...});
                 }
             };
         } // namespace cartesian
diff --git a/include/gridtools/stencil/frontend/cartesian/tmp_arg.hpp b/include/gridtools/stencil/frontend/cartesian/tmp_arg.hpp
index 8c971aa410..1f95a2d384 100644
--- a/include/gridtools/stencil/frontend/cartesian/tmp_arg.hpp
+++ b/include/gridtools/stencil/frontend/cartesian/tmp_arg.hpp
@@ -23,7 +23,7 @@
 
 #define GT_DECLARE_TMP(type, ...)                                                               \
     BOOST_PP_SEQ_FOR_EACH(GT_INTERNAL_DECLARE_TMP, type, BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__)) \
-    static_assert(1, "")
+    static_assert(1)
 
 #define GT_INTERNAL_DECLARE_EXPANDABLE_TMP(r, type, name)                                    \
     constexpr ::gridtools::stencil::expandable<                                              \
@@ -32,7 +32,7 @@
 
 #define GT_DECLARE_EXPANDABLE_TMP(type, ...)                                                               \
     BOOST_PP_SEQ_FOR_EACH(GT_INTERNAL_DECLARE_EXPANDABLE_TMP, type, BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__)) \
-    static_assert(1, "")
+    static_assert(1)
 
 namespace gridtools {
     namespace stencil {
diff --git a/include/gridtools/stencil/frontend/icosahedral/stage.hpp b/include/gridtools/stencil/frontend/icosahedral/stage.hpp
index 172b88a834..66d172ba97 100644
--- a/include/gridtools/stencil/frontend/icosahedral/stage.hpp
+++ b/include/gridtools/stencil/frontend/icosahedral/stage.hpp
@@ -11,6 +11,7 @@
 #pragma once
 
 #include <type_traits>
+#include <utility>
 
 #include "../../../common/defs.hpp"
 #include "../../../common/for_each.hpp"
@@ -61,7 +62,7 @@ namespace gridtools {
             namespace stage_impl_ {
                 struct default_deref_f {
                     template <class Key, class T>
-                    GT_FUNCTION decltype(auto) operator()(Key, T ptr) const {
+                    GT_FORCE_INLINE constexpr decltype(auto) operator()(Key, T ptr) const {
                         return *ptr;
                     }
                 };
@@ -72,21 +73,21 @@ namespace gridtools {
                     Strides const &m_strides;
 
                     template <class Key, class Offset>
-                    GT_FUNCTION decltype(auto) get_ref(Offset offset) const {
-                        return Deref()(Key(),
-                            sid::multi_shifted<Key>(host_device::at_key<Key>(m_ptr), m_strides, wstd::move(offset)));
+                    GT_FORCE_INLINE constexpr decltype(auto) get_ref(Offset offset) const {
+                        return Deref()(
+                            Key(), sid::multi_shifted<Key>(at_key<Key>(m_ptr), m_strides, std::move(offset)));
                     }
 
                     template <class Accessor>
-                    GT_FUNCTION decltype(auto) operator()(Accessor) const {
+                    GT_FORCE_INLINE constexpr decltype(auto) operator()(Accessor) const {
                         return apply_intent<Accessor::intent_v>(get_ref<meta::at_c<Keys, Accessor::index_t::value>>(
                             hymap::keys<dim::c>::values<integral_constant<int_t, Color>>()));
                     }
 
                     template <class Accessor, class Offset>
-                    GT_FUNCTION decltype(auto) neighbor(Accessor, Offset offset) const {
+                    GT_FORCE_INLINE constexpr decltype(auto) neighbor(Accessor, Offset offset) const {
                         return apply_intent<Accessor::intent_v>(
-                            get_ref<meta::at_c<Keys, Accessor::index_t::value>>(wstd::move(offset)));
+                            get_ref<meta::at_c<Keys, Accessor::index_t::value>>(std::move(offset)));
                     }
 
                     static constexpr int_t color = Color;
@@ -94,10 +95,10 @@ namespace gridtools {
                     template <class Fun, class Accessor, class... Accessors>
                     GT_FUNCTION void for_neighbors(Fun &&fun, Accessor, Accessors...) const {
                         static_assert(
-                            std::conjunction<
-                                std::is_same<typename Accessor::location_t, typename Accessors::location_t>...>::value,
+                            std::conjunction_v<
+                                std::is_same<typename Accessor::location_t, typename Accessors::location_t>...>,
                             "All accessors should be of the same location");
-                        host_device::for_each<neighbor_offsets<LocationType, typename Accessor::location_t, Color>>(
+                        for_each<neighbor_offsets<LocationType, typename Accessor::location_t, Color>>(
                             [&](auto offset) { fun(neighbor(Accessor(), offset), neighbor(Accessors(), offset)...); });
                     }
                 };
@@ -109,7 +110,7 @@ namespace gridtools {
                     template <class Deref = void, class Ptr, class Strides>
                     GT_FUNCTION void operator()(Ptr const &ptr, Strides const &strides) const {
                         using deref_t = meta::if_<std::is_void<Deref>, default_deref_f, Deref>;
-                        host_device::for_each<meta::make_indices<location_t>>([&](auto color) {
+                        for_each<meta::make_indices<location_t>>([&](auto color) {
                             using eval_t = evaluator<Ptr, Strides, PlhMap, deref_t, location_t, decltype(color)::value>;
                             Functor::apply(eval_t{ptr, strides});
                         });
diff --git a/include/gridtools/stencil/frontend/icosahedral/tmp_arg.hpp b/include/gridtools/stencil/frontend/icosahedral/tmp_arg.hpp
index da8563e8d3..30e97b6b42 100644
--- a/include/gridtools/stencil/frontend/icosahedral/tmp_arg.hpp
+++ b/include/gridtools/stencil/frontend/icosahedral/tmp_arg.hpp
@@ -26,7 +26,7 @@
 #define GT_DECLARE_EXPANDABLE_ICO_TMP(type, location, ...)                                               \
     BOOST_PP_SEQ_FOR_EACH(                                                                               \
         GT_INTERNAL_DECLARE_EXPANDABLE_ICO_TMP, (type, location), BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__)) \
-    static_assert(1, "")
+    static_assert(1)
 
 #define GT_INTERNAL_DECLARE_ICO_TMP(r, type_location, name)               \
     constexpr ::gridtools::stencil::icosahedral::tmp_arg<__COUNTER__,     \
@@ -36,7 +36,7 @@
 
 #define GT_DECLARE_ICO_TMP(type, location, ...)                                                                 \
     BOOST_PP_SEQ_FOR_EACH(GT_INTERNAL_DECLARE_ICO_TMP, (type, location), BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__)) \
-    static_assert(1, "")
+    static_assert(1)
 
 namespace gridtools {
     namespace stencil {
diff --git a/include/gridtools/stencil/frontend/run.hpp b/include/gridtools/stencil/frontend/run.hpp
index 33fd93e253..af9c0536f1 100644
--- a/include/gridtools/stencil/frontend/run.hpp
+++ b/include/gridtools/stencil/frontend/run.hpp
@@ -125,7 +125,7 @@ namespace gridtools {
                     static_assert(meta::is_set<meta::list<Args...>>::value, "Duplicated arguments.");
                     static_assert(
                         meta::is_set<meta::list<typename Caches::plh_t..., Args...>>::value, "Duplicated caches.");
-                    static_assert(std::conjunction<core::is_tmp_arg<Args>...>::value,
+                    static_assert(std::conjunction_v<core::is_tmp_arg<Args>...>,
                         "Only temporary args can be K-cached without fill or flush policies.");
                     return {};
                 }
@@ -239,7 +239,7 @@ namespace gridtools {
             }
 
             template <class Comp, class Backend, class Grid, class... Fields>
-            void run(Comp comp, Backend &&be, Grid const &grid, Fields &&... fields) {
+            void run(Comp comp, Backend &&be, Grid const &grid, Fields &&...fields) {
                 static_assert(
                     std::conjunction<is_sid<Fields>...>::value, "All computation fields must satisfy SID concept.");
                 run_impl(comp,
@@ -250,7 +250,7 @@ namespace gridtools {
             }
 
             template <class F, class Backend, class Grid, class... Fields>
-            void run_single_stage(F, Backend &&be, Grid const &grid, Fields &&... fields) {
+            void run_single_stage(F, Backend &&be, Grid const &grid, Fields &&...fields) {
                 return run([](auto... args) { return execute_parallel().stage(F(), args...); },
                     std::forward<Backend>(be),
                     grid,
diff --git a/include/gridtools/stencil/global_parameter.hpp b/include/gridtools/stencil/global_parameter.hpp
index 40ef5944a6..c6730e7ac0 100644
--- a/include/gridtools/stencil/global_parameter.hpp
+++ b/include/gridtools/stencil/global_parameter.hpp
@@ -22,14 +22,16 @@ namespace gridtools {
 
             template <class T>
             struct global_parameter {
-                static_assert(std::is_trivially_copyable<T>(), "global parameter should be trivially copyable");
+                static_assert(std::is_trivially_copy_constructible_v<T>, "global parameter should be trivially copyable");
 
                 T m_value;
 
-                GT_CONSTEXPR GT_FUNCTION global_parameter operator()() const { return *this; }
-                GT_CONSTEXPR GT_FUNCTION T operator*() const { return m_value; }
+                constexpr global_parameter(T val) : m_value(std::move(val)) {}
 
-                friend GT_FUNCTION global_parameter operator+(global_parameter obj, ptr_diff) { return obj; }
+                GT_FORCE_INLINE constexpr global_parameter operator()() const { return *this; }
+                GT_FORCE_INLINE constexpr T operator*() const { return m_value; }
+
+                friend GT_FORCE_INLINE constexpr global_parameter operator+(global_parameter obj, ptr_diff) { return obj; }
                 friend global_parameter sid_get_origin(global_parameter const &obj) { return obj; }
                 friend ptr_diff sid_get_ptr_diff(global_parameter) { return {}; }
             };
@@ -38,7 +40,7 @@ namespace gridtools {
         using global_parameter_impl_::global_parameter;
 
         template <class T>
-        global_parameter<T> make_global_parameter(T val) {
+        [[deprecated("use global_parameter template deduction")]] global_parameter<T> make_global_parameter(T val) {
             return {std::move(val)};
         }
     } // namespace stencil
diff --git a/include/gridtools/stencil/gpu/entry_point.hpp b/include/gridtools/stencil/gpu/entry_point.hpp
index 67fcf4c8d8..4687d07c40 100644
--- a/include/gridtools/stencil/gpu/entry_point.hpp
+++ b/include/gridtools/stencil/gpu/entry_point.hpp
@@ -53,7 +53,7 @@ namespace gridtools {
 
                 template <class Validator>
                 GT_FUNCTION_DEVICE void operator()(int_t i_block, int_t j_block, Validator const &validator) const {
-                    (void)(int[]){(tuple_util::device::get<Is>(m_funs)(i_block, j_block, validator), 0)...};
+                    (void)(int[]){(tuple_util::get<Is>(m_funs)(i_block, j_block, validator), 0)...};
                 }
             };
 
@@ -134,13 +134,13 @@ namespace gridtools {
             struct deref_f {
 #if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 350
                 template <class Key, class T>
-                GT_FUNCTION std::enable_if_t<is_texture_type<T>::value && meta::st_contains<Keys, Key>::value, T>
+                GT_FORCE_INLINE constexpr std::enable_if_t<is_texture_type<T>::value && meta::st_contains<Keys, Key>::value, T>
                 operator()(Key, T const *ptr) const {
                     return __ldg(ptr);
                 }
 #endif
                 template <class Key, class Ptr>
-                GT_FUNCTION decltype(auto) operator()(Key, Ptr ptr) const {
+                GT_FORCE_INLINE constexpr decltype(auto) operator()(Key, Ptr ptr) const {
                     return *ptr;
                 }
             };
@@ -243,7 +243,7 @@ namespace gridtools {
 
                 template <class Msses, class Grid, class DataStores>
                 static void entry_point(Grid const &grid, DataStores external_data_stores) {
-                    auto cuda_alloc = sid::device::make_cached_allocator(&cuda_util::cuda_malloc<char[]>);
+                    auto cuda_alloc = sid::cached_allocator(&cuda_util::cuda_malloc<char[]>);
                     auto data_stores = hymap::concat(
                         block(std::move(external_data_stores)), make_temporaries<Msses>(grid, cuda_alloc));
                     using const_keys_t =
diff --git a/include/gridtools/stencil/gpu/fill_flush.hpp b/include/gridtools/stencil/gpu/fill_flush.hpp
index d138f7a893..31658df610 100644
--- a/include/gridtools/stencil/gpu/fill_flush.hpp
+++ b/include/gridtools/stencil/gpu/fill_flush.hpp
@@ -64,29 +64,29 @@ namespace gridtools {
                     enum class check { none, lo, hi };
 
                     template <class Ptrs>
-                    GT_FUNCTION int_t get_k_pos(Ptrs const &ptrs) {
-                        return *host_device::at_key<meta::list<k_pos_key>>(ptrs);
+                    GT_FORCE_INLINE constexpr int_t get_k_pos(Ptrs const &ptrs) {
+                        return *at_key<meta::list<k_pos_key>>(ptrs);
                     }
 
                     template <class PlhInfo, class Ptr, class Strides, class Offset>
-                    GT_FUNCTION void shift_orig(Ptr &ptr, Strides const &strides, Offset offset) {
+                    GT_FORCE_INLINE constexpr void shift_orig(Ptr &ptr, Strides const &strides, Offset offset) {
                         sid::shift(
                             ptr, sid::get_stride_element<meta::list<typename PlhInfo::plh_t>, dim::k>(strides), offset);
                     }
 
                     template <class PlhInfo, class Ptr, class Strides, class Offset>
-                    GT_FUNCTION void shift_cached(Ptr &ptr, Strides const &strides, Offset offset) {
+                    GT_FORCE_INLINE constexpr void shift_cached(Ptr &ptr, Strides const &strides, Offset offset) {
                         sid::shift(ptr, sid::get_stride_element<typename PlhInfo::key_t, dim::k>(strides), offset);
                     }
 
                     template <class PlhInfo, class Ptrs>
-                    GT_FUNCTION auto get_orig(Ptrs const &ptrs) {
-                        return host_device::at_key<meta::list<typename PlhInfo::plh_t>>(ptrs);
+                    GT_FORCE_INLINE constexpr auto get_orig(Ptrs const &ptrs) {
+                        return at_key<meta::list<typename PlhInfo::plh_t>>(ptrs);
                     }
 
                     template <class PlhInfo, class Ptrs>
-                    GT_FUNCTION auto get_cached(Ptrs const &ptrs) {
-                        return host_device::at_key<typename PlhInfo::key_t>(ptrs);
+                    GT_FORCE_INLINE constexpr auto get_cached(Ptrs const &ptrs) {
+                        return at_key<typename PlhInfo::key_t>(ptrs);
                     }
 
                     template <class PlhInfo,
@@ -95,7 +95,7 @@ namespace gridtools {
                         std::enable_if_t<std::is_same<typename PlhInfo::cache_io_policies_t,
                                              meta::list<cache_io_policy::fill>>::value,
                             int> = 0>
-                    GT_FUNCTION void sync(Cached cached, Orig orig) {
+                    GT_FORCE_INLINE constexpr void sync(Cached cached, Orig orig) {
                         *cached = *orig;
                     }
 
@@ -105,18 +105,18 @@ namespace gridtools {
                         std::enable_if_t<std::is_same<typename PlhInfo::cache_io_policies_t,
                                              meta::list<cache_io_policy::flush>>::value,
                             int> = 0>
-                    GT_FUNCTION void sync(Cached cached, Orig orig) {
+                    GT_FORCE_INLINE constexpr void sync(Cached cached, Orig orig) {
                         *orig = *cached;
                     }
 
                     template <class Plh, check>
                     struct bound {};
 
-                    GT_FUNCTION bool is_k_valid(integral_constant<check, check::lo>, int_t k, int_t lim) {
+                    GT_FORCE_INLINE constexpr bool is_k_valid(integral_constant<check, check::lo>, int_t k, int_t lim) {
                         return k >= lim;
                     }
 
-                    GT_FUNCTION bool is_k_valid(integral_constant<check, check::hi>, int_t k, int_t lim) {
+                    GT_FORCE_INLINE constexpr bool is_k_valid(integral_constant<check, check::hi>, int_t k, int_t lim) {
                         return k < lim;
                     }
 
@@ -130,7 +130,7 @@ namespace gridtools {
                             using namespace literals;
                             auto orig = get_orig<PlhInfo>(ptrs);
                             auto cached = get_cached<PlhInfo>(ptrs);
-                            auto lim = *host_device::at_key<bound_key_t>(ptrs);
+                            auto lim = *at_key<bound_key_t>(ptrs);
 
                             using from_t = meta::if_c<Range == range::plus,
                                 typename PlhInfo::extent_t::kplus,
@@ -138,7 +138,7 @@ namespace gridtools {
 
                             shift_orig<PlhInfo>(orig, strides, from_t());
                             shift_cached<PlhInfo>(cached, strides, from_t());
-                            int_t k = *host_device::at_key<pos_key_t>(ptrs) + from_t::value;
+                            int_t k = *at_key<pos_key_t>(ptrs) + from_t::value;
 
                             static constexpr int_t size = Range == range::all ? PlhInfo::extent_t::kplus::value -
                                                                                     PlhInfo::extent_t::kminus::value + 1
@@ -258,14 +258,15 @@ namespace gridtools {
                             !sync_all || std::is_same<meta::first<CurInterval>, meta::second<CurInterval>>::value,
                             "offset_limit too small");
 
-                        static constexpr range range_v =
-                            minus == plus ? range::minus
-                                          : sync_all ? range::all : is_forward == is_fill ? range::plus : range::minus;
+                        static constexpr range range_v = minus == plus           ? range::minus
+                                                         : sync_all              ? range::all
+                                                         : is_forward == is_fill ? range::plus
+                                                                                 : range::minus;
 
-                        static constexpr check check_v =
-                            minus == plus || PlhInfo::is_tmp_t::value
-                                ? check::none
-                                : close_to_first ? check::lo : close_to_last ? check::hi : check::none;
+                        static constexpr check check_v = minus == plus || PlhInfo::is_tmp_t::value ? check::none
+                                                         : close_to_first                          ? check::lo
+                                                         : close_to_last                           ? check::hi
+                                                                                                   : check::none;
 
                         using type = sync_fun<PlhInfo, range_v, check_v>;
                     };
@@ -325,13 +326,13 @@ namespace gridtools {
 
                     template <class Plh, class DataStores>
                     auto make_data_store(bound<Plh, check::lo>, DataStores const &data_stores) {
-                        return make_global_parameter(
+                        return global_parameter(
                             sid::get_lower_bound<dim::k>(sid::get_lower_bounds(at_key<Plh>(data_stores))));
                     }
 
                     template <class Plh, class DataStores>
                     auto make_data_store(bound<Plh, check::hi>, DataStores const &data_stores) {
-                        return make_global_parameter(
+                        return global_parameter(
                             sid::get_upper_bound<dim::k>(sid::get_upper_bounds(at_key<Plh>(data_stores))));
                     }
 
diff --git a/include/gridtools/stencil/gpu/k_cache.hpp b/include/gridtools/stencil/gpu/k_cache.hpp
index 664906204d..231e6fd91c 100644
--- a/include/gridtools/stencil/gpu/k_cache.hpp
+++ b/include/gridtools/stencil/gpu/k_cache.hpp
@@ -46,12 +46,12 @@ namespace gridtools {
                 };
 
                 struct fake {
-                    GT_FUNCTION fake operator()() const { return {}; }
+                    constexpr fake operator()() const { return {}; }
                     fake operator*() const;
                 };
                 fake sid_get_ptr_diff(fake);
                 inline fake sid_get_origin(fake) { return {}; }
-                GT_FUNCTION fake operator+(fake, fake) { return {}; }
+                constexpr fake operator+(fake, fake) { return {}; }
                 inline hymap::keys<dim::k>::values<integral_constant<int_t, 1>> sid_get_strides(fake) { return {}; }
 
                 static_assert(is_sid<fake>(), GT_INTERNAL_ERROR);
@@ -62,13 +62,13 @@ namespace gridtools {
 
                   public:
                     GT_FUNCTION_DEVICE auto ptr() {
-                        return tuple_util::device::transform(
+                        return tuple_util::transform(
                             [](auto &storage) GT_FORCE_INLINE_LAMBDA { return storage.ptr(); }, m_storages);
                     }
 
                     template <class Step>
                     GT_FUNCTION_DEVICE void slide(Step step) {
-                        tuple_util::device::for_each(
+                        tuple_util::for_each(
                             [step](auto &storage) GT_FORCE_INLINE_LAMBDA { storage.slide(step); }, m_storages);
                     }
                 };
diff --git a/include/gridtools/stencil/gpu/launch_kernel.hpp b/include/gridtools/stencil/gpu/launch_kernel.hpp
index e8e275b40f..a9b27e3fbf 100644
--- a/include/gridtools/stencil/gpu/launch_kernel.hpp
+++ b/include/gridtools/stencil/gpu/launch_kernel.hpp
@@ -142,7 +142,7 @@ namespace gridtools {
                     static_assert(Extent::iminus::value <= 0, GT_INTERNAL_ERROR);
                     static_assert(Extent::iplus::value >= 0, GT_INTERNAL_ERROR);
 
-                    static_assert(std::is_trivially_copyable<Fun>::value, GT_INTERNAL_ERROR);
+                    static_assert(std::is_trivially_copy_constructible_v<Fun>, GT_INTERNAL_ERROR);
 
                     static constexpr auto halo_lines = Extent::jplus::value - Extent::jminus::value +
                                                        (Extent::iminus::value < 0 ? 1 : 0) +
@@ -171,7 +171,7 @@ namespace gridtools {
                     std::enable_if_t<is_empty_ij_extents<Extent>(), int> = 0>
                 void launch_kernel(int_t i_size, int_t j_size, uint_t zblocks, Fun fun, size_t shared_memory_size = 0) {
 
-                    static_assert(std::is_trivially_copyable<Fun>::value, GT_INTERNAL_ERROR);
+                    static_assert(std::is_trivially_copy_constructible_v<Fun>, GT_INTERNAL_ERROR);
 
                     static const size_t num_threads = BlockSizeI * BlockSizeJ;
 
diff --git a/include/gridtools/stencil/gpu/make_kernel_fun.hpp b/include/gridtools/stencil/gpu/make_kernel_fun.hpp
index 1dc21a2dd0..ffb9da84f4 100644
--- a/include/gridtools/stencil/gpu/make_kernel_fun.hpp
+++ b/include/gridtools/stencil/gpu/make_kernel_fun.hpp
@@ -15,7 +15,6 @@
 #include "../../common/gt_math.hpp"
 #include "../../common/host_device.hpp"
 #include "../../common/tuple_util.hpp"
-#include "../../common/utility.hpp"
 #include "../../meta.hpp"
 #include "../../sid/blocked_dim.hpp"
 #include "../../sid/concept.hpp"
@@ -33,7 +32,7 @@ namespace gridtools {
                 template <class Deref, class Info, class Ptr, class Strides, class Validator>
                 GT_FUNCTION_DEVICE void exec_cells(
                     Info, Ptr const &ptr, Strides const &strides, Validator const &validator) {
-                    device::for_each<typename Info::cells_t>([&](auto cell) GT_FORCE_INLINE_LAMBDA {
+                    for_each<typename Info::cells_t>([&](auto cell) {
                         syncthreads(cell.need_sync());
                         if (validator(cell.extent()))
                             cell.template operator()<Deref>(ptr, strides);
@@ -54,8 +53,8 @@ namespace gridtools {
                     template <class Ptr, class Strides, class Validator>
                     GT_FUNCTION_DEVICE void operator()(Ptr ptr, Strides const &strides, Validator validator) const {
                         k_caches_type<Mss> k_caches;
-                        auto mixed_ptr = hymap::device::merge(k_caches.ptr(), wstd::move(ptr));
-                        tuple_util::device::for_each(
+                        auto mixed_ptr = hymap::merge(k_caches.ptr(), std::move(ptr));
+                        tuple_util::for_each(
                             [&](const int_t size, auto info) GT_FORCE_INLINE_LAMBDA {
 #ifdef __HIPCC__
 // unroll factor estimate based on GT perftests on AMD Mi50
@@ -80,7 +79,7 @@ namespace gridtools {
 
                     template <class Ptr, class Strides, class Validator>
                     GT_FUNCTION_DEVICE void operator()(Ptr ptr, Strides const &strides, Validator validator) const {
-                        tuple_util::device::for_each(
+                        tuple_util::for_each(
                             [&](const int_t size, auto info) GT_FORCE_INLINE_LAMBDA {
 #ifdef __HIPCC__
 // unroll factor estimate based on GT perftests on AMD Mi50
@@ -106,7 +105,7 @@ namespace gridtools {
                     GT_FUNCTION_DEVICE void operator()(Ptr ptr, Strides const &strides, Validator validator) const {
                         int_t cur = -(int_t)blockIdx.z * BlockSize;
                         sid::shift(ptr, sid::get_stride<dim::k>(strides), -cur);
-                        tuple_util::device::for_each(
+                        tuple_util::for_each(
                             [&](int_t size, auto info) GT_FORCE_INLINE_LAMBDA {
                                 if (cur >= BlockSize)
                                     return;
@@ -138,7 +137,7 @@ namespace gridtools {
                         sid::shift(ptr, sid::get_stride<sid::blocked_dim<dim::j>>(m_strides), blockIdx.y);
                         sid::shift(ptr, sid::get_stride<dim::i>(m_strides), i_block);
                         sid::shift(ptr, sid::get_stride<dim::j>(m_strides), j_block);
-                        k_loop(wstd::move(ptr), m_strides, wstd::move(validator));
+                        k_loop(std::move(ptr), m_strides, std::move(validator));
                     }
                 };
 
diff --git a/include/gridtools/stencil/gpu/shared_allocator.hpp b/include/gridtools/stencil/gpu/shared_allocator.hpp
index 1be7db28a9..e57fbff2a7 100644
--- a/include/gridtools/stencil/gpu/shared_allocator.hpp
+++ b/include/gridtools/stencil/gpu/shared_allocator.hpp
@@ -31,7 +31,7 @@ namespace gridtools {
                         return reinterpret_cast<T *>(ij_cache_shm + m_offset);
                     }
 
-                    friend GT_FUNCTION lazy_alloc operator+(lazy_alloc l, ptrdiff_t r) {
+                    friend GT_FORCE_INLINE constexpr lazy_alloc operator+(lazy_alloc l, ptrdiff_t r) {
                         l.m_offset += r * sizeof(T);
                         return l;
                     }
diff --git a/include/gridtools/stencil/gpu_horizontal/entry_point.hpp b/include/gridtools/stencil/gpu_horizontal/entry_point.hpp
index e5bb3a0502..d2e1d6125d 100644
--- a/include/gridtools/stencil/gpu_horizontal/entry_point.hpp
+++ b/include/gridtools/stencil/gpu_horizontal/entry_point.hpp
@@ -21,7 +21,6 @@
 #include "../../common/hymap.hpp"
 #include "../../common/integral_constant.hpp"
 #include "../../common/tuple_util.hpp"
-#include "../../common/utility.hpp"
 #include "../../meta.hpp"
 #include "../../sid/as_const.hpp"
 #include "../../sid/block.hpp"
@@ -44,13 +43,13 @@ namespace gridtools {
             struct deref_f {
 #if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 350
                 template <class Key, class T>
-                GT_FUNCTION std::enable_if_t<is_texture_type<T>::value && meta::st_contains<Keys, Key>::value, T>
+                GT_FORCE_INLINE constexpr std::enable_if_t<is_texture_type<T>::value && meta::st_contains<Keys, Key>::value, T>
                 operator()(Key, T const *ptr) const {
                     return __ldg(ptr);
                 }
 #endif
                 template <class Key, class Ptr>
-                GT_FUNCTION decltype(auto) operator()(Key, Ptr ptr) const {
+                GT_FORCE_INLINE constexpr decltype(auto) operator()(Key, Ptr ptr) const {
                     return *ptr;
                 }
             };
@@ -71,7 +70,7 @@ namespace gridtools {
 
                     using j_caches_t = j_caches_type<Info>;
                     j_caches_t j_caches;
-                    auto mixed_ptr = hymap::device::merge(j_caches.ptr(), wstd::move(ptr));
+                    auto mixed_ptr = hymap::merge(j_caches.ptr(), std::move(ptr));
 
                     auto shift_mixed_ptr = [&](auto dim, auto offset) {
                         sid::shift(mixed_ptr.secondary(), sid::get_stride<decltype(dim)>(strides), offset);
@@ -80,7 +79,7 @@ namespace gridtools {
 
 #pragma unroll
                     for (int_t j = decltype(j_start)::value; j < JBlockSize; ++j) {
-                        device::for_each<typename Info::cells_t>([&](auto cell) GT_FORCE_INLINE_LAMBDA {
+                        for_each<typename Info::cells_t>([&](auto cell) {
                             using cell_t = decltype(cell);
                             using extent_t = typename cell_t::extent_t;
                             constexpr auto j_offset = typename extent_t::jplus();
@@ -109,7 +108,7 @@ namespace gridtools {
                 GT_FUNCTION_DEVICE void operator()(Ptr ptr, Strides const &strides, Validator validator) const {
                     int_t cur = -(int_t)blockIdx.z * KBlockSize;
                     sid::shift(ptr, sid::get_stride<dim::k>(strides), -cur);
-                    tuple_util::device::for_each(
+                    tuple_util::for_each(
                         [&](int_t size, auto info) GT_FORCE_INLINE_LAMBDA {
                             if (cur >= KBlockSize)
                                 return;
@@ -140,7 +139,7 @@ namespace gridtools {
                     sid::shift(ptr, sid::get_stride<sid::blocked_dim<dim::i>>(m_strides), blockIdx.x);
                     sid::shift(ptr, sid::get_stride<sid::blocked_dim<dim::j>>(m_strides), blockIdx.y);
                     sid::shift(ptr, sid::get_stride<dim::i>(m_strides), i_block);
-                    k_loop(wstd::move(ptr), m_strides, wstd::move(validator));
+                    k_loop(std::move(ptr), m_strides, std::move(validator));
                 }
             };
 
diff --git a/include/gridtools/stencil/gpu_horizontal/j_cache.hpp b/include/gridtools/stencil/gpu_horizontal/j_cache.hpp
index d29e0de221..8536ce41b7 100644
--- a/include/gridtools/stencil/gpu_horizontal/j_cache.hpp
+++ b/include/gridtools/stencil/gpu_horizontal/j_cache.hpp
@@ -63,7 +63,7 @@ namespace gridtools {
 
                 template <class Extent, class NumColors>
                 struct fake {
-                    GT_FUNCTION fake operator()() const { return {}; }
+                    constexpr fake operator()() const { return {}; }
                     fake operator*() const;
                 };
                 template <class Extent, class NumColors>
@@ -75,7 +75,7 @@ namespace gridtools {
                 }
 
                 template <class Extent, class NumColors>
-                GT_FUNCTION fake<Extent, NumColors> operator+(fake<Extent, NumColors>, fake<Extent, NumColors>) {
+                constexpr fake<Extent, NumColors> operator+(fake<Extent, NumColors>, fake<Extent, NumColors>) {
                     return {};
                 }
 
@@ -90,20 +90,19 @@ namespace gridtools {
 
                   public:
                     GT_FUNCTION_DEVICE auto ptr() {
-                        return tuple_util::device::transform(
+                        return tuple_util::transform(
                             [](auto &storage) GT_FORCE_INLINE_LAMBDA { return storage.ptr(); }, m_storages);
                     }
 
                     GT_FUNCTION_DEVICE void slide() {
-                        tuple_util::device::for_each(
-                            [](auto &storage) GT_FORCE_INLINE_LAMBDA { storage.slide(); }, m_storages);
+                        tuple_util::for_each([](auto &storage) GT_FORCE_INLINE_LAMBDA { storage.slide(); }, m_storages);
                     }
 
                     template <class Ptr, class Dim, class Offset>
                     static GT_FUNCTION_DEVICE void shift(Dim, Ptr &ptr, Offset offset) {
                         using strides_t =
                             meta::rename<tuple, meta::transform<get_stride_f<Dim>::template apply, Storages>>;
-                        tuple_util::device::for_each(
+                        tuple_util::for_each(
                             [offset](auto &ptr, auto stride) { sid::shift(ptr, stride, offset); }, ptr, strides_t());
                     }
                 };
diff --git a/include/gridtools/stencil/gpu_horizontal/launch_kernel.hpp b/include/gridtools/stencil/gpu_horizontal/launch_kernel.hpp
index a05625022c..0885a76a8b 100644
--- a/include/gridtools/stencil/gpu_horizontal/launch_kernel.hpp
+++ b/include/gridtools/stencil/gpu_horizontal/launch_kernel.hpp
@@ -55,7 +55,7 @@ namespace gridtools {
 
                 template <int_t BlockSizeI, int_t BlockSizeJ, class Fun>
                 void launch_kernel(int_t i_size, int_t j_size, uint_t zblocks, Fun fun) {
-                    static_assert(std::is_trivially_copyable<Fun>::value, GT_INTERNAL_ERROR);
+                    static_assert(std::is_trivially_copy_constructible_v<Fun>, GT_INTERNAL_ERROR);
 
                     cuda_util::launch(
                         dim3((i_size + BlockSizeI - 1) / BlockSizeI, (j_size + BlockSizeJ - 1) / BlockSizeJ, zblocks),
diff --git a/include/gridtools/stencil/naive.hpp b/include/gridtools/stencil/naive.hpp
index c114070113..958a52d8f5 100644
--- a/include/gridtools/stencil/naive.hpp
+++ b/include/gridtools/stencil/naive.hpp
@@ -32,7 +32,7 @@ namespace gridtools {
         struct naive {
             template <class Spec, class Grid, class DataStores>
             friend void gridtools_backend_entry_point(naive, Spec, Grid const &grid, DataStores external_data_stores) {
-                auto alloc = sid::host_device::make_allocator(&std::make_unique<char[]>);
+                auto alloc = sid::allocator(&std::make_unique<char[]>);
                 using stages_t = be_api::make_split_view<Spec>;
                 using tmp_plh_map_t = be_api::remove_caches_from_plh_map<typename stages_t::tmp_plh_map_t>;
                 auto temporaries = be_api::make_data_stores(tmp_plh_map_t(), [&](auto info) {
diff --git a/include/gridtools/stencil/positional.hpp b/include/gridtools/stencil/positional.hpp
index fa033dedc1..188154fc06 100644
--- a/include/gridtools/stencil/positional.hpp
+++ b/include/gridtools/stencil/positional.hpp
@@ -23,14 +23,14 @@ namespace gridtools {
         struct positional {
             int_t m_val;
 
-            GT_FUNCTION positional(int_t val = 0) : m_val{val} {}
+            GT_FORCE_INLINE constexpr positional(int_t val = 0) : m_val{val} {}
 
-            GT_FUNCTION int operator*() const { return m_val; }
-            GT_FUNCTION positional const &operator()() const { return *this; }
+            GT_FORCE_INLINE constexpr int operator*() const { return m_val; }
+            GT_FORCE_INLINE constexpr positional const &operator()() const { return *this; }
         };
 
         template <class Dim>
-        GT_FUNCTION positional<Dim> operator+(positional<Dim> lhs, positional<Dim> rhs) {
+        GT_FORCE_INLINE constexpr positional<Dim> operator+(positional<Dim> lhs, positional<Dim> rhs) {
             return {lhs.m_val + rhs.m_val};
         }
 
@@ -40,7 +40,7 @@ namespace gridtools {
         }
 
         template <class Dim>
-        GT_FUNCTION void sid_shift(positional<Dim> &p, positional_stride, int_t offset) {
+        GT_FORCE_INLINE constexpr void sid_shift(positional<Dim> &p, positional_stride, int_t offset) {
             p.m_val += offset;
         }
 
diff --git a/include/gridtools/storage/adapter/fortran_array_adapter.hpp b/include/gridtools/storage/adapter/fortran_array_adapter.hpp
index 59729ba9e5..f7b9641522 100644
--- a/include/gridtools/storage/adapter/fortran_array_adapter.hpp
+++ b/include/gridtools/storage/adapter/fortran_array_adapter.hpp
@@ -19,7 +19,7 @@
 namespace gridtools {
     template <class DataStorePtr>
     class fortran_array_adapter {
-        static_assert(storage::is_data_store_ptr<DataStorePtr>::value, "");
+        static_assert(storage::is_data_store_ptr<DataStorePtr>::value);
         using data_store_t = typename DataStorePtr::element_type;
         using lengths_t = std::decay_t<decltype(DataStorePtr()->lengths())>;
         using strides_t = std::decay_t<decltype(DataStorePtr()->strides())>;
diff --git a/include/gridtools/storage/adapter/python_sid_adapter.hpp b/include/gridtools/storage/adapter/python_sid_adapter.hpp
index 245d5ce3c8..0c9f6017dc 100644
--- a/include/gridtools/storage/adapter/python_sid_adapter.hpp
+++ b/include/gridtools/storage/adapter/python_sid_adapter.hpp
@@ -113,8 +113,8 @@ namespace gridtools {
 
         template <class T, std::size_t Dim, class Kind = void, size_t UnitStrideDim = size_t(-1)>
         wrapper<T, Dim, Kind, UnitStrideDim> as_sid(pybind11::buffer const &src) {
-            static_assert(
-                std::is_trivially_copyable<T>::value, "as_sid should be instantiated with the trivially copyable type");
+            static_assert(std::is_trivially_copy_constructible_v<T>,
+                "as_sid should be instantiated with the trivially copy constructible type");
             constexpr bool writable = !std::is_const<T>();
             // pybind11::buffer::request accepts writable as an optional parameter (default is false).
             // if writable is true PyBUF_WRITABLE flag is added while delegating to the PyObject_GetBuffer.
@@ -266,8 +266,8 @@ namespace gridtools {
 
         template <class T, size_t Dim, class Kind = void, size_t UnitStrideDim = size_t(-1)>
         auto as_cuda_sid(pybind11::object const &src) {
-            static_assert(std::is_trivially_copyable<T>::value,
-                "as_cuda_sid should be instantiated with the trivially copyable type");
+            static_assert(std::is_trivially_copy_constructible_v<T>,
+                "as_cuda_sid should be instantiated with the trivially copy constructible type");
 
             auto iface = src.attr("__cuda_array_interface__").cast<pybind11::dict>();
 
@@ -340,7 +340,7 @@ namespace gridtools {
 
             using sid::property;
             return sid::synthetic()
-                .template set<property::origin>(sid::host_device::simple_ptr_holder<T *>{ptr})
+                .template set<property::origin>(sid::simple_ptr_holder<T *>{ptr})
                 .template set<property::strides>(assign_unit_stride<UnitStrideDim>(std::move(strides), shape))
                 .template set<property::strides_kind, kind<Dim, Kind>>()
                 .template set<property::lower_bounds>(array<integral_constant<size_t, 0>, Dim>())
diff --git a/include/gridtools/storage/builder.hpp b/include/gridtools/storage/builder.hpp
index 5854f9e961..fac50964a1 100644
--- a/include/gridtools/storage/builder.hpp
+++ b/include/gridtools/storage/builder.hpp
@@ -272,7 +272,7 @@ namespace gridtools {
                 template <class... Args>
                 auto dimensions(Args const &...values) const {
                     static_assert(!has<param::lengths>::value, "storage dimensions are set twice");
-                    static_assert(std::conjunction<std::is_convertible<Args const &, uint_t>...>::value,
+                    static_assert(std::conjunction_v<std::is_convertible<Args const &, uint_t>...>,
                         "builder.dimensions(...) arguments should be convertible to unsigned int");
                     check_dimensions_number<sizeof...(Args)>();
                     return add_value<param::lengths>(
@@ -282,7 +282,7 @@ namespace gridtools {
                 template <class... Args>
                 auto halos(Args const &...values) const {
                     static_assert(!has<param::halos>::value, "storage dimensions are set twice");
-                    static_assert(std::conjunction<std::is_convertible<Args const &, int>...>::value,
+                    static_assert(std::conjunction_v<std::is_convertible<Args const &, int>...>,
                         "builder.halos(...) arguments should be convertible to int");
                     check_dimensions_number<sizeof...(Args)>();
                     return add_value<param::halos>(array<int, sizeof...(Args)>{static_cast<int>(values)...});
diff --git a/include/gridtools/storage/gpu.hpp b/include/gridtools/storage/gpu.hpp
index 7fcfddd57c..49d7651bb5 100644
--- a/include/gridtools/storage/gpu.hpp
+++ b/include/gridtools/storage/gpu.hpp
@@ -19,7 +19,6 @@
 #include "../common/host_device.hpp"
 #include "../common/integral_constant.hpp"
 #include "../common/layout_map.hpp"
-#include "../common/utility.hpp"
 
 namespace gridtools {
     namespace storage {
@@ -57,8 +56,8 @@ namespace gridtools {
 
                 template <class... Args>
                 GT_FUNCTION_DEVICE auto operator()(Args &&... args) const
-                    -> decltype(m_ptr[m_info.index(wstd::forward<Args>(args)...)]) {
-                    return m_ptr[m_info.index(wstd::forward<Args>(args)...)];
+                    -> decltype(m_ptr[m_info.index(std::forward<Args>(args)...)]) {
+                    return m_ptr[m_info.index(std::forward<Args>(args)...)];
                 }
 
                 GT_FUNCTION_DEVICE decltype(auto) operator()(array<int, Info::ndims> const &arg) const {
diff --git a/include/gridtools/storage/info.hpp b/include/gridtools/storage/info.hpp
index 19417a5c80..6dfb34ebae 100644
--- a/include/gridtools/storage/info.hpp
+++ b/include/gridtools/storage/info.hpp
@@ -13,6 +13,7 @@
 #include <cassert>
 #include <cstddef>
 #include <type_traits>
+#include <utility>
 
 #include "../common/array.hpp"
 #include "../common/defs.hpp"
@@ -90,7 +91,7 @@ namespace gridtools {
             class info<Lengths, Strides, std::index_sequence<Dims...>> : tuple<Lengths, Strides> {
                 static_assert(tuple_util::size<Lengths>::value == tuple_util::size<Strides>::value, GT_INTERNAL_ERROR);
 
-                GT_FUNCTION tuple<Lengths, Strides> const &base() const { return *this; }
+                GT_FORCE_INLINE constexpr tuple<Lengths, Strides> const &base() const { return *this; }
 
               public:
                 static constexpr size_t ndims = tuple_util::size<Lengths>::value;
@@ -98,35 +99,35 @@ namespace gridtools {
                 info(Lengths lengths, Strides strides)
                     : tuple<Lengths, Strides>{std::move(lengths), std::move(strides)} {}
 
-                GT_FUNCTION auto const &native_lengths() const { return tuple_util::host_device::get<0>(base()); }
-                GT_FUNCTION auto const &native_strides() const { return tuple_util::host_device::get<1>(base()); }
-                GT_FUNCTION int length() const {
-                    using tuple_util::host_device::get;
+                GT_FORCE_INLINE constexpr auto const &native_lengths() const { return tuple_util::get<0>(base()); }
+                GT_FORCE_INLINE constexpr auto const &native_strides() const { return tuple_util::get<1>(base()); }
+                GT_FORCE_INLINE constexpr int length() const {
+                    using tuple_util::get;
                     bool is_empty = false;
                     for (auto empty_dim : {(get<Dims>(native_lengths()) == 0)...})
                         is_empty = is_empty || empty_dim;
                     return is_empty ? 0 : index((get<Dims>(native_lengths()) - integral_constant<int_t, 1>())...) + 1;
                 }
-                GT_FUNCTION array<uint_t, ndims> lengths() const {
-                    return {(uint_t)tuple_util::host_device::get<Dims>(native_lengths())...};
+                GT_FORCE_INLINE constexpr array<uint_t, ndims> lengths() const {
+                    return {(uint_t)tuple_util::get<Dims>(native_lengths())...};
                 }
-                GT_FUNCTION array<uint_t, ndims> strides() const {
-                    return {(uint_t)tuple_util::host_device::get<Dims>(native_strides())...};
+                GT_FORCE_INLINE constexpr array<uint_t, ndims> strides() const {
+                    return {(uint_t)tuple_util::get<Dims>(native_strides())...};
                 }
 
                 template <class... Is,
                     std::enable_if_t<sizeof...(Is) == ndims &&
                                          std::conjunction<std::is_convertible<Is, int_t>...>::value,
                         int> = 0>
-                GT_FUNCTION auto index(Is... indices) const {
+                GT_FORCE_INLINE constexpr auto index(Is... indices) const {
                     return index_from_tuple(tuple(indices...));
                 }
 
                 template <class Indices>
-                GT_FUNCTION auto index_from_tuple(Indices &&indices) const {
-                    using namespace tuple_util::host_device;
+                GT_FORCE_INLINE constexpr auto index_from_tuple(Indices &&indices) const {
+                    using namespace tuple_util;
 #ifndef NDEBUG
-                    tuple_util::host_device::for_each(
+                    tuple_util::for_each(
                         [](int index, int length) {
                             assert(index >= 0);
                             assert(index < length);
@@ -136,7 +137,7 @@ namespace gridtools {
 #endif
                     return fold([](auto l, auto r) { return l + r; },
                         transform(
-                            [](auto i, auto s) { return i * s; }, wstd::forward<Indices>(indices), native_strides()));
+                            [](auto i, auto s) { return i * s; }, std::forward<Indices>(indices), native_strides()));
                 }
             };
 
diff --git a/include/gridtools/storage/sid.hpp b/include/gridtools/storage/sid.hpp
index 9d94ce35c2..3cce245885 100644
--- a/include/gridtools/storage/sid.hpp
+++ b/include/gridtools/storage/sid.hpp
@@ -28,7 +28,7 @@ namespace gridtools {
         namespace storage_sid_impl_ {
             struct empty_ptr_diff {
                 template <class T>
-                friend GT_CONSTEXPR GT_FUNCTION T *operator+(T *lhs, empty_ptr_diff) {
+                friend GT_FORCE_INLINE constexpr T *operator+(T *lhs, empty_ptr_diff) {
                     return lhs;
                 }
             };
@@ -36,7 +36,7 @@ namespace gridtools {
             template <class T>
             struct ptr_holder {
                 T *m_val;
-                GT_FUNCTION GT_CONSTEXPR T *operator()() const { return m_val; }
+                GT_FORCE_INLINE constexpr T *operator()() const { return m_val; }
 
                 friend GT_FORCE_INLINE constexpr ptr_holder operator+(ptr_holder obj, int_t arg) {
                     return {obj.m_val + arg};
diff --git a/tests/include/cuda_test_helper.hpp b/tests/include/cuda_test_helper.hpp
index 851b4bf00c..0a1352e7eb 100644
--- a/tests/include/cuda_test_helper.hpp
+++ b/tests/include/cuda_test_helper.hpp
@@ -26,11 +26,12 @@ namespace gridtools {
         // integral_constant will be taken instead of explicit conversion
         template <class T, T (*Fun)()>
         __global__ void kernel(T *res, integral_constant<T (*)(), Fun>) {
-            *res = Fun();
+            T in{Fun()};
+            memcpy(res, &in, sizeof(T));
         }
         template <class T, T (*Fun)()>
         T exec_with_shared_memory(size_t shm_size, integral_constant<T (*)(), Fun> fun) {
-            static_assert(std::is_trivially_copyable<T>::value, "");
+            static_assert(std::is_trivially_copy_constructible_v<T>);
             auto res = cuda_util::cuda_malloc<T>();
             kernel<<<1, 1, shm_size>>>(res.get(), fun);
             GT_CUDA_CHECK(cudaDeviceSynchronize());
@@ -39,14 +40,15 @@ namespace gridtools {
 
         template <class Res, class Fun, class... Args>
         __global__ void kernel(Res *res, Fun fun, Args... args) {
-            *res = fun(args...);
+            Res in{fun(std::move(args)...)};
+            memcpy(res, &in, sizeof(Res));
         }
         template <class Fun, class... Args>
         auto exec_with_shared_memory(size_t shm_size, Fun fun, Args... args) {
-            static_assert(!std::is_pointer<Fun>::value, "");
-            static_assert(std::conjunction<std::negation<std::is_pointer<Args>>...>::value, "");
+            static_assert(!std::is_pointer<Fun>::value);
+            static_assert(std::conjunction_v<std::negation<std::is_pointer<Args>>...>);
             using res_t = std::decay_t<decltype(fun(args...))>;
-            static_assert(std::is_trivially_copyable<res_t>::value, "");
+            static_assert(std::is_trivially_copy_constructible_v<res_t>);
             auto res = cuda_util::cuda_malloc<res_t>();
             kernel<<<1, 1, shm_size>>>(res.get(), fun, args...);
             GT_CUDA_CHECK(cudaDeviceSynchronize());
@@ -54,7 +56,7 @@ namespace gridtools {
         }
 
         template <class Fun, class... Args>
-        auto exec(Fun &&fun, Args &&... args) {
+        auto exec(Fun &&fun, Args &&...args) {
             return exec_with_shared_memory(0, std::forward<Fun>(fun), std::forward<Args>(args)...);
         }
     } // namespace on_device
diff --git a/tests/include/verifier.hpp b/tests/include/verifier.hpp
index 9c96761e9f..73dabe0aeb 100644
--- a/tests/include/verifier.hpp
+++ b/tests/include/verifier.hpp
@@ -39,19 +39,19 @@ namespace gridtools {
     } // namespace impl_
 
     template <class T>
-    GT_FUNCTION double default_precision() {
+    constexpr double default_precision() {
         return impl_::default_precision_impl<T>::value;
     }
 
     template <class T, std::enable_if_t<std::is_floating_point<T>::value, int> = 0>
-    GT_FUNCTION bool expect_with_threshold(T expected, T actual, double precision = default_precision<T>()) {
+    constexpr bool expect_with_threshold(T expected, T actual, double precision = default_precision<T>()) {
         auto abs_error = math::fabs(expected - actual);
         auto abs_max = math::max(math::fabs(expected), math::fabs(actual));
         return abs_error < precision || abs_error < abs_max * precision;
     }
 
     template <class T, std::enable_if_t<!std::is_floating_point<T>::value, int> = 0>
-    GT_FUNCTION bool expect_with_threshold(T const &expected, T const &actual, double = 0) {
+    constexpr bool expect_with_threshold(T const &expected, T const &actual, double = 0) {
         return actual == expected;
     }
 
diff --git a/tests/regression/c_array_copy.cpp b/tests/regression/c_array_copy.cpp
index 6e9605db2c..6bdfdf8a48 100644
--- a/tests/regression/c_array_copy.cpp
+++ b/tests/regression/c_array_copy.cpp
@@ -31,7 +31,7 @@ struct copy {
 
 template <class T>
 auto grid(T const &) {
-    static_assert(std::rank<T>() == 3, "");
+    static_assert(std::rank_v<T> == 3);
     return make_grid(std::extent<T, 0>(), std::extent<T, 1>(), std::extent<T, 2>());
 }
 
diff --git a/tests/regression/extended_4D.cpp b/tests/regression/extended_4D.cpp
index b4b103348b..5f9ebc23b4 100644
--- a/tests/regression/extended_4D.cpp
+++ b/tests/regression/extended_4D.cpp
@@ -122,8 +122,8 @@ namespace {
         run_single_stage(integration(),
             stencil_backend_t(),
             TypeParam::make_grid(),
-            make_global_parameter(ephi),
-            make_global_parameter(epsi),
+            global_parameter(ephi),
+            global_parameter(epsi),
             const_builder.dimensions(TypeParam::d(0), TypeParam::d(1), TypeParam::d(2), nbQuadPt)
                 .initializer(jac)
                 .build(),
diff --git a/tests/regression/horizontal_diffusion_functions.cpp b/tests/regression/horizontal_diffusion_functions.cpp
index 3859150eb4..7e42b40811 100644
--- a/tests/regression/horizontal_diffusion_functions.cpp
+++ b/tests/regression/horizontal_diffusion_functions.cpp
@@ -203,7 +203,7 @@ namespace {
     GT_REGRESSION_TEST(horizontal_diffusion_functions_##v, test_environment<2>, stencil_backend_t) { \
         do_test<TypeParam, variation::v>();                                                          \
     }                                                                                                \
-    static_assert(1, "")
+    static_assert(1)
 
     TEST_VARIATION(monolithic);
     TEST_VARIATION(call);
diff --git a/tests/regression/py_bindings/implementation.cpp b/tests/regression/py_bindings/implementation.cpp
index fab7aac33f..814d1e3efd 100644
--- a/tests/regression/py_bindings/implementation.cpp
+++ b/tests/regression/py_bindings/implementation.cpp
@@ -48,8 +48,8 @@ struct copy_functor {
 // The input and output fields are passed as SIDs
 template <class From, class To>
 void copy(From &&from, To &&to) {
-    static_assert(is_sid<From>(), "");
-    static_assert(is_sid<To>(), "");
+    static_assert(is_sid<From>());
+    static_assert(is_sid<To>());
     auto &&size = sid::get_upper_bounds(to);
     run_single_stage(copy_functor(),
         naive(),
@@ -73,12 +73,12 @@ void check_cuda_sid(T &&testee,
     size_t expected_ptr,
     std::vector<size_t> const &expected_strides,
     std::vector<size_t> const &expected_dims) {
-    static_assert(is_sid<T>(), "");
+    static_assert(is_sid<T>());
     using lower_bounds_t = sid::lower_bounds_type<T>;
     using upper_bounds_t = sid::upper_bounds_type<T>;
     using strides_t = sid::strides_type<T>;
-    static_assert(tuple_util::size<lower_bounds_t>() == tuple_util::size<strides_t>(), "");
-    static_assert(tuple_util::size<upper_bounds_t>() == tuple_util::size<strides_t>(), "");
+    static_assert(tuple_util::size<lower_bounds_t>() == tuple_util::size<strides_t>());
+    static_assert(tuple_util::size<upper_bounds_t>() == tuple_util::size<strides_t>());
 
     assert(reinterpret_cast<size_t>(sid::get_origin(testee)()) == expected_ptr);
     check_hymap(sid::get_strides(testee), expected_strides);
@@ -107,7 +107,7 @@ PYBIND11_MODULE(py_implementation, m) {
         "Copy from the 1D double buffer to a 3D one.");
     m.def(
         "copy_from_scalar",
-        [](double from, py::buffer to) { copy(make_global_parameter(from), as_sid<double, 3>(to)); },
+        [](double from, py::buffer to) { copy(global_parameter(from), as_sid<double, 3>(to)); },
         "Copy from the scalar to a 3D buffer of doubles.");
     m.def(
         "check_cuda_sid",
diff --git a/tests/regression/vertical_advection_dycore.cpp b/tests/regression/vertical_advection_dycore.cpp
index e00d48dee4..0b350dcbee 100644
--- a/tests/regression/vertical_advection_dycore.cpp
+++ b/tests/regression/vertical_advection_dycore.cpp
@@ -136,7 +136,7 @@ namespace {
                         wcon = TypeParam::make_storage(repo.wcon),
                         u_pos = TypeParam::make_storage(repo.u_pos),
                         utens = TypeParam::make_storage(repo.utens),
-                        dtr_stage = make_global_parameter(typename TypeParam::float_t(repo.dtr_stage))] {
+                        dtr_stage = global_parameter<typename TypeParam::float_t>(repo.dtr_stage)] {
             const auto spec = [](auto utens_stage, auto u_stage, auto wcon, auto u_pos, auto utens, auto dtr_stage) {
                 GT_DECLARE_TMP(typename TypeParam::float_t, ccol, dcol, data_col);
                 return multi_pass(
diff --git a/tests/unit_tests/CMakeLists.txt b/tests/unit_tests/CMakeLists.txt
index 6ed9874d90..d1a2f074cd 100644
--- a/tests/unit_tests/CMakeLists.txt
+++ b/tests/unit_tests/CMakeLists.txt
@@ -5,7 +5,7 @@ function(gridtools_check_compilation tgt)
         _gt_convert_to_cuda_source(sources ${ARGN})
         if (NOT sources STREQUAL ARGN)
             add_library(${tgt}_nvcc OBJECT ${sources})
-            target_link_libraries(${tgt}_nvcc gridtools)
+            target_link_libraries(${tgt}_nvcc gridtools _gridtools_nvcc)
         endif()
     endif()
 endfunction()
diff --git a/tests/unit_tests/boundaries/test_bindbc_utilities.cpp b/tests/unit_tests/boundaries/test_bindbc_utilities.cpp
index d905740b10..c356c7c65e 100644
--- a/tests/unit_tests/boundaries/test_bindbc_utilities.cpp
+++ b/tests/unit_tests/boundaries/test_bindbc_utilities.cpp
@@ -37,9 +37,9 @@ namespace collect_indices {
         typename bd::_impl::comm_indices<std::tuple<>>::collect_indices<0, std::index_sequence<>, Tuple>::type,
         std::index_sequence<Is...>>::value;
 
-    static_assert(testee<std::tuple<int, int>, 0, 1>, "");
-    static_assert(testee<std::tuple<int, decltype(_1), int, decltype(_2)>, 0, 2>, "");
-    static_assert(testee<std::tuple<decltype(_1), decltype(_2)>>, "");
+    static_assert(testee<std::tuple<int, int>, 0, 1>);
+    static_assert(testee<std::tuple<int, decltype(_1), int, decltype(_2)>, 0, 2>);
+    static_assert(testee<std::tuple<decltype(_1), decltype(_2)>>);
 } // namespace collect_indices
 
 TEST(DistributedBoundaries, RestTuple) {
@@ -48,10 +48,10 @@ TEST(DistributedBoundaries, RestTuple) {
     EXPECT_EQ(bd::_impl::rest_tuple(std::make_tuple(1, 2), std::make_index_sequence<1>{}), std::make_tuple(2));
 }
 
-static_assert(!bd::_impl::contains_placeholders<decltype(std::make_tuple(3, 4, 5))>::value, "");
-static_assert(!bd::_impl::contains_placeholders<decltype(std::make_tuple())>::value, "");
-static_assert(bd::_impl::contains_placeholders<decltype(std::make_tuple(3, 4, _1))>::value, "");
-static_assert(bd::_impl::contains_placeholders<decltype(std::make_tuple(3, _2, 5))>::value, "");
+static_assert(!bd::_impl::contains_placeholders<decltype(std::make_tuple(3, 4, 5))>::value);
+static_assert(!bd::_impl::contains_placeholders<decltype(std::make_tuple())>::value);
+static_assert(bd::_impl::contains_placeholders<decltype(std::make_tuple(3, 4, _1))>::value);
+static_assert(bd::_impl::contains_placeholders<decltype(std::make_tuple(3, _2, 5))>::value);
 
 TEST(DistributedBoundaries, BoundBC) {
     const auto builder = gt::storage::builder<gt::storage::cpu_kfirst>.type<double>().dimensions(3, 3, 3);
diff --git a/tests/unit_tests/common/CMakeLists.txt b/tests/unit_tests/common/CMakeLists.txt
index 8b8982eab1..adf042dc75 100644
--- a/tests/unit_tests/common/CMakeLists.txt
+++ b/tests/unit_tests/common/CMakeLists.txt
@@ -9,7 +9,6 @@ gridtools_add_unit_test(test_array SOURCES test_array.cpp)
 gridtools_add_unit_test(test_compose SOURCES test_compose.cpp)
 gridtools_add_unit_test(test_hugepage_alloc SOURCES test_hugepage_alloc.cpp)
 gridtools_add_unit_test(test_hymap SOURCES test_hymap.cpp)
-gridtools_add_unit_test(test_pair SOURCES test_pair.cpp)
 gridtools_add_unit_test(test_stride_util SOURCES test_stride_util.cpp)
 gridtools_add_unit_test(test_tuple_util SOURCES test_tuple_util.cpp)
 gridtools_add_unit_test(test_for_each SOURCES test_for_each.cpp)
diff --git a/tests/unit_tests/common/test_array.cpp b/tests/unit_tests/common/test_array.cpp
index f28696e1bf..4862920464 100644
--- a/tests/unit_tests/common/test_array.cpp
+++ b/tests/unit_tests/common/test_array.cpp
@@ -12,6 +12,8 @@
 
 #include <gtest/gtest.h>
 
+#include <gridtools/common/defs.hpp>
+
 using namespace gridtools;
 
 TEST(array, test_copyctr) {
@@ -35,8 +37,8 @@ namespace constexpr_compare {
     constexpr array<uint_t, 3> b{0, 0, 0};
     constexpr array<uint_t, 3> c{0, 0, 1};
 
-    static_assert(a == b, "");
-    static_assert(a != c, "");
+    static_assert(a == b);
+    static_assert(a != c);
 } // namespace constexpr_compare
 
 TEST(array, iterate) {
diff --git a/tests/unit_tests/common/test_cuda_type_traits.cu b/tests/unit_tests/common/test_cuda_type_traits.cu
index bdd3d4d51b..ed4219866f 100644
--- a/tests/unit_tests/common/test_cuda_type_traits.cu
+++ b/tests/unit_tests/common/test_cuda_type_traits.cu
@@ -12,8 +12,8 @@
 #include <gridtools/common/defs.hpp>
 
 namespace gridtools {
-    static_assert(is_texture_type<int>::value, "");
-    static_assert(!is_texture_type<bool>::value, "");
-    static_assert(is_texture_type<double>::value, "");
-    static_assert(is_texture_type<uint_t>::value, "");
+    static_assert(is_texture_type<int>::value);
+    static_assert(!is_texture_type<bool>::value);
+    static_assert(is_texture_type<double>::value);
+    static_assert(is_texture_type<uint_t>::value);
 } // namespace gridtools
diff --git a/tests/unit_tests/common/test_for_each.cpp b/tests/unit_tests/common/test_for_each.cpp
index 6eeb755f30..25a7a2e566 100644
--- a/tests/unit_tests/common/test_for_each.cpp
+++ b/tests/unit_tests/common/test_for_each.cpp
@@ -15,15 +15,13 @@
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
-#include <gridtools/common/host_device.hpp>
-
 namespace gridtools {
 
     struct f {
         int *&dst;
 
         template <class T>
-        GT_FUNCTION_WARNING void operator()(T) const {
+        void operator()(T) const {
             *(dst++) = T::value;
         }
     };
@@ -62,13 +60,6 @@ namespace gridtools {
             for_each<lst<my_int_t<2>>>(f{res});
             return res;
         }
-        static_assert(foo() == 2, "");
+        static_assert(foo() == 2);
     } // namespace test_constexpr
-
-    TEST(for_each, targets) {
-        int *ptr = nullptr;
-        for_each<lst<>>(f{ptr});
-        host::for_each<lst<>>(f{ptr});
-        host_device::for_each<lst<>>(f{ptr});
-    }
 } // namespace gridtools
diff --git a/tests/unit_tests/common/test_gt_math.cpp b/tests/unit_tests/common/test_gt_math.cpp
index 57ca7dafba..6efd324bba 100644
--- a/tests/unit_tests/common/test_gt_math.cpp
+++ b/tests/unit_tests/common/test_gt_math.cpp
@@ -32,12 +32,12 @@ bool GT_FUNCTION test_exp(Value val, Value result) {
     return expect_with_threshold(math::exp(val), result);
 }
 
-static_assert(std::is_same<decltype(math::fabs(4.0f)), float>::value, "");
-static_assert(std::is_same<decltype(math::fabs(4.0)), double>::value, "");
+static_assert(std::is_same_v<decltype(math::fabs(4.0f)), float>);
+static_assert(std::is_same_v<decltype(math::fabs(4.0)), double>);
 #ifndef __CUDA_ARCH__
-static_assert(std::is_same<decltype(math::fabs((long double)4)), long double>::value, "");
+static_assert(std::is_same_v<decltype(math::fabs((long double)4)), long double>);
 #endif
-static_assert(std::is_same<decltype(math::fabs((int)4)), double>::value, "");
+static_assert(std::is_same_v<decltype(math::fabs((int)4)), double>);
 
 bool GT_FUNCTION test_fabs() {
     if (!expect_with_threshold(math::fabs(5.6), 5.6, 1e-14))
@@ -56,16 +56,16 @@ bool GT_FUNCTION test_fabs() {
         return true;
 }
 
-static_assert(std::is_same<decltype(math::abs(4.0f)), float>::value, "");
-static_assert(std::is_same<decltype(math::abs(4.0)), double>::value, "");
+static_assert(std::is_same_v<decltype(math::abs(4.0f)), float>);
+static_assert(std::is_same_v<decltype(math::abs(4.0)), double>);
 #ifndef __CUDA_ARCH__
-static_assert(std::is_same<decltype(math::abs((long double)4)), long double>::value, "");
+static_assert(std::is_same_v<decltype(math::abs((long double)4)), long double>);
 #endif
 
 // int overloads
-static_assert(std::is_same<decltype(math::abs((int)4)), int>::value, "");
-static_assert(std::is_same<decltype(math::abs((long)4)), long>::value, "");
-static_assert(std::is_same<decltype(math::abs((long long)4)), long long>::value, "");
+static_assert(std::is_same_v<decltype(math::abs((int)4)), int>);
+static_assert(std::is_same_v<decltype(math::abs((long)4)), long>);
+static_assert(std::is_same_v<decltype(math::abs((long long)4)), long long>);
 
 GT_FUNCTION bool test_abs() {
     // float overloads
diff --git a/tests/unit_tests/common/test_hymap.cpp b/tests/unit_tests/common/test_hymap.cpp
index e83a5f1204..14e45c0cab 100644
--- a/tests/unit_tests/common/test_hymap.cpp
+++ b/tests/unit_tests/common/test_hymap.cpp
@@ -25,21 +25,21 @@ namespace gridtools {
         struct b;
         struct c;
 
-        static_assert(!is_hymap<void>::value, "");
-        static_assert(is_hymap<std::array<int, 3>>::value, "");
-        static_assert(is_hymap<tuple<int, double>>::value, "");
-        static_assert(is_hymap<hymap::keys<>::values<>>::value, "");
-        static_assert(is_hymap<hymap::keys<a>::values<int>>::value, "");
-        static_assert(is_hymap<hymap::keys<a, b>::values<int, double>>::value, "");
+        static_assert(!is_hymap<void>::value);
+        static_assert(is_hymap<std::array<int, 3>>::value);
+        static_assert(is_hymap<tuple<int, double>>::value);
+        static_assert(is_hymap<hymap::keys<>::values<>>::value);
+        static_assert(is_hymap<hymap::keys<a>::values<int>>::value);
+        static_assert(is_hymap<hymap::keys<a, b>::values<int, double>>::value);
 
         TEST(tuple_like, smoke) {
             using testee_t = hymap::keys<a, b, c>::values<int, double, void *>;
 
-            static_assert(tuple_util::size<testee_t>::value == 3, "");
+            static_assert(tuple_util::size<testee_t>::value == 3);
 
-            static_assert(std::is_same<tuple_util::element<0, testee_t>, int>::value, "");
-            static_assert(std::is_same<tuple_util::element<1, testee_t>, double>::value, "");
-            static_assert(std::is_same<tuple_util::element<2, testee_t>, void *>::value, "");
+            static_assert(std::is_same_v<tuple_util::element<0, testee_t>, int>);
+            static_assert(std::is_same_v<tuple_util::element<1, testee_t>, double>);
+            static_assert(std::is_same_v<tuple_util::element<2, testee_t>, void *>);
 
             testee_t testee{42, 5.3, nullptr};
             EXPECT_EQ(42, tuple_util::get<0>(testee));
@@ -51,9 +51,9 @@ namespace gridtools {
             using testee_t = hymap::keys<a, b>::values<int, double>;
             testee_t testee{42, 5.3};
 
-            static_assert(has_key<testee_t, a>::value, "");
-            static_assert(has_key<testee_t, b>::value, "");
-            static_assert(!has_key<testee_t, c>::value, "");
+            static_assert(has_key<testee_t, a>::value);
+            static_assert(has_key<testee_t, b>::value);
+            static_assert(!has_key<testee_t, c>::value);
 
             EXPECT_EQ(42, at_key<a>(testee));
             EXPECT_EQ(5.3, at_key<b>(testee));
@@ -63,9 +63,9 @@ namespace gridtools {
             using testee_t = std::tuple<int, double>;
             testee_t testee{42, 5.3};
 
-            static_assert(has_key<testee_t, integral_constant<int, 0>>::value, "");
-            static_assert(has_key<testee_t, integral_constant<int, 1>>::value, "");
-            static_assert(!has_key<testee_t, integral_constant<int, 2>>::value, "");
+            static_assert(has_key<testee_t, integral_constant<int, 0>>::value);
+            static_assert(has_key<testee_t, integral_constant<int, 1>>::value);
+            static_assert(!has_key<testee_t, integral_constant<int, 2>>::value);
 
             EXPECT_EQ(42, (at_key<integral_constant<int, 0>>(testee)));
             EXPECT_EQ(5.3, (at_key<integral_constant<int, 1>>(testee)));
@@ -115,18 +115,16 @@ namespace gridtools {
             using src_t = hymap::keys<a, b>::values<int, double>;
             using dst_t = hymap::to_meta_map<src_t>;
 
-            static_assert(std::is_same<meta::second<meta::mp_find<dst_t, a>>, int>(), "");
-            static_assert(std::is_same<meta::second<meta::mp_find<dst_t, b>>, double>(), "");
+            static_assert(std::is_same_v<meta::second<meta::mp_find<dst_t, a>>, int>);
+            static_assert(std::is_same_v<meta::second<meta::mp_find<dst_t, b>>, double>);
         }
 
         TEST(from_meta_map, smoke) {
             using src_t = meta::list<meta::list<a, int>, meta::list<b, double>>;
             using dst_t = hymap::from_meta_map<src_t>;
 
-            static_assert(
-                std::is_same<typename std::decay<decltype(at_key<a>(std::declval<dst_t>()))>::type, int>(), "");
-            static_assert(
-                std::is_same<typename std::decay<decltype(at_key<b>(std::declval<dst_t>()))>::type, double>(), "");
+            static_assert(std::is_same_v<element_at<a, dst_t>, int>);
+            static_assert(std::is_same_v<element_at<b, dst_t>, double>);
         }
 
         TEST(from_meta_map, empty) {
diff --git a/tests/unit_tests/common/test_hypercube_iterator.cpp b/tests/unit_tests/common/test_hypercube_iterator.cpp
index 26dd720679..e962ac8ff0 100644
--- a/tests/unit_tests/common/test_hypercube_iterator.cpp
+++ b/tests/unit_tests/common/test_hypercube_iterator.cpp
@@ -10,14 +10,15 @@
 
 #include <gridtools/common/hypercube_iterator.hpp>
 
-#include <gridtools/common/pair.hpp>
-#include <gridtools/common/tuple.hpp>
-#include <gridtools/common/tuple_util.hpp>
 #include <vector>
+#include <utility>
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
+#include <gridtools/common/tuple.hpp>
+#include <gridtools/common/tuple_util.hpp>
+
 using namespace gridtools;
 
 class hypercube_iteration : public ::testing::Test {
@@ -47,12 +48,12 @@ class hypercube_iteration : public ::testing::Test {
 
 TEST_F(hypercube_iteration, view_from_array_of_ranges) {
     expect_ranges({1, 3}, {4, 8}, {2, 10});
-    call_testee(array{pair(1, 3), pair(4, 8), pair(2, 10)});
+    call_testee(array{std::pair(1, 3), std::pair(4, 8), std::pair(2, 10)});
 }
 
 TEST_F(hypercube_iteration, view_from_tuple_of_ranges) {
     expect_ranges({1, 3}, {4, 8}, {2, 10});
-    call_testee(tuple(pair(1, 3), pair(4, 8), pair(2, 10)));
+    call_testee(tuple(std::pair(1, 3), std::pair(4, 8), std::pair(2, 10)));
 }
 
 TEST_F(hypercube_iteration, from_array_of_integers) {
@@ -62,7 +63,7 @@ TEST_F(hypercube_iteration, from_array_of_integers) {
 
 TEST_F(hypercube_iteration, from_zero_to_zero) {
     expect_ranges({}, {}, {});
-    call_testee(array{pair(0, 0), pair(0, 0), pair(0, 0)});
+    call_testee(array{std::pair(0, 0), std::pair(0, 0), std::pair(0, 0)});
 }
 
 TEST_F(hypercube_iteration, from_one_to_one) {
@@ -72,8 +73,8 @@ TEST_F(hypercube_iteration, from_one_to_one) {
 
 TEST(hypercube_view_empty_iteration_space, zero_dimensional_range) {
     int count = 0;
-    for (auto it : make_hypercube_view(array<pair<size_t, size_t>, 0>())) {
-        static_assert(tuple_util::size<decltype(it)>::value == 0, "");
+    for (auto it : make_hypercube_view(array<std::pair<size_t, size_t>, 0>())) {
+        static_assert(tuple_util::size<decltype(it)>::value == 0);
         ++count;
     }
     EXPECT_EQ(1, count);
@@ -82,7 +83,7 @@ TEST(hypercube_view_empty_iteration_space, zero_dimensional_range) {
 TEST(hypercube_view_empty_iteration_space, zero_dimensional_size) {
     int count = 0;
     for (auto it : make_hypercube_view(array<size_t, 0>())) {
-        static_assert(tuple_util::size<decltype(it)>::value == 0, "");
+        static_assert(tuple_util::size<decltype(it)>::value == 0);
         ++count;
     }
     EXPECT_EQ(1, count);
diff --git a/tests/unit_tests/common/test_hypercube_iterator.cu b/tests/unit_tests/common/test_hypercube_iterator.cu
index c110d24761..cd493bafa7 100644
--- a/tests/unit_tests/common/test_hypercube_iterator.cu
+++ b/tests/unit_tests/common/test_hypercube_iterator.cu
@@ -13,7 +13,7 @@
 
 static const size_t Size = 2;
 
-GT_FUNCTION int linear_index(gridtools::array<size_t, 2> &index) { return index[0] * Size + index[1]; }
+constexpr int linear_index(gridtools::array<size_t, 2> &index) { return index[0] * Size + index[1]; }
 
 __global__ void test_kernel(int *out_ptr) {
     for (size_t i = 0; i < Size * Size; ++i)
diff --git a/tests/unit_tests/common/test_int_vector.cu b/tests/unit_tests/common/test_int_vector.cu
index ac020dfcc1..a46718519d 100644
--- a/tests/unit_tests/common/test_int_vector.cu
+++ b/tests/unit_tests/common/test_int_vector.cu
@@ -38,9 +38,9 @@ namespace gridtools {
 
             auto testee = on_device::exec(GT_MAKE_INTEGRAL_CONSTANT_FROM_VALUE(&plus_device), m1, m2);
 
-            static_assert(std::is_same<int, std::decay_t<decltype(at_key<a>(testee))>>::value);
-            static_assert(std::is_same<long int, std::decay_t<decltype(at_key<b>(testee))>>::value);
-            static_assert(std::is_same<unsigned int, std::decay_t<decltype(at_key<c>(testee))>>::value);
+            static_assert(std::is_same_v<int, std::decay_t<decltype(at_key<a>(testee))>>);
+            static_assert(std::is_same_v<long int, std::decay_t<decltype(at_key<b>(testee))>>);
+            static_assert(std::is_same_v<unsigned int, std::decay_t<decltype(at_key<c>(testee))>>);
 
             EXPECT_EQ(1, at_key<a>(testee));
             EXPECT_EQ(12, at_key<b>(testee));
@@ -73,7 +73,7 @@ namespace gridtools {
 
             EXPECT_EQ(1, at_key<a>(testee));
             static_assert(!has_key<decltype(testee), b>());
-            static_assert(std::is_same<integral_constant<int, 2>, std::decay_t<decltype(at_key<c>(testee))>>::value);
+            static_assert(std::is_same_v<integral_constant<int, 2>, std::decay_t<decltype(at_key<c>(testee))>>);
         }
 
     } // namespace
diff --git a/tests/unit_tests/common/test_integral_constant.cpp b/tests/unit_tests/common/test_integral_constant.cpp
index d3cc6f2a80..d020b8354d 100644
--- a/tests/unit_tests/common/test_integral_constant.cpp
+++ b/tests/unit_tests/common/test_integral_constant.cpp
@@ -14,21 +14,21 @@ namespace gridtools {
     namespace {
         using namespace literals;
 
-        static_assert(0_c == 0, "");
-        static_assert(42_c == 42, "");
-        static_assert(-12345_c == -12345, "");
+        static_assert(0_c == 0);
+        static_assert(42_c == 42);
+        static_assert(-12345_c == -12345);
 
-        static_assert(0b100_c == 0b100, "");
-        static_assert(0100_c == 0100, "");
-        static_assert(0xDEAD_c == 0xDEAD, "");
+        static_assert(0b100_c == 0b100);
+        static_assert(0100_c == 0100);
+        static_assert(0xDEAD_c == 0xDEAD);
 
-        static_assert(1'000_c == 1000, "");
+        static_assert(1'000_c == 1000);
 
-        static_assert(2_c + 3_c == 5_c, "");
+        static_assert(2_c + 3_c == 5_c);
 
-        static_assert(is_integral_constant<integral_constant<int, 42>>::value, "");
-        static_assert(is_integral_constant<std::integral_constant<int, 42>>::value, "");
-        static_assert(is_gr_integral_constant<integral_constant<int, 42>>::value, "");
-        static_assert(!is_gr_integral_constant<std::integral_constant<int, 42>>::value, "");
+        static_assert(is_integral_constant<integral_constant<int, 42>>::value);
+        static_assert(is_integral_constant<std::integral_constant<int, 42>>::value);
+        static_assert(is_gr_integral_constant<integral_constant<int, 42>>::value);
+        static_assert(!is_gr_integral_constant<std::integral_constant<int, 42>>::value);
     } // namespace
 } // namespace gridtools
diff --git a/tests/unit_tests/common/test_layout_map.cpp b/tests/unit_tests/common/test_layout_map.cpp
index bb6e7fab3a..73c4d992f1 100644
--- a/tests/unit_tests/common/test_layout_map.cpp
+++ b/tests/unit_tests/common/test_layout_map.cpp
@@ -15,55 +15,55 @@ namespace simple_layout {
     typedef layout_map<0, 1, 2> layout1;
 
     // test length
-    static_assert(layout1::masked_length == 3, "");
-    static_assert(layout1::unmasked_length == 3, "");
+    static_assert(layout1::masked_length == 3);
+    static_assert(layout1::unmasked_length == 3);
 
     // test find method
-    static_assert(layout1::find(0) == 0, "");
-    static_assert(layout1::find(1) == 1, "");
-    static_assert(layout1::find(2) == 2, "");
+    static_assert(layout1::find(0) == 0);
+    static_assert(layout1::find(1) == 1);
+    static_assert(layout1::find(2) == 2);
 
     // test at method
-    static_assert(layout1::at(0) == 0, "");
-    static_assert(layout1::at(1) == 1, "");
-    static_assert(layout1::at(2) == 2, "");
+    static_assert(layout1::at(0) == 0);
+    static_assert(layout1::at(1) == 1);
+    static_assert(layout1::at(2) == 2);
 } // namespace simple_layout
 
 namespace extended_layout {
     typedef layout_map<3, 2, 1, 0> layout2;
 
     // test length
-    static_assert(layout2::masked_length == 4, "");
-    static_assert(layout2::unmasked_length == 4, "");
+    static_assert(layout2::masked_length == 4);
+    static_assert(layout2::unmasked_length == 4);
 
     // test find method
-    static_assert(layout2::find(0) == 3, "");
-    static_assert(layout2::find(1) == 2, "");
-    static_assert(layout2::find(2) == 1, "");
-    static_assert(layout2::find(3) == 0, "");
+    static_assert(layout2::find(0) == 3);
+    static_assert(layout2::find(1) == 2);
+    static_assert(layout2::find(2) == 1);
+    static_assert(layout2::find(3) == 0);
 
     // test at method
-    static_assert(layout2::at(0) == 3, "");
-    static_assert(layout2::at(1) == 2, "");
-    static_assert(layout2::at(2) == 1, "");
-    static_assert(layout2::at(3) == 0, "");
+    static_assert(layout2::at(0) == 3);
+    static_assert(layout2::at(1) == 2);
+    static_assert(layout2::at(2) == 1);
+    static_assert(layout2::at(3) == 0);
 } // namespace extended_layout
 
 namespace masked_layout {
     typedef layout_map<2, -1, 1, 0> layout3;
 
     // test length
-    static_assert(layout3::masked_length == 4, "");
-    static_assert(layout3::unmasked_length == 3, "");
+    static_assert(layout3::masked_length == 4);
+    static_assert(layout3::unmasked_length == 3);
 
     // test find method
-    static_assert(layout3::find(0) == 3, "");
-    static_assert(layout3::find(1) == 2, "");
-    static_assert(layout3::find(2) == 0, "");
+    static_assert(layout3::find(0) == 3);
+    static_assert(layout3::find(1) == 2);
+    static_assert(layout3::find(2) == 0);
 
     // test at method
-    static_assert(layout3::at(0) == 2, "");
-    static_assert(layout3::at(1) == -1, "");
-    static_assert(layout3::at(2) == 1, "");
-    static_assert(layout3::at(3) == 0, "");
+    static_assert(layout3::at(0) == 2);
+    static_assert(layout3::at(1) == -1);
+    static_assert(layout3::at(2) == 1);
+    static_assert(layout3::at(3) == 0);
 } // namespace masked_layout
diff --git a/tests/unit_tests/common/test_pair.cpp b/tests/unit_tests/common/test_pair.cpp
deleted file mode 100644
index 9df5f0c882..0000000000
--- a/tests/unit_tests/common/test_pair.cpp
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
- * GridTools
- *
- * Copyright (c) 2014-2021, ETH Zurich
- * All rights reserved.
- *
- * Please, refer to the LICENSE file in the root directory.
- * SPDX-License-Identifier: BSD-3-Clause
- */
-#include <gridtools/common/pair.hpp>
-
-#include <type_traits>
-
-#include <gtest/gtest.h>
-
-TEST(pair, non_uniform_ctor) {
-    int int_val = 1;
-    size_t size_t_val = 2;
-
-    gridtools::pair<size_t, size_t> my_pair(int_val, size_t_val);
-
-    EXPECT_EQ((size_t)int_val, my_pair.first);
-    EXPECT_EQ(size_t_val, my_pair.second);
-}
-
-TEST(pair, get_rval_ref) {
-    size_t val0 = 1;
-    size_t val1 = 2;
-
-    EXPECT_TRUE(
-        std::is_rvalue_reference<decltype(gridtools::get<0>(gridtools::pair<size_t, size_t>{val0, val1}))>::value);
-    EXPECT_EQ(val0, gridtools::get<0>(gridtools::pair<size_t, size_t>{val0, val1}));
-    EXPECT_EQ(val1, gridtools::get<1>(gridtools::pair<size_t, size_t>{val0, val1}));
-}
-
-TEST(pair, eq) {
-    gridtools::pair<size_t, size_t> pair1{1, 2};
-    gridtools::pair<size_t, size_t> pair2{pair1};
-
-    EXPECT_TRUE(pair1 == pair2);
-    EXPECT_FALSE(pair1 != pair2);
-    EXPECT_FALSE(pair1 < pair2);
-    EXPECT_TRUE(pair1 <= pair2);
-    EXPECT_FALSE(pair1 > pair2);
-    EXPECT_TRUE(pair1 >= pair2);
-}
-TEST(pair, compare_first_differ) {
-    gridtools::pair<size_t, size_t> smaller{1, 2};
-    gridtools::pair<size_t, size_t> bigger{2, 2};
-
-    EXPECT_FALSE(smaller == bigger);
-    EXPECT_TRUE(smaller != bigger);
-    EXPECT_TRUE(smaller < bigger);
-    EXPECT_TRUE(smaller <= bigger);
-    EXPECT_FALSE(smaller > bigger);
-    EXPECT_FALSE(smaller >= bigger);
-}
-
-TEST(pair, lt_gt_second_differ) {
-    gridtools::pair<size_t, size_t> smaller{1, 1};
-    gridtools::pair<size_t, size_t> bigger{1, 2};
-
-    EXPECT_FALSE(smaller == bigger);
-    EXPECT_TRUE(smaller != bigger);
-    EXPECT_TRUE(smaller < bigger);
-    EXPECT_TRUE(smaller <= bigger);
-    EXPECT_FALSE(smaller > bigger);
-    EXPECT_FALSE(smaller >= bigger);
-}
-
-TEST(pair, construct_from_std_pair) {
-    std::pair<size_t, size_t> std_pair{1, 2};
-
-    gridtools::pair<size_t, size_t> gt_pair(std_pair);
-
-    ASSERT_EQ(std_pair.first, gt_pair.first);
-    ASSERT_EQ(std_pair.second, gt_pair.second);
-}
diff --git a/tests/unit_tests/common/test_stride_util.cpp b/tests/unit_tests/common/test_stride_util.cpp
index 848a4ba7e7..d077000ede 100644
--- a/tests/unit_tests/common/test_stride_util.cpp
+++ b/tests/unit_tests/common/test_stride_util.cpp
@@ -27,7 +27,7 @@ namespace gridtools {
 
             TEST(make_strides_from_sizes, smoke) {
                 auto testee = make_strides_from_sizes(tuple(20, 30, 40));
-                static_assert(std::is_same<decltype(testee), tuple<integral_constant<int, 1>, int, int>>{}, "");
+                static_assert(std::is_same_v<decltype(testee), tuple<integral_constant<int, 1>, int, int>>);
 
                 EXPECT_EQ(1, tu::get<0>(testee));
                 EXPECT_EQ(20, tu::get<1>(testee));
@@ -36,10 +36,8 @@ namespace gridtools {
 
             TEST(make_strides_from_sizes, integral_constants) {
                 auto testee = make_strides_from_sizes(tuple(20_c, 30_c, 40));
-                static_assert(
-                    std::is_same<decltype(testee),
-                        tuple<integral_constant<int, 1>, integral_constant<int, 20>, integral_constant<int, 600>>>{},
-                    "");
+                static_assert(std::is_same_v<decltype(testee),
+                    tuple<integral_constant<int, 1>, integral_constant<int, 20>, integral_constant<int, 600>>>);
 
                 EXPECT_EQ(1, tu::get<0>(testee));
                 EXPECT_EQ(20, tu::get<1>(testee));
@@ -52,9 +50,8 @@ namespace gridtools {
 
             TEST(make_strides_from_sizes, hymap) {
                 auto testee = make_strides_from_sizes(hymap::keys<a, b, c>::make_values(20, 30, 40));
-                static_assert(
-                    std::is_same<decltype(testee), hymap::keys<a, b, c>::values<integral_constant<int, 1>, int, int>>{},
-                    "");
+                static_assert(std::is_same_v<decltype(testee),
+                    hymap::keys<a, b, c>::values<integral_constant<int, 1>, int, int>>);
 
                 EXPECT_EQ(1, at_key<a>(testee));
                 EXPECT_EQ(20, at_key<b>(testee));
@@ -68,7 +65,7 @@ namespace gridtools {
 
             TEST(total_size, integral_constants) {
                 auto testee = total_size(tuple(20_c, 30_c, 40_c));
-                static_assert(std::is_same<decltype(testee), integral_constant<int, 24000>>{}, "");
+                static_assert(std::is_same_v<decltype(testee), integral_constant<int, 24000>>);
 
                 EXPECT_EQ(24000, testee);
             }
diff --git a/tests/unit_tests/common/test_tuple.cpp b/tests/unit_tests/common/test_tuple.cpp
index 0cf3c4ceda..1c86a97c78 100644
--- a/tests/unit_tests/common/test_tuple.cpp
+++ b/tests/unit_tests/common/test_tuple.cpp
@@ -19,9 +19,9 @@
 
 namespace gridtools {
     namespace {
-        static_assert(is_tuple_like<tuple<>>::value, "");
-        static_assert(is_tuple_like<tuple<int, double>>::value, "");
-        static_assert(is_tuple_like<tuple<int, int const, int&&, int&, int const& >>::value, "");
+        static_assert(is_tuple_like<tuple<>>::value);
+        static_assert(is_tuple_like<tuple<int, double>>::value);
+        static_assert(is_tuple_like<tuple<int, int const, int &&, int &, int const &>>::value);
 
         template <size_t I>
         using an_empty = std::integral_constant<size_t, I>;
@@ -42,20 +42,20 @@ namespace gridtools {
         struct take_move_only {
             int value;
             take_move_only() = default;
-            GT_FUNCTION take_move_only(move_only src) : value(src.value) {}
+            constexpr take_move_only(move_only src) : value(src.value) {}
         };
 
         // empty base optimization works
-        static_assert(sizeof(tuple<an_empty<0>, an_empty<1>, an_empty<3>>) == sizeof(an_empty<0>), "");
+        static_assert(sizeof(tuple<an_empty<0>, an_empty<1>, an_empty<3>>) == sizeof(an_empty<0>));
 
-        static_assert(tuple_util::size<tuple<int, char, double, char>>() == 4, "");
-        static_assert(tuple_util::size<tuple<int>>() == 1, "");
-        static_assert(tuple_util::size<tuple<>>() == 0, "");
+        static_assert(tuple_util::size<tuple<int, char, double, char>>() == 4);
+        static_assert(tuple_util::size<tuple<int>>() == 1);
+        static_assert(tuple_util::size<tuple<>>() == 0);
 
-        static_assert(std::is_same<tuple_util::element<1, tuple<int, char, double, char>>, char>(), "");
-        static_assert(std::is_same<tuple_util::element<0, tuple<int>>, int>(), "");
+        static_assert(std::is_same_v<tuple_util::element<1, tuple<int, char, double, char>>, char>);
+        static_assert(std::is_same_v<tuple_util::element<0, tuple<int>>, int>);
 
-        using tuple_util::host_device::get;
+        using tuple_util::get;
 
         TEST(tuple, get) {
             tuple<int, double, an_empty<59>> testee;
@@ -83,13 +83,13 @@ namespace gridtools {
 
         TEST(tuple, move_get) {
             auto val = get<1>(tuple<char, move_only>{'a', move_only{2}});
-            static_assert(std::is_same<decltype(val), move_only>(), "");
+            static_assert(std::is_same_v<decltype(val), move_only>);
             EXPECT_EQ(2, val.value);
         }
 
         TEST(one_tuple, move_get) {
             auto val = get<0>(tuple<move_only>{move_only{2}});
-            static_assert(std::is_same<decltype(val), move_only>(), "");
+            static_assert(std::is_same_v<decltype(val), move_only>);
             EXPECT_EQ(2, val.value);
         }
 
@@ -198,7 +198,7 @@ namespace gridtools {
             tuple<int, double> src = {1, 1.5};
             tuple<int, double> testee;
             auto &res = testee = src;
-            static_assert(std::is_same<decltype(res), tuple<int, double> &>(), "");
+            static_assert(std::is_same_v<decltype(res), tuple<int, double> &>);
             EXPECT_EQ(&testee, &res);
             EXPECT_EQ(1, get<0>(testee));
             EXPECT_EQ(1.5, get<1>(testee));
@@ -208,7 +208,7 @@ namespace gridtools {
             tuple<int> src = {1};
             tuple<int> testee;
             auto &res = testee = src;
-            static_assert(std::is_same<decltype(res), tuple<int> &>(), "");
+            static_assert(std::is_same_v<decltype(res), tuple<int> &>);
             EXPECT_EQ(&testee, &res);
             EXPECT_EQ(1, get<0>(testee));
         }
@@ -216,7 +216,7 @@ namespace gridtools {
         TEST(tuple, move_assign) {
             tuple<move_only, move_only> testee;
             auto &res = testee = tuple<move_only, move_only>{move_only{47}, move_only{2}};
-            static_assert(std::is_same<decltype(res), tuple<move_only, move_only> &>(), "");
+            static_assert(std::is_same_v<decltype(res), tuple<move_only, move_only> &>);
             EXPECT_EQ(&testee, &res);
             EXPECT_EQ(47, get<0>(testee).value);
             EXPECT_EQ(2, get<1>(testee).value);
@@ -225,7 +225,7 @@ namespace gridtools {
         TEST(one_tuple, move_assign) {
             tuple<take_move_only> testee;
             auto &res = testee = tuple<move_only>{move_only{47}};
-            static_assert(std::is_same<decltype(res), tuple<take_move_only> &>(), "");
+            static_assert(std::is_same_v<decltype(res), tuple<take_move_only> &>);
             EXPECT_EQ(&testee, &res);
             EXPECT_EQ(47, get<0>(testee).value);
         }
@@ -234,7 +234,7 @@ namespace gridtools {
             tuple<char, char> src = {'a', 'b'};
             tuple<int, double> testee;
             auto &res = testee = src;
-            static_assert(std::is_same<decltype(res), tuple<int, double> &>(), "");
+            static_assert(std::is_same_v<decltype(res), tuple<int, double> &>);
             EXPECT_EQ(&testee, &res);
             EXPECT_EQ('a', get<0>(testee));
             EXPECT_EQ('b', get<1>(testee));
@@ -244,7 +244,7 @@ namespace gridtools {
             tuple<char> src = {'a'};
             tuple<int> testee;
             auto &res = testee = src;
-            static_assert(std::is_same<decltype(res), tuple<int> &>(), "");
+            static_assert(std::is_same_v<decltype(res), tuple<int> &>);
             EXPECT_EQ(&testee, &res);
             EXPECT_EQ('a', get<0>(testee));
         }
@@ -252,7 +252,7 @@ namespace gridtools {
         TEST(tuple, move_conversion_assign) {
             tuple<double, move_only> testee;
             auto &res = testee = tuple<char, move_only>{'a', move_only{2}};
-            static_assert(std::is_same<decltype(res), tuple<double, move_only> &>(), "");
+            static_assert(std::is_same_v<decltype(res), tuple<double, move_only> &>);
             EXPECT_EQ(&testee, &res);
             EXPECT_EQ('a', get<0>(testee));
             EXPECT_EQ(2, get<1>(testee).value);
@@ -261,7 +261,7 @@ namespace gridtools {
         TEST(one_tuple, move_conversion_assign) {
             tuple<take_move_only> testee;
             auto &res = testee = tuple<move_only>{move_only{2}};
-            static_assert(std::is_same<decltype(res), tuple<take_move_only> &>(), "");
+            static_assert(std::is_same_v<decltype(res), tuple<take_move_only> &>);
             EXPECT_EQ(&testee, &res);
             EXPECT_EQ(2, get<0>(testee).value);
         }
@@ -303,20 +303,20 @@ namespace gridtools {
             tuple<> dst;
 
             auto copy = src;
-            static_assert(std::is_same<decltype(copy), tuple<>>(), "");
+            static_assert(std::is_same_v<decltype(copy), tuple<>>);
             EXPECT_NE(&src, &copy);
 
             auto move = tuple<>{};
-            static_assert(std::is_same<decltype(move), tuple<>>(), "");
+            static_assert(std::is_same_v<decltype(move), tuple<>>);
             // make nvcc happy
             EXPECT_EQ(&move, &move);
 
             auto &copy_assign = dst = src;
-            static_assert(std::is_same<decltype(copy_assign), tuple<> &>(), "");
+            static_assert(std::is_same_v<decltype(copy_assign), tuple<> &>);
             EXPECT_EQ(&dst, &copy_assign);
 
             auto &move_assign = dst = tuple<>{};
-            static_assert(std::is_same<decltype(move_assign), tuple<> &>(), "");
+            static_assert(std::is_same_v<decltype(move_assign), tuple<> &>);
             EXPECT_EQ(&dst, &move_assign);
 
             src.swap(dst);
diff --git a/tests/unit_tests/common/test_tuple.cu b/tests/unit_tests/common/test_tuple.cu
index 97a9ce011d..d12db92da3 100644
--- a/tests/unit_tests/common/test_tuple.cu
+++ b/tests/unit_tests/common/test_tuple.cu
@@ -21,16 +21,16 @@
 namespace gridtools {
     TEST(tuple, get) {
         tuple<int, double> src{42, 2.5};
-        EXPECT_EQ(42, on_device::exec(tuple_util::host_device::get_nth_f<0>{}, src));
-        EXPECT_EQ(2.5, on_device::exec(tuple_util::host_device::get_nth_f<1>{}, src));
+        EXPECT_EQ(42, on_device::exec(tuple_util::get_f<0>{}, src));
+        EXPECT_EQ(2.5, on_device::exec(tuple_util::get_f<1>{}, src));
     }
 
     __device__ tuple<int, double> element_wise_ctor(int x, double y) { return {x, y}; }
 
     TEST(tuple, element_wise_ctor) {
         tuple<int, double> testee = on_device::exec(GT_MAKE_INTEGRAL_CONSTANT_FROM_VALUE(&element_wise_ctor), 42, 2.5);
-        EXPECT_EQ(42, tuple_util::host::get<0>(testee));
-        EXPECT_EQ(2.5, tuple_util::host::get<1>(testee));
+        EXPECT_EQ(42, tuple_util::get<0>(testee));
+        EXPECT_EQ(2.5, tuple_util::get<1>(testee));
     }
 
 #if defined(__clang__) && (__clang_major__ == 11 && __clang_minor__ == 0 && __clang_patchlevel__ == 0)
@@ -41,8 +41,8 @@ namespace gridtools {
     TEST(tuple, element_wise_conversion_ctor) {
         tuple<int, double> testee =
             on_device::exec(GT_MAKE_INTEGRAL_CONSTANT_FROM_VALUE(&element_wise_conversion_ctor), 'a', 'b');
-        EXPECT_EQ('a', tuple_util::host::get<0>(testee));
-        EXPECT_EQ('b', tuple_util::host::get<1>(testee));
+        EXPECT_EQ('a', tuple_util::get<0>(testee));
+        EXPECT_EQ('b', tuple_util::get<1>(testee));
     }
 
     __device__ tuple<int, double> tuple_conversion_ctor(tuple<char, char> const &src) { return src; }
@@ -50,8 +50,8 @@ namespace gridtools {
     TEST(tuple, tuple_conversion_ctor) {
         tuple<int, double> testee =
             on_device::exec(GT_MAKE_INTEGRAL_CONSTANT_FROM_VALUE(&tuple_conversion_ctor), tuple<char, char>{'a', 'b'});
-        EXPECT_EQ('a', tuple_util::host::get<0>(testee));
-        EXPECT_EQ('b', tuple_util::host::get<1>(testee));
+        EXPECT_EQ('a', tuple_util::get<0>(testee));
+        EXPECT_EQ('b', tuple_util::get<1>(testee));
     }
 #endif
 } // namespace gridtools
diff --git a/tests/unit_tests/common/test_tuple_util.cpp b/tests/unit_tests/common/test_tuple_util.cpp
index e7de8a1e52..256fcf0a4c 100644
--- a/tests/unit_tests/common/test_tuple_util.cpp
+++ b/tests/unit_tests/common/test_tuple_util.cpp
@@ -20,7 +20,6 @@
 #include <gridtools/common/array.hpp>
 #include <gridtools/common/defs.hpp>
 #include <gridtools/common/host_device.hpp>
-#include <gridtools/common/pair.hpp>
 #include <gridtools/meta.hpp>
 
 namespace custom {
@@ -31,16 +30,15 @@ namespace custom {
 
 namespace gridtools {
 
-    static_assert(!is_tuple_like<void>::value, "");
-    static_assert(!is_tuple_like<int>::value, "");
-    static_assert(is_tuple_like<std::array<int, 42>>::value, "");
-    static_assert(is_tuple_like<std::tuple<>>::value, "");
-    static_assert(is_tuple_like<std::tuple<int>>::value, "");
-    static_assert(is_tuple_like<std::pair<int, double>>::value, "");
-    static_assert(is_tuple_like<array<int, 42>>::value, "");
-    static_assert(is_tuple_like<pair<int, double>>::value, "");
-    static_assert(is_tuple_like<custom::foo>::value, "");
-    static_assert(is_tuple_like<std::tuple<int, int const, int &&, int &, int const &>>::value, "");
+    static_assert(!is_tuple_like<void>::value);
+    static_assert(!is_tuple_like<int>::value);
+    static_assert(is_tuple_like<std::array<int, 42>>::value);
+    static_assert(is_tuple_like<std::tuple<>>::value);
+    static_assert(is_tuple_like<std::tuple<int>>::value);
+    static_assert(is_tuple_like<std::pair<int, double>>::value);
+    static_assert(is_tuple_like<array<int, 42>>::value);
+    static_assert(is_tuple_like<custom::foo>::value);
+    static_assert(is_tuple_like<std::tuple<int, int const, int &&, int &, int const &>>::value);
 
 #ifdef __cpp_concepts
     static_assert(!concepts::tuple_like<int>);
@@ -77,7 +75,7 @@ namespace gridtools {
 
         struct add_2_f {
             template <class T>
-            GT_FUNCTION GT_CONSTEXPR T operator()(T val) const {
+            constexpr T operator()(T val) const {
                 return val + 2;
             }
         };
@@ -92,7 +90,7 @@ namespace gridtools {
             EXPECT_EQ(size<custom::foo>::value, 2);
 
             auto res = transform(add_2_f{}, custom::foo{42, 5.3});
-            static_assert(std::is_same<decltype(res), custom::foo>{}, "");
+            static_assert(std::is_same_v<decltype(res), custom::foo>);
             EXPECT_EQ(res.a, 44);
             EXPECT_EQ(res.b, 7.3);
         }
@@ -100,21 +98,21 @@ namespace gridtools {
         TEST(transform, functional) {
             auto src = std::tuple(42, 5.3);
             auto res = transform(add_2_f{}, src);
-            static_assert(std::is_same<decltype(res), decltype(src)>{}, "");
+            static_assert(std::is_same_v<decltype(res), decltype(src)>);
             EXPECT_EQ(res, std::tuple(44, 7.3));
         }
 
         TEST(transform, array) {
             auto src = std::array{42, 5};
             auto res = transform(add_2_f{}, src);
-            static_assert(std::is_same<decltype(res), decltype(src)>{}, "");
+            static_assert(std::is_same_v<decltype(res), decltype(src)>);
             EXPECT_THAT(res, testing::ElementsAre(44, 7));
         }
 
         TEST(transform, gt_array) {
             auto src = gridtools::array{42, 5};
-            auto res = host_device::transform(add_2_f{}, src);
-            static_assert(std::is_same<decltype(res), decltype(src)>{}, "");
+            auto res = transform(add_2_f{}, src);
+            static_assert(std::is_same_v<decltype(res), decltype(src)>);
             EXPECT_THAT(res, testing::ElementsAre(44, 7));
         }
 
@@ -130,7 +128,7 @@ namespace gridtools {
 
         struct add_index_f {
             template <size_t I, class T>
-            GT_FUNCTION GT_CONSTEXPR T operator()(T val) const {
+            constexpr T operator()(T val) const {
                 return val + I;
             }
         };
@@ -138,7 +136,7 @@ namespace gridtools {
         TEST(transform_index, functional) {
             auto src = std::tuple(42, 5.3);
             auto res = transform_index(add_index_f{}, src);
-            static_assert(std::is_same<decltype(res), decltype(src)>{}, "");
+            static_assert(std::is_same_v<decltype(res), decltype(src)>);
             EXPECT_EQ(res, std::tuple(42, 6.3));
         }
 
@@ -285,7 +283,6 @@ namespace gridtools {
 
         TEST(convert_to, tuple) {
             EXPECT_EQ(std::tuple(1, 2), convert_to<std::tuple>(std::array{1, 2}));
-            EXPECT_EQ(std::tuple(1, 2), convert_to<std::tuple>(gridtools::pair(1, 2)));
             EXPECT_EQ(std::pair(1, 2), convert_to<std::pair>(gridtools::array{1, 2}));
         }
 
@@ -303,14 +300,6 @@ namespace gridtools {
                 std::pair(std::array{1, 2, 3}, std::array{10, 20, 30}));
         }
 
-        TEST(all_of, functional) {
-            auto testee = all_of([](int i) { return i % 2; });
-            EXPECT_TRUE(testee(std::tuple(1, 3, 99, 7)));
-            EXPECT_FALSE(testee(std::tuple(1, 3, 2, 7, 100)));
-
-            EXPECT_TRUE(all_of([](int l, int r) { return l == r; }, std::tuple(1, 3, 99, 7), std::tuple(1, 3, 99, 7)));
-        }
-
         TEST(reverse, functional) { EXPECT_TRUE(reverse(std::tuple(1, 'a', 42.5)) == std::tuple(42.5, 'a', 1)); }
 
         TEST(insert, functional) { EXPECT_TRUE(insert<2>('a', std::tuple(1, 2, 3)) == std::tuple(1, 2, 'a', 3)); }
diff --git a/tests/unit_tests/fn/test_fn_scan.cpp b/tests/unit_tests/fn/test_fn_scan.cpp
index 9a2abc5fa0..5568b3388b 100644
--- a/tests/unit_tests/fn/test_fn_scan.cpp
+++ b/tests/unit_tests/fn/test_fn_scan.cpp
@@ -20,13 +20,13 @@ namespace gridtools::fn {
         using sid::property;
 
         struct sum_fold : fwd {
-            static GT_FUNCTION constexpr auto body() {
+            static constexpr auto body() {
                 return [](auto acc, auto const &iter) { return acc + *iter; };
             }
         };
 
         struct sum_scan : fwd {
-            static GT_FUNCTION constexpr auto body() {
+            static constexpr auto body() {
                 return scan_pass(
                     [](auto acc, auto const &iter) { return tuple(get<0>(acc) + *iter, get<1>(acc) * *iter); },
                     [](auto acc) { return get<0>(acc); });
@@ -34,17 +34,17 @@ namespace gridtools::fn {
         };
 
         struct sum_fold_with_logues : sum_fold {
-            static GT_FUNCTION constexpr auto prologue() {
+            static constexpr auto prologue() {
                 return tuple([](auto acc, auto const &iter) { return acc + 2 * *iter; });
             }
-            static GT_FUNCTION constexpr auto epilogue() {
+            static constexpr auto epilogue() {
                 return tuple([](auto acc, auto const &iter) { return acc + 3 * *iter; });
             }
         };
 
         struct make_iterator_mock {
-            auto operator()() const {
-                return [](auto tag, auto const &ptr, auto const &strides) { return at_key<decltype(tag)>(ptr); };
+            auto constexpr operator()() const {
+                return [](auto tag, auto const &ptr, auto const &) { return at_key<decltype(tag)>(ptr); };
             }
         };
 
@@ -56,10 +56,10 @@ namespace gridtools::fn {
             column_t b = {1, 2, 3, 4, 5};
             auto composite = sid::composite::keys<integral_constant<int, 0>, integral_constant<int, 1>>::make_values(
                 sid::synthetic()
-                    .set<property::origin>(sid::host_device::make_simple_ptr_holder(&a[0]))
+                    .set<property::origin>(sid::simple_ptr_holder(&a[0]))
                     .set<property::strides>(tuple(1_c)),
                 sid::synthetic()
-                    .set<property::origin>(sid::host_device::make_simple_ptr_holder(&b[0]))
+                    .set<property::origin>(sid::simple_ptr_holder(&b[0]))
                     .set<property::strides>(tuple(1_c)));
             auto ptr = sid::get_origin(composite)();
             auto strides = sid::get_strides(composite);
diff --git a/tests/unit_tests/fn/test_fn_scan.cu b/tests/unit_tests/fn/test_fn_scan.cu
index 76315043b6..c43892b9d8 100644
--- a/tests/unit_tests/fn/test_fn_scan.cu
+++ b/tests/unit_tests/fn/test_fn_scan.cu
@@ -23,23 +23,21 @@ namespace gridtools::fn {
         using sid::property;
 
         struct sum_scan : fwd {
-            static GT_FUNCTION constexpr auto body() {
+            static constexpr auto body() {
                 return scan_pass(
                     [](auto acc, auto const &iter) { return tuple(get<0>(acc) + *iter, get<1>(acc) * *iter); },
                     [](auto acc) { return get<0>(acc); });
             }
         };
         struct make_iterator_mock {
-            GT_FUNCTION auto operator()() const {
-                return [](auto tag, auto const &ptr, auto const &strides) {
-                    return host_device::at_key<decltype(tag)>(ptr);
-                };
+            constexpr auto operator()() const {
+                return [](auto tag, auto const &ptr, auto const &) { return at_key<decltype(tag)>(ptr); };
             }
         };
 
         struct device_fun {
             template <class Ptr, class Strides>
-            GT_FUNCTION auto operator()(Ptr ptr, Strides strides) const {
+            constexpr auto operator()(Ptr ptr, Strides strides) const {
                 using vdim_t = integral_constant<int, 0>;
                 return column_stage<vdim_t, sum_scan, make_iterator_mock, 0, 1>()(tuple(42, 1), 5, ptr, strides);
             }
@@ -52,10 +50,10 @@ namespace gridtools::fn {
             cudaMemcpy(b.get(), bh, 5 * sizeof(int), cudaMemcpyHostToDevice);
             auto composite = sid::composite::keys<integral_constant<int, 0>, integral_constant<int, 1>>::make_values(
                 sid::synthetic()
-                    .set<property::origin>(sid::host_device::make_simple_ptr_holder(a.get()))
+                    .set<property::origin>(sid::simple_ptr_holder(a.get()))
                     .set<property::strides>(tuple(1_c)),
                 sid::synthetic()
-                    .set<property::origin>(sid::host_device::make_simple_ptr_holder(b.get()))
+                    .set<property::origin>(sid::simple_ptr_holder(b.get()))
                     .set<property::strides>(tuple(1_c)));
             auto ptr = sid::get_origin(composite)();
             auto strides = sid::get_strides(composite);
diff --git a/tests/unit_tests/layout_transformation/test_layout_transformation.cpp b/tests/unit_tests/layout_transformation/test_layout_transformation.cpp
index 4606b8ecff..0493214abd 100644
--- a/tests/unit_tests/layout_transformation/test_layout_transformation.cpp
+++ b/tests/unit_tests/layout_transformation/test_layout_transformation.cpp
@@ -28,7 +28,7 @@ namespace {
     template <class T, class U, size_t N, size_t M, class Dims, class DstStrides, class SrcSrides>
     void testee(
         host, T (&dst)[N], U (&src)[M], Dims const &dims, DstStrides const &dst_strides, SrcSrides const &src_strides) {
-        static_assert(std::is_same<std::remove_all_extents_t<T>, std::remove_all_extents_t<U>>::value, "");
+        static_assert(std::is_same_v<std::remove_all_extents_t<T>, std::remove_all_extents_t<U>>);
         using data_t = std::remove_all_extents_t<T>;
         transform_layout((data_t *)dst, (data_t const *)src, dims, dst_strides, src_strides);
     }
@@ -43,7 +43,7 @@ namespace {
         Dims const &dims,
         DstStrides const &dst_strides,
         SrcSrides const &src_strides) {
-        static_assert(std::is_same<std::remove_all_extents_t<T>, std::remove_all_extents_t<U>>::value, "");
+        static_assert(std::is_same_v<std::remove_all_extents_t<T>, std::remove_all_extents_t<U>>);
         using data_t = std::remove_all_extents_t<T>;
         auto &src_arr = reinterpret_cast<array<U, M> &>(src);
         auto &dst_arr = reinterpret_cast<array<T, N> &>(dst);
@@ -58,6 +58,8 @@ namespace {
     using envs_t = meta::list<host>;
 #endif
 
+    static constexpr size_t one = 1;
+
     TEST(layout_transformation, 3D_reverse_layout) {
         for_each<envs_t>([](auto env) {
             constexpr size_t Nx = 4, Ny = 5, Nz = 6;
@@ -68,7 +70,7 @@ namespace {
                 src[i[0]][i[1]][i[2]] = 100 * i[0] + 10 * i[1] + i[2];
                 dst[i[2]][i[1]][i[0]] = -1;
             }
-            testee(env, dst, src, dims, array{1, Nx, Nx * Ny}, array{Ny * Nz, Nz, 1});
+            testee(env, dst, src, dims, array{one, Nx, Nx * Ny}, array{Ny * Nz, Nz, one});
             for (auto i : make_hypercube_view(dims))
                 EXPECT_DOUBLE_EQ(dst[i[2]][i[1]][i[0]], src[i[0]][i[1]][i[2]]);
         });
@@ -84,7 +86,7 @@ namespace {
                 src[i[0]][i[1]][i[2]][i[3]] = 1000 * i[0] + 100 * i[1] + 10 * i[2] + i[3];
                 dst[i[3]][i[2]][i[1]][i[0]] = -1;
             }
-            testee(env, dst, src, dims, array{1, Nx, Nx * Ny, Nx * Ny * Nz}, array{Ny * Nz * Nw, Nz * Nw, Nw, 1});
+            testee(env, dst, src, dims, array{one, Nx, Nx * Ny, Nx * Ny * Nz}, array{Ny * Nz * Nw, Nz * Nw, Nw, one});
             for (auto i : make_hypercube_view(dims))
                 EXPECT_DOUBLE_EQ(dst[i[3]][i[2]][i[1]][i[0]], src[i[0]][i[1]][i[2]][i[3]]);
         });
@@ -100,7 +102,7 @@ namespace {
                 src[i[0]][i[1]] = 100 * i[0] + 10 * i[1];
                 dst[i[1]][i[0]] = -1;
             }
-            testee(env, dst, src, dims, array{1, Nx}, array{Ny, 1});
+            testee(env, dst, src, dims, array{one, Nx}, array{Ny, one});
             for (auto i : make_hypercube_view(dims))
                 EXPECT_DOUBLE_EQ(dst[i[1]][i[0]], src[i[0]][i[1]]);
         });
diff --git a/tests/unit_tests/sid/test_sid_as_const.cpp b/tests/unit_tests/sid/test_sid_as_const.cpp
index a32c90b8ed..34d73d2b98 100644
--- a/tests/unit_tests/sid/test_sid_as_const.cpp
+++ b/tests/unit_tests/sid/test_sid_as_const.cpp
@@ -24,12 +24,12 @@ namespace gridtools {
 
         TEST(as_const, smoke) {
             double data = 42;
-            auto src = sid::synthetic().set<property::origin>(sid::host_device::make_simple_ptr_holder(&data));
+            auto src = sid::synthetic().set<property::origin>(sid::simple_ptr_holder(&data));
             auto testee = sid::as_const(src);
             using testee_t = decltype(testee);
 
-            static_assert(is_sid<testee_t>(), "");
-            static_assert(std::is_same<sid::ptr_type<testee_t>, double const *>(), "");
+            static_assert(is_sid<testee_t>());
+            static_assert(std::is_same_v<sid::ptr_type<testee_t>, double const *>);
             EXPECT_EQ(sid::get_origin(src)(), sid::get_origin(testee)());
         }
     } // namespace
diff --git a/tests/unit_tests/sid/test_sid_block.cpp b/tests/unit_tests/sid/test_sid_block.cpp
index f0979361aa..c901f62172 100644
--- a/tests/unit_tests/sid/test_sid_block.cpp
+++ b/tests/unit_tests/sid/test_sid_block.cpp
@@ -40,7 +40,7 @@ namespace gridtools {
 
             positional_t s;
             auto blocked_s = sid::block(s, blocks);
-            static_assert(is_sid<decltype(blocked_s)>(), "");
+            static_assert(is_sid<decltype(blocked_s)>());
 
             auto strides = sid::get_strides(blocked_s);
             for (int ib = 0; ib < domain_size_i; ib += block_size_i) {
@@ -74,10 +74,10 @@ namespace gridtools {
             const int block_size_1 = 5;
             const int block_size_2 = 2;
             auto blocked_s = sid::block(s, hymap::keys<dim::i>::make_values(block_size_1));
-            static_assert(is_sid<decltype(blocked_s)>(), "");
+            static_assert(is_sid<decltype(blocked_s)>());
             auto blocked_blocked_s =
                 sid::block(blocked_s, hymap::keys<sid::blocked_dim<dim::i>>::make_values(block_size_2));
-            static_assert(is_sid<decltype(blocked_blocked_s)>(), "");
+            static_assert(is_sid<decltype(blocked_blocked_s)>());
 
             auto ptr = sid::get_origin(blocked_blocked_s)();
             auto strides = sid::get_strides(blocked_blocked_s);
@@ -101,7 +101,7 @@ namespace gridtools {
             positional_t s;
 
             auto same_s = sid::block(s, hymap::keys<some_dim>::make_values(42));
-            static_assert(std::is_same<decltype(s), decltype(same_s)>(), "");
+            static_assert(std::is_same_v<decltype(s), decltype(same_s)>);
         }
 
         TEST(sid_block, reference_wrapper) {
@@ -110,7 +110,7 @@ namespace gridtools {
             const int domain_size = 20;
             const int block_size = 5;
             auto blocked_s = sid::block(std::ref(s), hymap::keys<dim::i>::make_values(block_size));
-            static_assert(is_sid<decltype(blocked_s)>(), "");
+            static_assert(is_sid<decltype(blocked_s)>());
 
             auto ptr = sid::get_origin(blocked_s)();
             auto strides = sid::get_strides(blocked_s);
@@ -138,10 +138,10 @@ namespace gridtools {
                          .set<sid::property::origin>(sid::simple_ptr_holder<int *>{nullptr})
                          .set<sid::property::strides>(strides)
                          .set<sid::property::strides_kind, void>();
-            static_assert(is_sid<decltype(s)>(), "");
+            static_assert(is_sid<decltype(s)>());
 
             auto blocked_s = sid::block(s, blocks);
-            static_assert(is_sid<decltype(blocked_s)>(), "");
+            static_assert(is_sid<decltype(blocked_s)>());
 
             auto blocked_strides = sid::get_strides(blocked_s);
             EXPECT_EQ(sid::get_stride<sid::blocked_dim<dim::i>>(blocked_strides), 2);
diff --git a/tests/unit_tests/sid/test_sid_composite.cpp b/tests/unit_tests/sid/test_sid_composite.cpp
index 7e491649d0..13429995a2 100644
--- a/tests/unit_tests/sid/test_sid_composite.cpp
+++ b/tests/unit_tests/sid/test_sid_composite.cpp
@@ -34,10 +34,10 @@ namespace gridtools {
 
         TEST(composite, empty) {
             using testee_t = sid::composite::keys<>::values<>;
-            static_assert(is_sid<testee_t>(), "");
-            static_assert(tu::size<sid::strides_type<testee_t>>::value == 0, "");
-            static_assert(tu::size<sid::ptr_holder_type<testee_t>>::value == 0, "");
-            static_assert(tu::size<sid::ptr_type<testee_t>>::value == 0, "");
+            static_assert(is_sid<testee_t>());
+            static_assert(tu::size<sid::strides_type<testee_t>>::value == 0);
+            static_assert(tu::size<sid::ptr_holder_type<testee_t>>::value == 0);
+            static_assert(tu::size<sid::ptr_type<testee_t>>::value == 0);
             testee_t testee;
             sid::get_strides(testee);
             *sid::get_origin(testee)();
@@ -50,9 +50,8 @@ namespace gridtools {
 #endif
             double const src = 42;
             double dst = 0;
-            sid::composite::keys<a, b>::values(
-                sid::synthetic().set<property::origin>(sid::host_device::make_simple_ptr_holder(&src)),
-                sid::synthetic().set<property::origin>(sid::host_device::make_simple_ptr_holder(&dst)));
+            sid::composite::keys<a, b>::values(sid::synthetic().set<property::origin>(sid::simple_ptr_holder(&src)),
+                sid::synthetic().set<property::origin>(sid::simple_ptr_holder(&dst)));
         }
 #endif
 
@@ -61,9 +60,9 @@ namespace gridtools {
             double dst = 0;
 
             auto testee = sid::composite::keys<a, b>::make_values(
-                sid::synthetic().set<property::origin>(sid::host_device::make_simple_ptr_holder(&src)),
-                sid::synthetic().set<property::origin>(sid::host_device::make_simple_ptr_holder(&dst)));
-            static_assert(is_sid<decltype(testee)>(), "");
+                sid::synthetic().set<property::origin>(sid::simple_ptr_holder(&src)),
+                sid::synthetic().set<property::origin>(sid::simple_ptr_holder(&dst)));
+            static_assert(is_sid<decltype(testee)>());
 
             auto ptrs = sid::get_origin(testee)();
             EXPECT_EQ(&src, at_key<a>(ptrs));
@@ -88,25 +87,25 @@ namespace gridtools {
 
             auto my_strides = array{1, 5, 15};
 
-            auto testee = sid::composite::keys<a, b, c, d>::make_values(                              //
-                sid::synthetic()                                                                      //
-                    .set<property::origin>(sid::host_device::make_simple_ptr_holder(&one[0]))         //
-                    .set<property::strides>(tuple(1_c))                                               //
-                ,                                                                                     //
-                sid::synthetic()                                                                      //
-                    .set<property::origin>(sid::host_device::make_simple_ptr_holder(&two))            //
-                ,                                                                                     //
-                sid::synthetic()                                                                      //
-                    .set<property::origin>(sid::host_device::make_simple_ptr_holder(&three[0][0][0])) //
-                    .set<property::strides>(my_strides)                                               //
-                    .set<property::strides_kind, my_strides_kind>()                                   //
-                ,                                                                                     //
-                sid::synthetic()                                                                      //
-                    .set<property::origin>(sid::host_device::make_simple_ptr_holder(&four[0][0][0]))  //
-                    .set<property::strides>(my_strides)                                               //
-                    .set<property::strides_kind, my_strides_kind>()                                   //
+            auto testee = sid::composite::keys<a, b, c, d>::make_values(            //
+                sid::synthetic()                                                    //
+                    .set<property::origin>(sid::simple_ptr_holder(&one[0]))         //
+                    .set<property::strides>(tuple(1_c))                             //
+                ,                                                                   //
+                sid::synthetic()                                                    //
+                    .set<property::origin>(sid::simple_ptr_holder(&two))            //
+                ,                                                                   //
+                sid::synthetic()                                                    //
+                    .set<property::origin>(sid::simple_ptr_holder(&three[0][0][0])) //
+                    .set<property::strides>(my_strides)                             //
+                    .set<property::strides_kind, my_strides_kind>()                 //
+                ,                                                                   //
+                sid::synthetic()                                                    //
+                    .set<property::origin>(sid::simple_ptr_holder(&four[0][0][0]))  //
+                    .set<property::strides>(my_strides)                             //
+                    .set<property::strides_kind, my_strides_kind>()                 //
             );
-            static_assert(is_sid<decltype(testee)>(), "");
+            static_assert(is_sid<decltype(testee)>());
 
             auto &&strides = sid::get_strides(testee);
             auto &&stride_i = sid::get_stride<dim_i>(strides);
@@ -178,21 +177,21 @@ namespace gridtools {
             char four[6][4][5] = {};
             auto strides_four = hymap::keys<dim_y, dim_z, dim_x>::make_values(1_c, 5_c, 20_c);
 
-            auto testee = sid::composite::keys<a, b, c, d>::make_values(                              //
-                sid::synthetic()                                                                      //
-                    .set<property::origin>(sid::host_device::make_simple_ptr_holder(&one[0]))         //
-                    .set<property::strides>(strides_one)                                              //
-                ,                                                                                     //
-                sid::synthetic()                                                                      //
-                    .set<property::origin>(sid::host_device::make_simple_ptr_holder(&two))            //
-                ,                                                                                     //
-                sid::synthetic()                                                                      //
-                    .set<property::origin>(sid::host_device::make_simple_ptr_holder(&three[0][0][0])) //
-                    .set<property::strides>(strides_three)                                            //
-                ,                                                                                     //
-                sid::synthetic()                                                                      //
-                    .set<property::origin>(sid::host_device::make_simple_ptr_holder(&four[0][0][0]))  //
-                    .set<property::strides>(strides_four)                                             //
+            auto testee = sid::composite::keys<a, b, c, d>::make_values(            //
+                sid::synthetic()                                                    //
+                    .set<property::origin>(sid::simple_ptr_holder(&one[0]))         //
+                    .set<property::strides>(strides_one)                            //
+                ,                                                                   //
+                sid::synthetic()                                                    //
+                    .set<property::origin>(sid::simple_ptr_holder(&two))            //
+                ,                                                                   //
+                sid::synthetic()                                                    //
+                    .set<property::origin>(sid::simple_ptr_holder(&three[0][0][0])) //
+                    .set<property::strides>(strides_three)                          //
+                ,                                                                   //
+                sid::synthetic()                                                    //
+                    .set<property::origin>(sid::simple_ptr_holder(&four[0][0][0]))  //
+                    .set<property::strides>(strides_four)                           //
             );
 
             auto &&strides = sid::get_strides(testee);
@@ -216,14 +215,14 @@ namespace gridtools {
             int one[1] = {};
             int two[1][1] = {};
 
-            auto testee = sid::composite::keys<a, b>::make_values(                               //
-                sid::synthetic()                                                                 //
-                    .set<property::origin>(sid::host_device::make_simple_ptr_holder(&one[0]))    //
-                    .set<property::strides>(tuple(1))                                            //
-                    .set<property::strides_kind, sid::unknown_kind>(),                           //
-                sid::synthetic()                                                                 //
-                    .set<property::origin>(sid::host_device::make_simple_ptr_holder(&two[0][0])) //
-                    .set<property::strides>(tuple(1, 1))                                         //
+            auto testee = sid::composite::keys<a, b>::make_values(             //
+                sid::synthetic()                                               //
+                    .set<property::origin>(sid::simple_ptr_holder(&one[0]))    //
+                    .set<property::strides>(tuple(1))                          //
+                    .set<property::strides_kind, sid::unknown_kind>(),         //
+                sid::synthetic()                                               //
+                    .set<property::origin>(sid::simple_ptr_holder(&two[0][0])) //
+                    .set<property::strides>(tuple(1, 1))                       //
                     .set<property::strides_kind, sid::unknown_kind>());
 
             auto &&strides = sid::get_strides(testee);
diff --git a/tests/unit_tests/sid/test_sid_concept.cpp b/tests/unit_tests/sid/test_sid_concept.cpp
index 62397a9c27..dca377fec6 100644
--- a/tests/unit_tests/sid/test_sid_concept.cpp
+++ b/tests/unit_tests/sid/test_sid_concept.cpp
@@ -24,10 +24,10 @@ namespace gridtools {
         using namespace literals;
 
         // several primitive not sids
-        static_assert(!is_sid<void>(), "");
-        static_assert(!is_sid<int>(), "");
+        static_assert(!is_sid<void>());
+        static_assert(!is_sid<int>());
         struct garbage {};
-        static_assert(!is_sid<garbage>(), "");
+        static_assert(!is_sid<garbage>());
 
         // fully custom defined sid
         namespace custom {
@@ -37,12 +37,12 @@ namespace gridtools {
             };
             struct ptr {
                 element *val;
-                GT_FUNCTION element &operator*() const { return *val; }
-                friend GT_FUNCTION ptr operator+(ptr, ptr_diff) { return {}; }
+                constexpr element &operator*() const { return *val; }
+                friend constexpr ptr operator+(ptr, ptr_diff) { return {}; }
             };
             struct stride {
-                friend GT_FUNCTION std::true_type sid_shift(ptr &, stride const &, int) { return {}; }
-                friend GT_FUNCTION std::false_type sid_shift(ptr_diff &, stride const &, int) { return {}; }
+                friend constexpr std::true_type sid_shift(ptr &, stride const &, int) { return {}; }
+                friend constexpr std::false_type sid_shift(ptr_diff &, stride const &, int) { return {}; }
             };
 
             struct dim_0;
@@ -54,7 +54,7 @@ namespace gridtools {
             struct bounds_validator_kind;
 
             struct testee {
-                friend sid::host_device::simple_ptr_holder<ptr> sid_get_origin(testee &) { return {}; }
+                friend sid::simple_ptr_holder<ptr> sid_get_origin(testee &) { return {}; }
                 friend strides sid_get_strides(testee const &) { return {}; }
 
                 friend ptr_diff sid_get_ptr_diff(testee);
@@ -62,58 +62,57 @@ namespace gridtools {
                 friend bounds_validator_kind sid_get_bounds_validator_kind(testee);
             };
 
-            static_assert(sid::concept_impl_::is_sid<testee>(), "");
-            static_assert(std::is_same<sid::ptr_diff_type<testee>, ptr_diff>(), "");
-            static_assert(std::is_same<sid::reference_type<testee>, element &>(), "");
-            static_assert(std::is_same<sid::element_type<testee>, element>(), "");
-            static_assert(std::is_same<sid::const_reference_type<testee>, element const &>(), "");
-            static_assert(std::is_same<sid::strides_kind<testee>, strides_kind>(), "");
+            static_assert(sid::concept_impl_::is_sid<testee>());
+            static_assert(std::is_same_v<sid::ptr_diff_type<testee>, ptr_diff>);
+            static_assert(std::is_same_v<sid::reference_type<testee>, element &>);
+            static_assert(std::is_same_v<sid::element_type<testee>, element>);
+            static_assert(std::is_same_v<sid::const_reference_type<testee>, element const &>);
+            static_assert(std::is_same_v<sid::strides_kind<testee>, strides_kind>);
 
-            static_assert(
-                std::is_same<std::decay_t<decltype(sid::get_origin(std::declval<testee &>())())>, ptr>::value, "");
-            static_assert(std::is_same<decltype(sid::get_strides(testee{})), strides>(), "");
+            static_assert(std::is_same_v<std::decay_t<decltype(sid::get_origin(std::declval<testee &>())())>, ptr>);
+            static_assert(std::is_same_v<decltype(sid::get_strides(testee{})), strides>);
 
-            static_assert(std::is_same<std::decay_t<decltype(sid::get_stride<dim_0>(strides{}))>, stride>(), "");
-            static_assert(std::is_same<std::decay_t<decltype(sid::get_stride<dim_1>(strides{}))>, stride>(), "");
-            static_assert(decltype(sid::get_stride<void>(strides()))::value == 0, "");
-            static_assert(decltype(sid::get_stride<void *>(strides()))::value == 0, "");
+            static_assert(std::is_same_v<std::decay_t<decltype(sid::get_stride<dim_0>(strides{}))>, stride>);
+            static_assert(std::is_same_v<std::decay_t<decltype(sid::get_stride<dim_1>(strides{}))>, stride>);
+            static_assert(decltype(sid::get_stride<void>(strides()))::value == 0);
+            static_assert(decltype(sid::get_stride<void *>(strides()))::value == 0);
 
-            static_assert(std::is_same<decltype(sid::shift(std::declval<ptr &>(), stride{}, 0)), std::true_type>(), "");
+            static_assert(std::is_same_v<decltype(sid::shift(std::declval<ptr &>(), stride{}, 0)), std::true_type>);
             static_assert(
-                std::is_same<decltype(sid::shift(std::declval<ptr_diff &>(), stride{}, 0)), std::false_type>(), "");
+                std::is_same_v<decltype(sid::shift(std::declval<ptr_diff &>(), stride{}, 0)), std::false_type>);
         } // namespace custom
 
         namespace fallbacks {
 
             struct testee {
-                friend sid::host_device::simple_ptr_holder<testee *> sid_get_origin(testee &obj) { return {&obj}; }
+                friend sid::simple_ptr_holder<testee *> sid_get_origin(testee &obj) { return {&obj}; }
             };
 
-            static_assert(is_sid<testee>(), "");
-            static_assert(std::is_same<sid::ptr_type<testee>, testee *>(), "");
-            static_assert(std::is_same<sid::ptr_diff_type<testee>, ptrdiff_t>(), "");
-            static_assert(std::is_same<sid::reference_type<testee>, testee &>(), "");
-            static_assert(std::is_same<sid::element_type<testee>, testee>(), "");
-            static_assert(std::is_same<sid::const_reference_type<testee>, testee const &>(), "");
+            static_assert(is_sid<testee>());
+            static_assert(std::is_same_v<sid::ptr_type<testee>, testee *>);
+            static_assert(std::is_same_v<sid::ptr_diff_type<testee>, ptrdiff_t>);
+            static_assert(std::is_same_v<sid::reference_type<testee>, testee &>);
+            static_assert(std::is_same_v<sid::element_type<testee>, testee>);
+            static_assert(std::is_same_v<sid::const_reference_type<testee>, testee const &>);
 
             using strides = sid::strides_type<testee>;
-            static_assert(tuple_util::size<strides>() == 0, "");
+            static_assert(tuple_util::size<strides>() == 0);
 
             static_assert(
-                std::is_same<std::decay_t<decltype(sid::get_origin(std::declval<testee &>())())>, testee *>(), "");
-            static_assert(std::is_same<decltype(sid::get_strides(testee{})), strides>(), "");
+                std::is_same_v<std::decay_t<decltype(sid::get_origin(std::declval<testee &>())())>, testee *>);
+            static_assert(std::is_same_v<decltype(sid::get_strides(testee{})), strides>);
 
             auto stride = sid::get_stride<void>(strides{});
-            static_assert(decltype(stride)::value == 0, "");
+            static_assert(decltype(stride)::value == 0);
 
-            static_assert(std::is_void<std::void_t<decltype(sid::shift(std::declval<testee *&>(), stride, 42))>>(), "");
-            static_assert(std::is_void<std::void_t<decltype(sid::shift(std::declval<ptrdiff_t *&>(), stride, 42))>>(), "");
+            static_assert(std::is_void_v<std::void_t<decltype(sid::shift(std::declval<testee *&>(), stride, 42))>>);
+            static_assert(std::is_void_v<std::void_t<decltype(sid::shift(std::declval<ptrdiff_t *&>(), stride, 42))>>);
 
             using lower_bounds = sid::lower_bounds_type<testee>;
-            static_assert(tuple_util::size<lower_bounds>() == 0, "");
+            static_assert(tuple_util::size<lower_bounds>() == 0);
 
             using upper_bounds = sid::upper_bounds_type<testee>;
-            static_assert(tuple_util::size<upper_bounds>() == 0, "");
+            static_assert(tuple_util::size<upper_bounds>() == 0);
         } // namespace fallbacks
 
         template <class T, class Stride, class Offset>
@@ -149,12 +148,12 @@ namespace gridtools {
 
             struct testee {};
 
-            sid::host_device::simple_ptr_holder<testee *> sid_get_origin(testee &obj) { return {&obj}; }
+            sid::simple_ptr_holder<testee *> sid_get_origin(testee &obj) { return {&obj}; }
             tuple<stride> sid_get_strides(testee const &) { return {}; }
-            GT_FUNCTION int operator*(stride, int) { return 100; }
+            constexpr int operator*(stride, int) { return 100; }
             integral_constant<int, 42> sid_get_strides_kind(testee const &);
 
-            static_assert(is_sid<testee>(), "");
+            static_assert(is_sid<testee>());
 
             TEST(non_static_value, shift) {
                 ptrdiff_t val = 22;
@@ -168,7 +167,7 @@ namespace gridtools {
 
         TEST(c_array, smoke) {
             double testee[15][43] = {};
-            static_assert(is_sid<decltype(testee)>(), "");
+            static_assert(is_sid<decltype(testee)>());
 
             EXPECT_EQ(&testee[0][0], sid::get_origin(testee)());
 
@@ -178,13 +177,13 @@ namespace gridtools {
 
             using strides_t = decltype(strides);
 
-            static_assert(tuple_util::size<strides_t>::value == 2, "");
+            static_assert(tuple_util::size<strides_t>::value == 2);
 
             using stride_0_t = tuple_util::element<0, strides_t>;
             using stride_1_t = tuple_util::element<1, strides_t>;
 
-            static_assert(stride_0_t::value == 43, "");
-            static_assert(stride_1_t::value == 1, "");
+            static_assert(stride_0_t::value == 43);
+            static_assert(stride_1_t::value == 1);
 
             testee[7][8] = 555;
 
@@ -205,7 +204,7 @@ namespace gridtools {
 
         TEST(c_array, 4D) {
             double testee[2][3][4][5] = {};
-            static_assert(is_sid<decltype(testee)>(), "");
+            static_assert(is_sid<decltype(testee)>());
 
             EXPECT_EQ(&testee[0][0][0][0], sid::get_origin(testee)());
 
diff --git a/tests/unit_tests/sid/test_sid_contiguous.cpp b/tests/unit_tests/sid/test_sid_contiguous.cpp
index 1092e438bb..a99e12809f 100644
--- a/tests/unit_tests/sid/test_sid_contiguous.cpp
+++ b/tests/unit_tests/sid/test_sid_contiguous.cpp
@@ -34,7 +34,7 @@ namespace gridtools {
         using sid::property;
 
         TEST(contiguous, smoke) {
-            auto alloc = sid::make_allocator(&std::make_unique<char[]>);
+            auto alloc = sid::allocator(&std::make_unique<char[]>);
             hymap::keys<a, b, c>::values<integral_constant<int_t, 2>, int, int> sizes = {2_c, 3, 4};
             auto testee = sid::make_contiguous<int>(alloc, sizes);
 
@@ -43,9 +43,9 @@ namespace gridtools {
             using strides_t = sid::strides_type<testee_t>;
             using strides_kind_t = sid::strides_kind<testee_t>;
 
-            static_assert(is_sid<testee_t>(), "");
-            static_assert(std::is_same<ptrdiff_t, ptr_diff_t>(), "");
-            static_assert(std::is_same<strides_kind_t, strides_t>(), "");
+            static_assert(is_sid<testee_t>());
+            static_assert(std::is_same_v<ptrdiff_t, ptr_diff_t>);
+            static_assert(std::is_same_v<strides_kind_t, strides_t>);
 
             auto lower_bounds = sid::get_lower_bounds(testee);
             EXPECT_EQ(0, at_key<a>(lower_bounds));
diff --git a/tests/unit_tests/sid/test_sid_delegate.cpp b/tests/unit_tests/sid/test_sid_delegate.cpp
index 4a20ae115f..d29d1c913b 100644
--- a/tests/unit_tests/sid/test_sid_delegate.cpp
+++ b/tests/unit_tests/sid/test_sid_delegate.cpp
@@ -46,13 +46,13 @@ namespace gridtools {
         TEST(delegate, smoke) {
             double data[3][5];
             auto src = sid::synthetic()
-                           .set<property::origin>(sid::host_device::make_simple_ptr_holder(&data[0][0]))
+                           .set<property::origin>(sid::simple_ptr_holder(&data[0][0]))
                            .set<property::strides>(tuple(5_c, 1_c));
             EXPECT_EQ(&data[0][0], sid::get_origin(src)());
 
             auto testee = i_shift(std::move(src));
 
-            static_assert(is_sid<decltype(testee)>(), "");
+            static_assert(is_sid<decltype(testee)>());
 
             EXPECT_EQ(&data[1][0], sid::get_origin(testee)());
         }
@@ -61,7 +61,7 @@ namespace gridtools {
             double src[3][5];
             auto testee = i_shift(src);
 
-            static_assert(is_sid<decltype(testee)>(), "");
+            static_assert(is_sid<decltype(testee)>());
 
             EXPECT_EQ(&src[1][0], sid::get_origin(testee)());
             auto strides = sid::get_strides(testee);
@@ -77,11 +77,10 @@ namespace gridtools {
         TEST(delegate, do_nothing) {
             double data[3][5];
             auto src = sid::synthetic()
-                           .set<property::origin>(sid::host_device::make_simple_ptr_holder(&data[0][0]))
+                           .set<property::origin>(sid::simple_ptr_holder(&data[0][0]))
                            .set<property::strides>(tuple(5_c, 1_c));
             auto testee = just_delegate(src);
-            static_assert(is_sid<decltype(testee)>(), "");
+            static_assert(is_sid<decltype(testee)>());
         }
-
     } // namespace
 } // namespace gridtools
diff --git a/tests/unit_tests/sid/test_sid_loop.cpp b/tests/unit_tests/sid/test_sid_loop.cpp
index d9b4336580..0ae8ac363d 100644
--- a/tests/unit_tests/sid/test_sid_loop.cpp
+++ b/tests/unit_tests/sid/test_sid_loop.cpp
@@ -63,7 +63,7 @@ namespace gridtools {
             double *ptr = &data[0][0];
             auto strides = tuple(10_c, 1_c);
 
-            auto testee = host_device::compose(sid::make_loop<i_t>(10_c), sid::make_loop<j_t>(10_c));
+            auto testee = compose(sid::make_loop<i_t>(10_c), sid::make_loop<j_t>(10_c));
 
             testee(assignment_f{42})(ptr, strides);
 
diff --git a/tests/unit_tests/sid/test_sid_rename_dimensions.cpp b/tests/unit_tests/sid/test_sid_rename_dimensions.cpp
index b9ec877c8a..c04b5dd2a1 100644
--- a/tests/unit_tests/sid/test_sid_rename_dimensions.cpp
+++ b/tests/unit_tests/sid/test_sid_rename_dimensions.cpp
@@ -34,7 +34,7 @@ namespace gridtools {
             double data[3][5][7];
 
             auto src = sid::synthetic()
-                           .set<property::origin>(sid::make_simple_ptr_holder(&data[0][0][0]))
+                           .set<property::origin>(sid::simple_ptr_holder(&data[0][0][0]))
                            .set<property::strides>(hymap::keys<a, b, c>::make_values(5_c * 7_c, 7_c, 1_c))
                            .set<property::upper_bounds>(hymap::keys<a, b>::make_values(3, 5));
 
@@ -47,7 +47,7 @@ namespace gridtools {
             EXPECT_EQ(1, sid::get_stride<c>(strides));
             EXPECT_EQ(7, sid::get_stride<d>(strides));
 
-            static_assert(meta::is_empty<get_keys<sid::lower_bounds_type<testee_t>>>(), "");
+            static_assert(meta::is_empty<get_keys<sid::lower_bounds_type<testee_t>>>());
             auto u_bound = sid::get_upper_bounds(testee);
             EXPECT_EQ(3, at_key<a>(u_bound));
             EXPECT_EQ(5, at_key<d>(u_bound));
@@ -77,13 +77,13 @@ namespace gridtools {
         TEST(rename_dimensions, rename_twice_and_make_composite) {
             double data[3][5][7];
             auto src = sid::synthetic()
-                           .set<property::origin>(sid::host_device::make_simple_ptr_holder(&data[0][0][0]))
+                           .set<property::origin>(sid::simple_ptr_holder(&data[0][0][0]))
                            .set<property::strides>(hymap::keys<a, b, c>::make_values(5_c * 7_c, 7_c, 1_c))
                            .set<property::upper_bounds>(hymap::keys<a, b>::make_values(3, 5));
             auto testee = sid::rename_dimensions<a, c, b, d>(src);
-            static_assert(sid::is_sid<decltype(testee)>::value, "");
+            static_assert(sid::is_sid<decltype(testee)>::value);
             auto composite = sid::composite::keys<void>::make_values(testee);
-            static_assert(sid::is_sid<decltype(composite)>::value, "");
+            static_assert(sid::is_sid<decltype(composite)>::value);
             sid::get_origin(composite);
         }
 
diff --git a/tests/unit_tests/sid/test_sid_shift_sid_origin.cpp b/tests/unit_tests/sid/test_sid_shift_sid_origin.cpp
index 248a0fef8e..44e9d5aea0 100644
--- a/tests/unit_tests/sid/test_sid_shift_sid_origin.cpp
+++ b/tests/unit_tests/sid/test_sid_shift_sid_origin.cpp
@@ -28,14 +28,14 @@ namespace gridtools {
             double data[3][5][7];
 
             auto src = sid::synthetic()
-                           .set<property::origin>(sid::make_simple_ptr_holder(&data[0][0][0]))
+                           .set<property::origin>(sid::simple_ptr_holder(&data[0][0][0]))
                            .set<property::strides>(tuple(5_c * 7_c, 7_c, 1_c))
                            .set<property::upper_bounds>(tuple(3));
 
             auto offset = tuple(1_c, 2);
             auto testee = sid::shift_sid_origin(src, offset);
 
-            static_assert(is_sid<decltype(testee)>(), "");
+            static_assert(is_sid<decltype(testee)>());
 
             EXPECT_EQ(&data[0][0][0], sid::get_origin(src)());
             EXPECT_EQ(&data[1][2][0], sid::get_origin(testee)());
@@ -49,7 +49,7 @@ namespace gridtools {
             auto offset = tuple(1_c, 2);
             auto testee = sid::shift_sid_origin(data, offset);
 
-            static_assert(is_sid<decltype(testee)>(), "");
+            static_assert(is_sid<decltype(testee)>());
 
             EXPECT_EQ(&data[1][2][0], sid::get_origin(testee)());
 
diff --git a/tests/unit_tests/sid/test_sid_synthetic.cpp b/tests/unit_tests/sid/test_sid_synthetic.cpp
index 29605e94b4..283e696879 100644
--- a/tests/unit_tests/sid/test_sid_synthetic.cpp
+++ b/tests/unit_tests/sid/test_sid_synthetic.cpp
@@ -24,8 +24,8 @@ namespace gridtools {
 
         TEST(sid_synthetic, smoke) {
             double a = 100;
-            auto testee = sid::synthetic().set<property::origin>(sid::host_device::make_simple_ptr_holder(&a));
-            static_assert(is_sid<decltype(testee)>::value, "");
+            auto testee = sid::synthetic().set<property::origin>(sid::simple_ptr_holder(&a));
+            static_assert(is_sid<decltype(testee)>::value);
 
             EXPECT_EQ(a, *sid::get_origin(testee)());
         }
@@ -37,13 +37,13 @@ namespace gridtools {
             };
             struct ptr {
                 element const *val;
-                GT_FUNCTION element const &operator*() const { return *val; }
-                friend GT_FUNCTION ptr operator+(ptr, ptr_diff) { return {}; }
+                constexpr element const &operator*() const { return *val; }
+                friend constexpr ptr operator+(ptr, ptr_diff) { return {}; }
             };
             struct stride {
                 int val;
-                friend GT_FUNCTION std::true_type sid_shift(ptr &, stride const &, int) { return {}; }
-                friend GT_FUNCTION std::false_type sid_shift(ptr_diff &, stride const &, int) { return {}; }
+                friend constexpr std::true_type sid_shift(ptr &, stride const &, int) { return {}; }
+                friend constexpr std::false_type sid_shift(ptr_diff &, stride const &, int) { return {}; }
             };
             using strides = array<stride, 2>;
 
@@ -55,20 +55,20 @@ namespace gridtools {
                 strides the_strides = {stride{3}, stride{4}};
 
                 auto the_testee = sid::synthetic()
-                                      .set<property::origin>(sid::host_device::make_simple_ptr_holder(the_origin))
+                                      .set<property::origin>(sid::simple_ptr_holder(the_origin))
                                       .set<property::strides>(the_strides)
                                       .set<property::ptr_diff, ptr_diff>()
                                       .set<property::strides_kind, strides_kind>();
 
                 using testee = decltype(the_testee);
 
-                static_assert(is_sid<testee>(), "");
-                static_assert(std::is_trivially_copyable<testee>(), "");
+                static_assert(is_sid<testee>());
+                static_assert(std::is_trivially_copy_constructible_v<testee>);
 
-                static_assert(std::is_same<sid::ptr_type<testee>, ptr>(), "");
-                static_assert(std::is_same<sid::strides_type<testee>, strides>(), "");
-                static_assert(std::is_same<sid::ptr_diff_type<testee>, ptr_diff>(), "");
-                static_assert(std::is_same<sid::strides_kind<testee>, strides_kind>(), "");
+                static_assert(std::is_same_v<sid::ptr_type<testee>, ptr>);
+                static_assert(std::is_same_v<sid::strides_type<testee>, strides>);
+                static_assert(std::is_same_v<sid::ptr_diff_type<testee>, ptr_diff>);
+                static_assert(std::is_same_v<sid::strides_kind<testee>, strides_kind>);
 
                 EXPECT_EQ(&the_element, sid::get_origin(the_testee)().val);
                 EXPECT_EQ(3, tuple_util::get<0>(sid::get_strides(the_testee)).val);
diff --git a/tests/unit_tests/stencil/core/test_esf_metafunctions.cpp b/tests/unit_tests/stencil/core/test_esf_metafunctions.cpp
index 47b1c856d6..e5f7f55905 100644
--- a/tests/unit_tests/stencil/core/test_esf_metafunctions.cpp
+++ b/tests/unit_tests/stencil/core/test_esf_metafunctions.cpp
@@ -125,16 +125,17 @@ using mss_t = meta::first<decltype(execute_parallel()
                                        .stage(functor6(), o6(), o5(), in1(), in2()))>;
 
 template <class Arg, int_t... ExpectedExtentValues>
-using testee = std::is_same<lookup_extent_map<get_extent_map_from_mss<mss_t>, Arg>, extent<ExpectedExtentValues...>>;
-
-static_assert(testee<o0, -5, 11, -10, 10, -5, 13>::value, "");
-static_assert(testee<o1, -5, 9, -10, 8, -3, 10>::value, "");
-static_assert(testee<o2, -2, 8, -8, 7, -3, 8>::value, "");
-static_assert(testee<o3, -1, 5, -5, 7, 0, 6>::value, "");
-static_assert(testee<o4, 0, 4, -5, 4, 0, 3>::value, "");
-static_assert(testee<o5, 0, 3, -3, 2, 0, 0>::value, "");
-static_assert(testee<o6, 0, 0, 0, 0, 0, 0>::value, "");
-static_assert(testee<in0, -8, 11, -13, 13, -7, 13>::value, "");
-static_assert(testee<in1, -6, 12, -10, 12, -6, 15>::value, "");
-static_assert(testee<in2, -8, 14, -11, 12, -5, 14>::value, "");
-static_assert(testee<in3, -5, 10, -11, 10, -3, 10>::value, "");
+constexpr bool testee =
+    std::is_same_v<lookup_extent_map<get_extent_map_from_mss<mss_t>, Arg>, extent<ExpectedExtentValues...>>;
+
+static_assert(testee<o0, -5, 11, -10, 10, -5, 13>);
+static_assert(testee<o1, -5, 9, -10, 8, -3, 10>);
+static_assert(testee<o2, -2, 8, -8, 7, -3, 8>);
+static_assert(testee<o3, -1, 5, -5, 7, 0, 6>);
+static_assert(testee<o4, 0, 4, -5, 4, 0, 3>);
+static_assert(testee<o5, 0, 3, -3, 2, 0, 0>);
+static_assert(testee<o6, 0, 0, 0, 0, 0, 0>);
+static_assert(testee<in0, -8, 11, -13, 13, -7, 13>);
+static_assert(testee<in1, -6, 12, -10, 12, -6, 15>);
+static_assert(testee<in2, -8, 14, -11, 12, -5, 14>);
+static_assert(testee<in3, -5, 10, -11, 10, -3, 10>);
diff --git a/tests/unit_tests/stencil/core/test_functor_metafunctions.cpp b/tests/unit_tests/stencil/core/test_functor_metafunctions.cpp
index e8fc5a5ec5..bcb731dc2e 100644
--- a/tests/unit_tests/stencil/core/test_functor_metafunctions.cpp
+++ b/tests/unit_tests/stencil/core/test_functor_metafunctions.cpp
@@ -19,13 +19,13 @@ namespace gridtools {
                 using interval_t = interval<level<0, 1, 3>, level<2, -1, 3>>;
 
                 struct empty {};
-                //                static_assert(check_valid_apply_overloads<empty, interval_t>::value, "");
+                //                static_assert(check_valid_apply_overloads<empty, interval_t>::value);
 
                 struct simple {
                     template <class T>
                     static void apply(T);
                 };
-                static_assert(check_valid_apply_overloads<simple, interval_t>::value, "");
+                static_assert(check_valid_apply_overloads<simple, interval_t>::value);
 
                 using expected_simple_map_t = meta::list<meta::list<interval<level<0, 1, 3>, level<0, 1, 3>>, simple>,
                     meta::list<interval<level<0, 2, 3>, level<0, 2, 3>>, simple>,
@@ -38,7 +38,7 @@ namespace gridtools {
                     meta::list<interval<level<2, -2, 3>, level<2, -2, 3>>, simple>,
                     meta::list<interval<level<2, -1, 3>, level<2, -1, 3>>, simple>>;
 
-                static_assert(std::is_same<make_functor_map<simple, interval_t>, expected_simple_map_t>::value, "");
+                static_assert(std::is_same_v<make_functor_map<simple, interval_t>, expected_simple_map_t>);
 
                 struct good {
                     template <class T>
@@ -50,7 +50,7 @@ namespace gridtools {
                     template <class T>
                     static void apply(T, interval<level<1, 2, 3>, level<2, -3, 3>>);
                 };
-                static_assert(check_valid_apply_overloads<good, interval_t>::value, "");
+                static_assert(check_valid_apply_overloads<good, interval_t>::value);
 
                 using expected_good_map_t = meta::list<
                     meta::list<interval<level<0, 1, 3>, level<0, 1, 3>>,
@@ -71,7 +71,7 @@ namespace gridtools {
                     meta::list<interval<level<2, -2, 3>, level<2, -2, 3>>, good>,
                     meta::list<interval<level<2, -1, 3>, level<2, -1, 3>>, good>>;
 
-                static_assert(std::is_same<make_functor_map<good, interval_t>, expected_good_map_t>::value, "");
+                static_assert(std::is_same_v<make_functor_map<good, interval_t>, expected_good_map_t>);
 
                 struct intersect {
                     template <class T>
@@ -79,7 +79,7 @@ namespace gridtools {
                     template <class T>
                     static void apply(T, interval<level<1, -2, 3>, level<2, -3, 3>>);
                 };
-                //                static_assert(check_valid_apply_overloads<intersect, interval_t>::value, "");
+                //                static_assert(check_valid_apply_overloads<intersect, interval_t>::value);
 
                 struct gaps {
                     template <class T>
@@ -87,7 +87,7 @@ namespace gridtools {
                     template <class T>
                     static void apply(T, interval<level<1, 3, 3>, level<2, -3, 3>>);
                 };
-                static_assert(check_valid_apply_overloads<gaps, interval_t>::value, "");
+                static_assert(check_valid_apply_overloads<gaps, interval_t>::value);
 
                 using expected_gaps_map_t = meta::list<meta::list<interval<level<0, 1, 3>, level<0, 1, 3>>>,
                     meta::list<interval<level<0, 2, 3>, level<0, 2, 3>>>,
@@ -101,7 +101,7 @@ namespace gridtools {
                         functor_metafunctions_impl_::bound_functor<gaps, interval<level<1, 3, 3>, level<2, -3, 3>>>>,
                     meta::list<interval<level<2, -2, 3>, level<2, -2, 3>>>,
                     meta::list<interval<level<2, -1, 3>, level<2, -1, 3>>>>;
-                static_assert(std::is_same<make_functor_map<gaps, interval_t>, expected_gaps_map_t>::value, "");
+                static_assert(std::is_same_v<make_functor_map<gaps, interval_t>, expected_gaps_map_t>);
 
                 struct good_intervals {
                     template <class T>
@@ -112,19 +112,19 @@ namespace gridtools {
                     static void apply(T, interval<level<2, 3, 3>, level<2, 3, 3>>);
                 };
                 static_assert(
-                    check_valid_apply_overloads<good_intervals, interval<level<0, -3, 3>, level<2, 2, 3>>>::value, "");
+                    check_valid_apply_overloads<good_intervals, interval<level<0, -3, 3>, level<2, 2, 3>>>::value);
 
                 struct bad_from_level {
                     template <class T>
                     static void apply(T, interval<level<1, -3, 3>, level<4, 1, 3>>);
                 };
-                //                static_assert(check_valid_apply_overloads<bad_from_level, interval_t>::value, "");
+                //                static_assert(check_valid_apply_overloads<bad_from_level, interval_t>::value);
 
                 struct bad_to_level {
                     template <class T>
                     static void apply(T, interval<level<1, 1, 3>, level<1, 3, 3>>);
                 };
-                //                static_assert(check_valid_apply_overloads<bad_to_level, interval_t>::value, "");
+                //                static_assert(check_valid_apply_overloads<bad_to_level, interval_t>::value);
             } // namespace
         }     // namespace core
     }         // namespace stencil
diff --git a/tests/unit_tests/stencil/core/test_interval.cpp b/tests/unit_tests/stencil/core/test_interval.cpp
index 218eeeb376..ceeb6aa236 100644
--- a/tests/unit_tests/stencil/core/test_interval.cpp
+++ b/tests/unit_tests/stencil/core/test_interval.cpp
@@ -22,10 +22,9 @@ using level_t = level<Splitter, Offset, level_offset_limit>;
 using my_interval = interval<level_t<0, -1>, level_t<1, -1>>;
 
 template <class T, uint_t FromSplitter, int_t FromOffset, uint_t ToSplitter, int_t ToOffset>
-constexpr bool testee =
-    std::is_same<T, interval<level_t<FromSplitter, FromOffset>, level_t<ToSplitter, ToOffset>>>::value;
+constexpr bool testee = std::is_same_v<T, interval<level_t<FromSplitter, FromOffset>, level_t<ToSplitter, ToOffset>>>;
 
-static_assert(testee<my_interval::modify<-1, 0>, 0, -2, 1, -1>, "");
-static_assert(testee<my_interval::modify<1, 1>, 0, 1, 1, 1>, "");
-static_assert(testee<my_interval::modify<-2, 0>, 0, -3, 1, -1>, "");
-static_assert(testee<my_interval::modify<2, 2>, 0, 2, 1, 2>, "");
+static_assert(testee<my_interval::modify<-1, 0>, 0, -2, 1, -1>);
+static_assert(testee<my_interval::modify<1, 1>, 0, 1, 1, 1>);
+static_assert(testee<my_interval::modify<-2, 0>, 0, -3, 1, -1>);
+static_assert(testee<my_interval::modify<2, 2>, 0, 2, 1, 2>);
diff --git a/tests/unit_tests/stencil/core/test_level.cpp b/tests/unit_tests/stencil/core/test_level.cpp
index 35a2dcfc48..ffaf6e1f64 100644
--- a/tests/unit_tests/stencil/core/test_level.cpp
+++ b/tests/unit_tests/stencil/core/test_level.cpp
@@ -16,36 +16,36 @@ using namespace core;
 
 namespace test_level_to_index {
     template <class L, class I>
-    constexpr bool testee = std::is_same<level_to_index<L>, I>::value;
+    constexpr bool testee = std::is_same_v<level_to_index<L>, I>;
 
-    static_assert(testee<level<0, -2, 2>, level_index<0, 2>>, "");
-    static_assert(testee<level<0, -1, 2>, level_index<1, 2>>, "");
-    static_assert(testee<level<0, 1, 2>, level_index<2, 2>>, "");
-    static_assert(testee<level<0, 2, 2>, level_index<3, 2>>, "");
-    static_assert(testee<level<1, -2, 2>, level_index<4, 2>>, "");
-    static_assert(testee<level<1, -1, 2>, level_index<5, 2>>, "");
-    static_assert(testee<level<1, 1, 2>, level_index<6, 2>>, "");
-    static_assert(testee<level<1, 2, 2>, level_index<7, 2>>, "");
-    static_assert(testee<level<2, -2, 2>, level_index<8, 2>>, "");
-    static_assert(testee<level<2, -1, 2>, level_index<9, 2>>, "");
-    static_assert(testee<level<2, 1, 2>, level_index<10, 2>>, "");
-    static_assert(testee<level<2, 2, 2>, level_index<11, 2>>, "");
+    static_assert(testee<level<0, -2, 2>, level_index<0, 2>>);
+    static_assert(testee<level<0, -1, 2>, level_index<1, 2>>);
+    static_assert(testee<level<0, 1, 2>, level_index<2, 2>>);
+    static_assert(testee<level<0, 2, 2>, level_index<3, 2>>);
+    static_assert(testee<level<1, -2, 2>, level_index<4, 2>>);
+    static_assert(testee<level<1, -1, 2>, level_index<5, 2>>);
+    static_assert(testee<level<1, 1, 2>, level_index<6, 2>>);
+    static_assert(testee<level<1, 2, 2>, level_index<7, 2>>);
+    static_assert(testee<level<2, -2, 2>, level_index<8, 2>>);
+    static_assert(testee<level<2, -1, 2>, level_index<9, 2>>);
+    static_assert(testee<level<2, 1, 2>, level_index<10, 2>>);
+    static_assert(testee<level<2, 2, 2>, level_index<11, 2>>);
 } // namespace test_level_to_index
 
 namespace test_index_to_level {
     template <class L, class I>
-    constexpr bool testee = std::is_same<L, index_to_level<I>>::value;
+    constexpr bool testee = std::is_same_v<L, index_to_level<I>>;
 
-    static_assert(testee<level<0, -2, 2>, level_index<0, 2>>, "");
-    static_assert(testee<level<0, -1, 2>, level_index<1, 2>>, "");
-    static_assert(testee<level<0, 1, 2>, level_index<2, 2>>, "");
-    static_assert(testee<level<0, 2, 2>, level_index<3, 2>>, "");
-    static_assert(testee<level<1, -2, 2>, level_index<4, 2>>, "");
-    static_assert(testee<level<1, -1, 2>, level_index<5, 2>>, "");
-    static_assert(testee<level<1, 1, 2>, level_index<6, 2>>, "");
-    static_assert(testee<level<1, 2, 2>, level_index<7, 2>>, "");
-    static_assert(testee<level<2, -2, 2>, level_index<8, 2>>, "");
-    static_assert(testee<level<2, -1, 2>, level_index<9, 2>>, "");
-    static_assert(testee<level<2, 1, 2>, level_index<10, 2>>, "");
-    static_assert(testee<level<2, 2, 2>, level_index<11, 2>>, "");
+    static_assert(testee<level<0, -2, 2>, level_index<0, 2>>);
+    static_assert(testee<level<0, -1, 2>, level_index<1, 2>>);
+    static_assert(testee<level<0, 1, 2>, level_index<2, 2>>);
+    static_assert(testee<level<0, 2, 2>, level_index<3, 2>>);
+    static_assert(testee<level<1, -2, 2>, level_index<4, 2>>);
+    static_assert(testee<level<1, -1, 2>, level_index<5, 2>>);
+    static_assert(testee<level<1, 1, 2>, level_index<6, 2>>);
+    static_assert(testee<level<1, 2, 2>, level_index<7, 2>>);
+    static_assert(testee<level<2, -2, 2>, level_index<8, 2>>);
+    static_assert(testee<level<2, -1, 2>, level_index<9, 2>>);
+    static_assert(testee<level<2, 1, 2>, level_index<10, 2>>);
+    static_assert(testee<level<2, 2, 2>, level_index<11, 2>>);
 } // namespace test_index_to_level
diff --git a/tests/unit_tests/stencil/cpu_ifirst/test_tmp_storage_sid.cpp b/tests/unit_tests/stencil/cpu_ifirst/test_tmp_storage_sid.cpp
index 38e38d92e6..85493b771f 100644
--- a/tests/unit_tests/stencil/cpu_ifirst/test_tmp_storage_sid.cpp
+++ b/tests/unit_tests/stencil/cpu_ifirst/test_tmp_storage_sid.cpp
@@ -47,8 +47,8 @@ TEST(tmp_storage_sid, nonzero_k_extents) {
 
     using tmp_t = decltype(tmp);
 
-    static_assert(is_sid<tmp_t>(), "");
-    static_assert(std::is_same<sid::ptr_type<tmp_t>, double *>(), "");
+    static_assert(is_sid<tmp_t>());
+    static_assert(std::is_same_v<sid::ptr_type<tmp_t>, double *>);
 
     auto f = [](int_t i, int_t j, int_t k, int_t t) { return i + j * 100 + k * 200 + t * 400; };
 
@@ -115,8 +115,8 @@ TEST(tmp_storage_sid, zero_k_extents) {
 
     using tmp_t = decltype(tmp);
 
-    static_assert(is_sid<tmp_t>(), "");
-    static_assert(std::is_same<sid::ptr_type<tmp_t>, double *>(), "");
+    static_assert(is_sid<tmp_t>());
+    static_assert(std::is_same_v<sid::ptr_type<tmp_t>, double *>);
 
     auto f = [](int_t i, int_t j, int_t t) { return i + j * 100 + t * 200; };
 
diff --git a/tests/unit_tests/stencil/frontend/cartesian/test_accessor.cpp b/tests/unit_tests/stencil/frontend/cartesian/test_accessor.cpp
index 300f06ccbf..c7dfcaecbc 100644
--- a/tests/unit_tests/stencil/frontend/cartesian/test_accessor.cpp
+++ b/tests/unit_tests/stencil/frontend/cartesian/test_accessor.cpp
@@ -20,15 +20,15 @@ using namespace stencil;
 using namespace cartesian;
 using namespace expressions;
 
-static_assert(is_accessor<inout_accessor<6, extent<3, 4, 4, 5>>>::value, "");
-static_assert(is_accessor<in_accessor<2>>::value, "");
-static_assert(!is_accessor<int>::value, "");
-static_assert(!is_accessor<double &>::value, "");
-static_assert(!is_accessor<double const &>::value, "");
+static_assert(is_accessor<inout_accessor<6, extent<3, 4, 4, 5>>>::value);
+static_assert(is_accessor<in_accessor<2>>::value);
+static_assert(!is_accessor<int>::value);
+static_assert(!is_accessor<double &>::value);
+static_assert(!is_accessor<double const &>::value);
 
 TEST(accessor, smoke) {
     using testee_t = inout_accessor<0, extent<0, 3, 0, 2, -1, 0>>;
-    static_assert(tuple_util::size<testee_t>::value == 3, "");
+    static_assert(tuple_util::size<testee_t>::value == 3);
 
     testee_t testee{3, 2, -1};
 
@@ -39,14 +39,14 @@ TEST(accessor, smoke) {
 
 TEST(accessor, zero_accessor) {
     using testee_t = accessor<0>;
-    static_assert(tuple_util::size<testee_t>::value == 0, "");
+    static_assert(tuple_util::size<testee_t>::value == 0);
     testee_t{0, 0, 0, 0};
     testee_t{dimension<3>{}};
 }
 
 TEST(accessor, extra_args) {
     using testee_t = inout_accessor<0, extent<-1, 1>>;
-    static_assert(tuple_util::size<testee_t>::value == 1, "");
+    static_assert(tuple_util::size<testee_t>::value == 1);
     testee_t{1, 0};
     testee_t{dimension<2>{0}};
 }
diff --git a/tests/unit_tests/stencil/frontend/cartesian/test_arg_extent_intent.cpp b/tests/unit_tests/stencil/frontend/cartesian/test_arg_extent_intent.cpp
index 6e0f2baf0a..be9494f300 100644
--- a/tests/unit_tests/stencil/frontend/cartesian/test_arg_extent_intent.cpp
+++ b/tests/unit_tests/stencil/frontend/cartesian/test_arg_extent_intent.cpp
@@ -36,7 +36,7 @@ struct stage2 {
 
 template <class Arg, int... Is, class Spec>
 constexpr bool test_extent(Spec spec) {
-    return std::is_same<decltype(get_arg_extent(spec, Arg())), extent<Is...>>::value;
+    return std::is_same_v<decltype(get_arg_extent(spec, Arg())), extent<Is...>>;
 }
 
 template <class Plh, class Spec>
@@ -53,25 +53,25 @@ struct f {};
 
 constexpr auto mss0 = execute_parallel().stage(stage1(), a(), b(), c());
 
-static_assert(test_extent<a, 0, 1, -1, 0, 0, 1>(mss0), "");
-static_assert(test_extent<b, 0, 1, -1, 0, -1, 1>(mss0), "");
-static_assert(test_extent<c>(mss0), "");
+static_assert(test_extent<a, 0, 1, -1, 0, 0, 1>(mss0));
+static_assert(test_extent<b, 0, 1, -1, 0, -1, 1>(mss0));
+static_assert(test_extent<c>(mss0));
 
-static_assert(test_intent<a>(mss0, intent::in), "");
-static_assert(test_intent<b>(mss0, intent::in), "");
-static_assert(test_intent<c>(mss0, intent::inout), "");
+static_assert(test_intent<a>(mss0, intent::in));
+static_assert(test_intent<b>(mss0, intent::in));
+static_assert(test_intent<c>(mss0, intent::inout));
 
 constexpr auto mss1 = execute_parallel().stage(stage1(), a(), b(), c()).stage(stage2(), a(), c(), d());
 
-static_assert(test_extent<a, -1, 2, -2, 1, -1, 2>(mss1), "");
-static_assert(test_extent<b, -1, 2, -2, 0, -2, 2>(mss1), "");
-static_assert(test_extent<c, -1, 1, -1, 0, -1, 1>(mss1), "");
-static_assert(test_extent<d>(mss1), "");
+static_assert(test_extent<a, -1, 2, -2, 1, -1, 2>(mss1));
+static_assert(test_extent<b, -1, 2, -2, 0, -2, 2>(mss1));
+static_assert(test_extent<c, -1, 1, -1, 0, -1, 1>(mss1));
+static_assert(test_extent<d>(mss1));
 
-static_assert(test_intent<a>(mss1, intent::in), "");
-static_assert(test_intent<b>(mss1, intent::in), "");
-static_assert(test_intent<c>(mss1, intent::inout), "");
-static_assert(test_intent<d>(mss1, intent::inout), "");
+static_assert(test_intent<a>(mss1, intent::in));
+static_assert(test_intent<b>(mss1, intent::in));
+static_assert(test_intent<c>(mss1, intent::inout));
+static_assert(test_intent<d>(mss1, intent::inout));
 
 constexpr auto mss2 = execute_parallel()
                           .stage(stage1(), a(), b(), c())
@@ -107,16 +107,16 @@ constexpr auto mss2 = execute_parallel()
 //   b:  {-2, 3, -3, 1, -3, 3}
 //   a:  {-2, 3, -3, 1, -2, 3}
 
-static_assert(test_extent<a, -2, 3, -3, 1, -2, 3>(mss2), "");
-static_assert(test_extent<b, -2, 3, -3, 1, -3, 3>(mss2), "");
-static_assert(test_extent<c, -2, 2, -2, 1, -2, 2>(mss2), "");
-static_assert(test_extent<d, -1, 0, 0, 1, -1, 0>(mss2), "");
-static_assert(test_extent<e, -1, 1, -1, 0, -1, 1>(mss2), "");
-static_assert(test_extent<f>(mss2), "");
-
-static_assert(test_intent<a>(mss2, intent::in), "");
-static_assert(test_intent<b>(mss2, intent::in), "");
-static_assert(test_intent<c>(mss2, intent::inout), "");
-static_assert(test_intent<d>(mss2, intent::inout), "");
-static_assert(test_intent<e>(mss2, intent::inout), "");
-static_assert(test_intent<f>(mss2, intent::inout), "");
+static_assert(test_extent<a, -2, 3, -3, 1, -2, 3>(mss2));
+static_assert(test_extent<b, -2, 3, -3, 1, -3, 3>(mss2));
+static_assert(test_extent<c, -2, 2, -2, 1, -2, 2>(mss2));
+static_assert(test_extent<d, -1, 0, 0, 1, -1, 0>(mss2));
+static_assert(test_extent<e, -1, 1, -1, 0, -1, 1>(mss2));
+static_assert(test_extent<f>(mss2));
+
+static_assert(test_intent<a>(mss2, intent::in));
+static_assert(test_intent<b>(mss2, intent::in));
+static_assert(test_intent<c>(mss2, intent::inout));
+static_assert(test_intent<d>(mss2, intent::inout));
+static_assert(test_intent<e>(mss2, intent::inout));
+static_assert(test_intent<f>(mss2, intent::inout));
diff --git a/tests/unit_tests/stencil/frontend/cartesian/test_call_proc_stress_types.cpp b/tests/unit_tests/stencil/frontend/cartesian/test_call_proc_stress_types.cpp
index 03d987b6d7..bd0f9e6129 100644
--- a/tests/unit_tests/stencil/frontend/cartesian/test_call_proc_stress_types.cpp
+++ b/tests/unit_tests/stencil/frontend/cartesian/test_call_proc_stress_types.cpp
@@ -30,7 +30,7 @@ void do_test() {
 }
 
 template <class Eval, class Acc, class Expected>
-using check_acceessor = std::is_same<std::decay_t<decltype(std::declval<Eval &>()(Acc()))>, Expected>;
+constexpr bool check_acceessor = std::is_same_v<std::decay_t<decltype(std::declval<Eval &>()(Acc()))>, Expected>;
 
 struct in_tag {};
 struct out_tag {};
@@ -43,8 +43,8 @@ struct triple_nesting_with_type_switching_third_stage {
 
     template <typename Evaluation>
     GT_FUNCTION static void apply(Evaluation &eval) {
-        static_assert(check_acceessor<Evaluation, out, out_tag>::value, "");
-        static_assert(check_acceessor<Evaluation, local, local_tag>::value, "");
+        static_assert(check_acceessor<Evaluation, out, out_tag>);
+        static_assert(check_acceessor<Evaluation, local, local_tag>);
     }
 };
 
@@ -55,8 +55,8 @@ struct triple_nesting_with_type_switching_second_stage {
 
     template <typename Evaluation>
     GT_FUNCTION static void apply(Evaluation &eval) {
-        static_assert(check_acceessor<Evaluation, out, out_tag>::value, "");
-        static_assert(check_acceessor<Evaluation, in, in_tag>::value, "");
+        static_assert(check_acceessor<Evaluation, out, out_tag>);
+        static_assert(check_acceessor<Evaluation, in, in_tag>);
 
         local_tag local;
         call_proc<triple_nesting_with_type_switching_third_stage>::with(eval, out(), local);
@@ -70,8 +70,8 @@ struct triple_nesting_with_type_switching_first_stage {
 
     template <typename Evaluation>
     GT_FUNCTION static void apply(Evaluation &eval) {
-        static_assert(check_acceessor<Evaluation, out, out_tag>::value, "");
-        static_assert(check_acceessor<Evaluation, in, in_tag>::value, "");
+        static_assert(check_acceessor<Evaluation, out, out_tag>);
+        static_assert(check_acceessor<Evaluation, in, in_tag>);
 
         call_proc<triple_nesting_with_type_switching_second_stage>::with(eval, in(), out());
     }
diff --git a/tests/unit_tests/stencil/frontend/cartesian/test_call_stress_types.cpp b/tests/unit_tests/stencil/frontend/cartesian/test_call_stress_types.cpp
index dfe7534053..df5ca347e9 100644
--- a/tests/unit_tests/stencil/frontend/cartesian/test_call_stress_types.cpp
+++ b/tests/unit_tests/stencil/frontend/cartesian/test_call_stress_types.cpp
@@ -30,7 +30,7 @@ void do_test() {
 }
 
 template <class Eval, class Acc, class Expected>
-using check_acceessor = std::is_same<std::decay_t<decltype(std::declval<Eval &>()(Acc()))>, Expected>;
+constexpr bool check_acceessor = std::is_same_v<std::decay_t<decltype(std::declval<Eval &>()(Acc()))>, Expected>;
 
 struct in1_tag {};
 struct in2_tag {};
@@ -45,8 +45,8 @@ struct simple_callee_with_forced_return_type {
 
     template <typename Evaluation>
     GT_FUNCTION static void apply(Evaluation &eval) {
-        static_assert(check_acceessor<Evaluation, out, forced_tag>::value, "");
-        static_assert(check_acceessor<Evaluation, in, in1_tag>::value, "");
+        static_assert(check_acceessor<Evaluation, out, forced_tag>);
+        static_assert(check_acceessor<Evaluation, in, in1_tag>);
     }
 };
 
@@ -58,7 +58,7 @@ struct simple_caller_with_forced_return_type {
     template <typename Evaluation>
     GT_FUNCTION static void apply(Evaluation &eval) {
         auto result = call<simple_callee_with_forced_return_type>::return_type<forced_tag>::with(eval, in{});
-        static_assert(std::is_same<decltype(result), forced_tag>::value, "");
+        static_assert(std::is_same_v<decltype(result), forced_tag>);
     }
 
     void dummy() { do_test<simple_caller_with_forced_return_type, in1_tag, out_tag>(); }
@@ -71,8 +71,8 @@ struct simple_callee_with_deduced_return_type {
 
     template <typename Evaluation>
     GT_FUNCTION static void apply(Evaluation &eval) {
-        static_assert(check_acceessor<Evaluation, out, in1_tag>::value, "");
-        static_assert(check_acceessor<Evaluation, in, in1_tag>::value, "");
+        static_assert(check_acceessor<Evaluation, out, in1_tag>);
+        static_assert(check_acceessor<Evaluation, in, in1_tag>);
     }
 };
 
@@ -84,7 +84,7 @@ struct simple_caller_with_deduced_return_type {
     template <typename Evaluation>
     GT_FUNCTION static void apply(Evaluation &eval) {
         auto result = call<simple_callee_with_deduced_return_type>::with(eval, in{});
-        static_assert(std::is_same<decltype(result), in1_tag>::value, "");
+        static_assert(std::is_same_v<decltype(result), in1_tag>);
     }
     void dummy() { do_test<simple_caller_with_deduced_return_type, in1_tag, out_tag>(); }
 };
@@ -99,10 +99,10 @@ struct triple_nesting_with_type_switching_third_stage {
     template <typename Evaluation>
     GT_FUNCTION static void apply(Evaluation &eval) {
         // the new convention is that the return type (here "out) is deduced from the first argument in the call
-        static_assert(check_acceessor<Evaluation, out, in2_tag>::value, "");
-        static_assert(check_acceessor<Evaluation, in1, in1_tag>::value, "");
-        static_assert(check_acceessor<Evaluation, in2, in2_tag>::value, "");
-        static_assert(check_acceessor<Evaluation, local, local_tag>::value, "");
+        static_assert(check_acceessor<Evaluation, out, in2_tag>);
+        static_assert(check_acceessor<Evaluation, in1, in1_tag>);
+        static_assert(check_acceessor<Evaluation, in2, in2_tag>);
+        static_assert(check_acceessor<Evaluation, local, local_tag>);
     }
 };
 
@@ -116,14 +116,14 @@ struct triple_nesting_with_type_switching_second_stage {
     GT_FUNCTION static void apply(Evaluation &eval) {
         using out_type = std::decay_t<decltype(eval(out{}))>;
         // the expected type differs here in "call" vs "call_proc"
-        static_assert(check_acceessor<Evaluation, out, in1_tag>::value, "");
-        static_assert(check_acceessor<Evaluation, in1, in1_tag>::value, "");
-        static_assert(check_acceessor<Evaluation, in2, in2_tag>::value, "");
+        static_assert(check_acceessor<Evaluation, out, in1_tag>);
+        static_assert(check_acceessor<Evaluation, in1, in1_tag>);
+        static_assert(check_acceessor<Evaluation, in2, in2_tag>);
 
         local_tag local;
 
         auto result = call<triple_nesting_with_type_switching_third_stage>::with(eval, in2(), local, in1());
-        static_assert(std::is_same<decltype(result), in2_tag>::value, "");
+        static_assert(std::is_same_v<decltype(result), in2_tag>);
     }
 };
 
@@ -135,12 +135,12 @@ struct triple_nesting_with_type_switching_first_stage {
 
     template <typename Evaluation>
     GT_FUNCTION static void apply(Evaluation &eval) {
-        static_assert(check_acceessor<Evaluation, out, out_tag>::value, "");
-        static_assert(check_acceessor<Evaluation, in1, in1_tag>::value, "");
-        static_assert(check_acceessor<Evaluation, in2, in2_tag>::value, "");
+        static_assert(check_acceessor<Evaluation, out, out_tag>);
+        static_assert(check_acceessor<Evaluation, in1, in1_tag>);
+        static_assert(check_acceessor<Evaluation, in2, in2_tag>);
 
         auto result = call<triple_nesting_with_type_switching_second_stage>::with(eval, in1(), in2());
-        static_assert(std::is_same<decltype(result), in1_tag>::value, "");
+        static_assert(std::is_same_v<decltype(result), in1_tag>);
     }
     void dummy() { do_test<triple_nesting_with_type_switching_first_stage, in1_tag, out_tag, in2_tag>(); }
 };
@@ -155,14 +155,14 @@ struct triple_nesting_with_type_switching_and_call_proc_second_stage {
     GT_FUNCTION static void apply(Evaluation &eval) {
         // in contrast to the example where this is stage is called from "call" (not "call_proc")
         // the type here is different!
-        static_assert(check_acceessor<Evaluation, out, out_tag>::value, "");
-        static_assert(check_acceessor<Evaluation, in1, in1_tag>::value, "");
-        static_assert(check_acceessor<Evaluation, in2, in2_tag>::value, "");
+        static_assert(check_acceessor<Evaluation, out, out_tag>);
+        static_assert(check_acceessor<Evaluation, in1, in1_tag>);
+        static_assert(check_acceessor<Evaluation, in2, in2_tag>);
 
         local_tag local;
 
         auto result = call<triple_nesting_with_type_switching_third_stage>::with(eval, in2(), local, in1());
-        static_assert(std::is_same<decltype(result), in2_tag>::value, "");
+        static_assert(std::is_same_v<decltype(result), in2_tag>);
     }
 };
 
@@ -174,9 +174,9 @@ struct triple_nesting_with_type_switching_and_call_proc_first_stage {
 
     template <typename Evaluation>
     GT_FUNCTION static void apply(Evaluation &eval) {
-        static_assert(check_acceessor<Evaluation, out, out_tag>::value, "");
-        static_assert(check_acceessor<Evaluation, in1, in1_tag>::value, "");
-        static_assert(check_acceessor<Evaluation, in2, in2_tag>::value, "");
+        static_assert(check_acceessor<Evaluation, out, out_tag>);
+        static_assert(check_acceessor<Evaluation, in1, in1_tag>);
+        static_assert(check_acceessor<Evaluation, in2, in2_tag>);
 
         call_proc<triple_nesting_with_type_switching_and_call_proc_second_stage>::with(eval, in1(), out(), in2());
     }
diff --git a/tests/unit_tests/stencil/frontend/cartesian/test_expressions.cpp b/tests/unit_tests/stencil/frontend/cartesian/test_expressions.cpp
index 6d060dfeb3..d55b3bafcc 100644
--- a/tests/unit_tests/stencil/frontend/cartesian/test_expressions.cpp
+++ b/tests/unit_tests/stencil/frontend/cartesian/test_expressions.cpp
@@ -46,11 +46,11 @@ namespace gridtools {
 
                 using val = accessor_mock<float>;
 
-#define EXPRESSION_TEST(name, expr)                                      \
-    GT_FUNCTION float test_##name() {                                    \
-        auto result = iterate_domain_mock()(expr);                       \
-        static_assert(std::is_same<decltype(result), float>::value, ""); \
-        return result;                                                   \
+#define EXPRESSION_TEST(name, expr)                             \
+    GT_FUNCTION float test_##name() {                           \
+        auto result = iterate_domain_mock()(expr);              \
+        static_assert(std::is_same_v<decltype(result), float>); \
+        return result;                                          \
     }
 
                 EXPRESSION_TEST(add_accessors, val{1} + val{2})
diff --git a/tests/unit_tests/stencil/frontend/cartesian/test_expressions_integration.cpp b/tests/unit_tests/stencil/frontend/cartesian/test_expressions_integration.cpp
index be07ab3761..af67a8c9d4 100644
--- a/tests/unit_tests/stencil/frontend/cartesian/test_expressions_integration.cpp
+++ b/tests/unit_tests/stencil/frontend/cartesian/test_expressions_integration.cpp
@@ -107,8 +107,8 @@ namespace {
         run_single_stage(test_functor(),
             naive(),
             env_t::make_grid(),
-            make_global_parameter(2.),
-            make_global_parameter(3.),
+            global_parameter(2.),
+            global_parameter(3.),
             out,
             positional<dim::i>());
         env_t::verify(0, out);
diff --git a/tests/unit_tests/stencil/frontend/cartesian/test_stage_with_extents.cpp b/tests/unit_tests/stencil/frontend/cartesian/test_stage_with_extents.cpp
index 65cbed2682..5802a5fc63 100644
--- a/tests/unit_tests/stencil/frontend/cartesian/test_stage_with_extents.cpp
+++ b/tests/unit_tests/stencil/frontend/cartesian/test_stage_with_extents.cpp
@@ -34,12 +34,12 @@ namespace gridtools {
                                           .stage(stage(), c(), d());
 
                 template <class Arg, int_t... Is>
-                constexpr bool testee = std::is_same<decltype(get_arg_extent(spec, Arg())), extent<Is...>>::value;
+                constexpr bool testee = std::is_same_v<decltype(get_arg_extent(spec, Arg())), extent<Is...>>;
 
-                static_assert(testee<a, -6, 6>, "");
-                static_assert(testee<b, -5, 5>, "");
-                static_assert(testee<c, -3, 3>, "");
-                static_assert(testee<d>, "");
+                static_assert(testee<a, -6, 6>);
+                static_assert(testee<b, -5, 5>);
+                static_assert(testee<c, -3, 3>);
+                static_assert(testee<d>);
             } // namespace
         }     // namespace cartesian
     }         // namespace stencil
diff --git a/tests/unit_tests/stencil/frontend/icosahedral/test_from_to_mapping.cpp b/tests/unit_tests/stencil/frontend/icosahedral/test_from_to_mapping.cpp
index 8f8cf590ab..7cd27a9e73 100644
--- a/tests/unit_tests/stencil/frontend/icosahedral/test_from_to_mapping.cpp
+++ b/tests/unit_tests/stencil/frontend/icosahedral/test_from_to_mapping.cpp
@@ -20,37 +20,37 @@ template <class From, class To, int Color>
 constexpr bool testee = meta::first<meta::first<neighbor_offsets<From, To, Color>>>::value < 10;
 
 // From Cells to XXX
-static_assert(testee<cells, cells, 0>, "");
-static_assert(testee<cells, cells, 1>, "");
-static_assert(testee<cells, edges, 0>, "");
-static_assert(testee<cells, edges, 1>, "");
-static_assert(testee<cells, vertices, 0>, "");
-static_assert(testee<cells, vertices, 1>, "");
+static_assert(testee<cells, cells, 0>);
+static_assert(testee<cells, cells, 1>);
+static_assert(testee<cells, edges, 0>);
+static_assert(testee<cells, edges, 1>);
+static_assert(testee<cells, vertices, 0>);
+static_assert(testee<cells, vertices, 1>);
 
 // From Edges to XXX
-static_assert(testee<edges, cells, 0>, "");
-static_assert(testee<edges, cells, 1>, "");
-static_assert(testee<edges, cells, 2>, "");
-static_assert(testee<edges, edges, 0>, "");
-static_assert(testee<edges, edges, 1>, "");
-static_assert(testee<edges, edges, 2>, "");
-static_assert(testee<edges, vertices, 0>, "");
-static_assert(testee<edges, vertices, 1>, "");
-static_assert(testee<edges, vertices, 2>, "");
+static_assert(testee<edges, cells, 0>);
+static_assert(testee<edges, cells, 1>);
+static_assert(testee<edges, cells, 2>);
+static_assert(testee<edges, edges, 0>);
+static_assert(testee<edges, edges, 1>);
+static_assert(testee<edges, edges, 2>);
+static_assert(testee<edges, vertices, 0>);
+static_assert(testee<edges, vertices, 1>);
+static_assert(testee<edges, vertices, 2>);
 
 // From Vertices to XXX
-static_assert(testee<vertices, cells, 0>, "");
-static_assert(testee<vertices, edges, 0>, "");
-static_assert(testee<vertices, vertices, 0>, "");
+static_assert(testee<vertices, cells, 0>);
+static_assert(testee<vertices, edges, 0>);
+static_assert(testee<vertices, vertices, 0>);
 
-static_assert(std::is_same<neighbors_extent<cells, cells>, extent<-1, 1, -1, 1>>::value, "");
-static_assert(std::is_same<neighbors_extent<cells, edges>, extent<0, 1, 0, 1>>::value, "");
-static_assert(std::is_same<neighbors_extent<cells, vertices>, extent<0, 1, 0, 1>>::value, "");
+static_assert(std::is_same_v<neighbors_extent<cells, cells>, extent<-1, 1, -1, 1>>);
+static_assert(std::is_same_v<neighbors_extent<cells, edges>, extent<0, 1, 0, 1>>);
+static_assert(std::is_same_v<neighbors_extent<cells, vertices>, extent<0, 1, 0, 1>>);
 
-static_assert(std::is_same<neighbors_extent<edges, cells>, extent<-1, 0, -1, 0>>::value, "");
-static_assert(std::is_same<neighbors_extent<edges, edges>, extent<-1, 1, -1, 1>>::value, "");
-static_assert(std::is_same<neighbors_extent<edges, vertices>, extent<0, 1, 0, 1>>::value, "");
+static_assert(std::is_same_v<neighbors_extent<edges, cells>, extent<-1, 0, -1, 0>>);
+static_assert(std::is_same_v<neighbors_extent<edges, edges>, extent<-1, 1, -1, 1>>);
+static_assert(std::is_same_v<neighbors_extent<edges, vertices>, extent<0, 1, 0, 1>>);
 
-static_assert(std::is_same<neighbors_extent<vertices, cells>, extent<-1, 0, -1, 0>>::value, "");
-static_assert(std::is_same<neighbors_extent<vertices, edges>, extent<-1, 0, -1, 0>>::value, "");
-static_assert(std::is_same<neighbors_extent<vertices, vertices>, extent<-1, 1, -1, 1>>::value, "");
+static_assert(std::is_same_v<neighbors_extent<vertices, cells>, extent<-1, 0, -1, 0>>);
+static_assert(std::is_same_v<neighbors_extent<vertices, edges>, extent<-1, 0, -1, 0>>);
+static_assert(std::is_same_v<neighbors_extent<vertices, vertices>, extent<-1, 1, -1, 1>>);
diff --git a/tests/unit_tests/stencil/frontend/test_axis.cpp b/tests/unit_tests/stencil/frontend/test_axis.cpp
index 51546fc809..056b79acf2 100644
--- a/tests/unit_tests/stencil/frontend/test_axis.cpp
+++ b/tests/unit_tests/stencil/frontend/test_axis.cpp
@@ -36,15 +36,15 @@ namespace intervals {
 
     template <class T, uint_t FromSplitter, int_t FromOffset, uint_t ToSplitter, int_t ToOffset>
     constexpr bool testee =
-        std::is_same<T, interval<level_t<FromSplitter, FromOffset>, level_t<ToSplitter, ToOffset>>>::value;
+        std::is_same_v<T, interval<level_t<FromSplitter, FromOffset>, level_t<ToSplitter, ToOffset>>>;
 
     // full interval
-    static_assert(testee<axis_t::full_interval, 0, 1, 3, -1>, "");
+    static_assert(testee<axis_t::full_interval, 0, 1, 3, -1>);
 
     // intervals by id
-    static_assert(testee<axis_t::get_interval<0>, 0, 1, 1, -1>, "");
-    static_assert(testee<axis_t::get_interval<1>, 1, 1, 2, -1>, "");
+    static_assert(testee<axis_t::get_interval<0>, 0, 1, 1, -1>);
+    static_assert(testee<axis_t::get_interval<1>, 1, 1, 2, -1>);
 
     // hull of multiple intervals
-    static_assert(testee<axis_t::get_interval<1, 2>, 1, 1, 3, -1>, "");
+    static_assert(testee<axis_t::get_interval<1, 2>, 1, 1, 3, -1>);
 } // namespace intervals
diff --git a/tests/unit_tests/stencil/gpu/test_ij_cache.cu b/tests/unit_tests/stencil/gpu/test_ij_cache.cu
index 0aac1ca075..06da9740b6 100644
--- a/tests/unit_tests/stencil/gpu/test_ij_cache.cu
+++ b/tests/unit_tests/stencil/gpu/test_ij_cache.cu
@@ -34,13 +34,13 @@ namespace gridtools {
 
                 using ij_cache_t = decltype(testee);
 
-                static_assert(is_sid<ij_cache_t>(), "");
-                static_assert(std::is_same<sid::ptr_type<ij_cache_t>, double *>(), "");
-                static_assert(std::is_same<sid::ptr_diff_type<ij_cache_t>, int_t>(), "");
+                static_assert(is_sid<ij_cache_t>());
+                static_assert(std::is_same_v<sid::ptr_type<ij_cache_t>, double *>);
+                static_assert(std::is_same_v<sid::ptr_diff_type<ij_cache_t>, int_t>);
 
                 using expected_kind = hymap::keys<dim::c, dim::i, dim::j>::
                     values<integral_constant<int_t, 1>, integral_constant<int_t, 1>, integral_constant<int_t, 9>>;
-                static_assert(std::is_same<sid::strides_kind<ij_cache_t>, expected_kind>(), "");
+                static_assert(std::is_same_v<sid::strides_kind<ij_cache_t>, expected_kind>);
                 auto strides = sid::get_strides(testee);
                 EXPECT_EQ(1, at_key<dim::i>(strides));
                 EXPECT_EQ(9, at_key<dim::j>(strides));
diff --git a/tests/unit_tests/stencil/gpu/test_shared_allocator.cu b/tests/unit_tests/stencil/gpu/test_shared_allocator.cu
index ffa8265d2f..959970bbf9 100644
--- a/tests/unit_tests/stencil/gpu/test_shared_allocator.cu
+++ b/tests/unit_tests/stencil/gpu/test_shared_allocator.cu
@@ -53,9 +53,9 @@ namespace gridtools {
                 template <class PtrHolderFloat, class PtrHolderInt>
                 __global__ void fill_and_check_test(
                     PtrHolderFloat holder1, PtrHolderFloat holder1_shifted, PtrHolderInt holder2, bool *result) {
-                    static_assert(std::is_same<decltype(holder1()), float *>::value, "");
-                    static_assert(std::is_same<decltype(holder1_shifted()), float *>::value, "");
-                    static_assert(std::is_same<decltype(holder2()), int16_t *>::value, "");
+                    static_assert(std::is_same_v<decltype(holder1()), float *>);
+                    static_assert(std::is_same_v<decltype(holder1_shifted()), float *>);
+                    static_assert(std::is_same_v<decltype(holder2()), int16_t *>);
 
                     auto ptr1 = holder1();
                     auto ptr1_shifted = holder1_shifted();
diff --git a/tests/unit_tests/stencil/gpu/test_simple_device_memory_allocator.cu b/tests/unit_tests/stencil/gpu/test_simple_device_memory_allocator.cu
index d11868b2ef..e33425cc4b 100644
--- a/tests/unit_tests/stencil/gpu/test_simple_device_memory_allocator.cu
+++ b/tests/unit_tests/stencil/gpu/test_simple_device_memory_allocator.cu
@@ -31,7 +31,7 @@ namespace gridtools {
         __global__ void test_allocated(PtrHolder testee, bool *result) {}
 
         TEST(simple_device_memory_allocator, test) {
-            sid::device::allocator<GT_INTEGRAL_CONSTANT_FROM_VALUE(&cuda_util::cuda_malloc<char[]>)> alloc;
+            sid::allocator<GT_INTEGRAL_CONSTANT_FROM_VALUE(&cuda_util::cuda_malloc<char[]>)> alloc;
             auto ptr_holder = allocate(alloc, meta::lazy::id<double>{}, 1);
 
             auto result = gridtools::on_device::exec(
diff --git a/tests/unit_tests/stencil/gpu/test_tmp_storage_sid.cpp b/tests/unit_tests/stencil/gpu/test_tmp_storage_sid.cpp
index 215ba87625..15e9a285cf 100644
--- a/tests/unit_tests/stencil/gpu/test_tmp_storage_sid.cpp
+++ b/tests/unit_tests/stencil/gpu/test_tmp_storage_sid.cpp
@@ -36,7 +36,7 @@ namespace gridtools {
                 TEST(tmp_cuda_storage_sid, write_in_blocks) {
                     using index_info = multiplet<5>;
 
-                    auto alloc = sid::make_allocator(&std::make_unique<char[]>);
+                    auto alloc = sid::allocator(&std::make_unique<char[]>);
 
                     auto testee = make_tmp_storage<index_info>(
                         1_c, blocksize_i, blocksize_j, extent_t{}, n_blocks_i, n_blocks_j, k_size, alloc);
@@ -51,11 +51,11 @@ namespace gridtools {
                                 for (int bj = 0; bj < n_blocks_j; ++bj)
                                     for (int k = 0; k < k_size; ++k) {
                                         auto ptr = origin();
-                                        sid::shift(ptr, host::at_key<dim::i>(strides), i);
-                                        sid::shift(ptr, host::at_key<dim::j>(strides), j);
-                                        sid::shift(ptr, host::at_key<sid::blocked_dim<dim::i>>(strides), bi);
-                                        sid::shift(ptr, host::at_key<sid::blocked_dim<dim::j>>(strides), bj);
-                                        sid::shift(ptr, host::at_key<dim::k>(strides), k);
+                                        sid::shift(ptr, at_key<dim::i>(strides), i);
+                                        sid::shift(ptr, at_key<dim::j>(strides), j);
+                                        sid::shift(ptr, at_key<sid::blocked_dim<dim::i>>(strides), bi);
+                                        sid::shift(ptr, at_key<sid::blocked_dim<dim::j>>(strides), bj);
+                                        sid::shift(ptr, at_key<dim::k>(strides), k);
                                         *ptr = {i, j, bi, bj, k};
                                     }
                     // validate that block id is correct, i.e. there were no overlapping memory accesses in the write
@@ -65,11 +65,11 @@ namespace gridtools {
                                 for (int bj = 0; bj < n_blocks_j; ++bj)
                                     for (int k = 0; k < k_size; ++k) {
                                         auto ptr = origin();
-                                        sid::shift(ptr, host::at_key<dim::i>(strides), i);
-                                        sid::shift(ptr, host::at_key<dim::j>(strides), j);
-                                        sid::shift(ptr, host::at_key<sid::blocked_dim<dim::i>>(strides), bi);
-                                        sid::shift(ptr, host::at_key<sid::blocked_dim<dim::j>>(strides), bj);
-                                        sid::shift(ptr, host::at_key<dim::k>(strides), k);
+                                        sid::shift(ptr, at_key<dim::i>(strides), i);
+                                        sid::shift(ptr, at_key<dim::j>(strides), j);
+                                        sid::shift(ptr, at_key<sid::blocked_dim<dim::i>>(strides), bi);
+                                        sid::shift(ptr, at_key<sid::blocked_dim<dim::j>>(strides), bj);
+                                        sid::shift(ptr, at_key<dim::k>(strides), k);
                                         EXPECT_EQ((index_info{i, j, bi, bj, k}), *ptr);
                                     }
                 }
@@ -78,7 +78,7 @@ namespace gridtools {
                 TEST(tmp_cuda_storage_sid_block, write_in_blocks) {
                     using index_info = multiplet<6>;
 
-                    auto alloc = sid::make_allocator(&std::make_unique<char[]>);
+                    auto alloc = sid::allocator(&std::make_unique<char[]>);
 
                     auto testee = make_tmp_storage<index_info>(
                         2_c, blocksize_i, blocksize_j, extent_t{}, n_blocks_i, n_blocks_j, k_size, alloc);
@@ -94,12 +94,12 @@ namespace gridtools {
                                     for (int bj = 0; bj < n_blocks_j; ++bj)
                                         for (int k = 0; k < k_size; ++k) {
                                             auto ptr = origin();
-                                            sid::shift(ptr, host::at_key<dim::i>(strides), i);
-                                            sid::shift(ptr, host::at_key<dim::j>(strides), j);
-                                            sid::shift(ptr, host::at_key<dim::c>(strides), c);
-                                            sid::shift(ptr, host::at_key<sid::blocked_dim<dim::i>>(strides), bi);
-                                            sid::shift(ptr, host::at_key<sid::blocked_dim<dim::j>>(strides), bj);
-                                            sid::shift(ptr, host::at_key<dim::k>(strides), k);
+                                            sid::shift(ptr, at_key<dim::i>(strides), i);
+                                            sid::shift(ptr, at_key<dim::j>(strides), j);
+                                            sid::shift(ptr, at_key<dim::c>(strides), c);
+                                            sid::shift(ptr, at_key<sid::blocked_dim<dim::i>>(strides), bi);
+                                            sid::shift(ptr, at_key<sid::blocked_dim<dim::j>>(strides), bj);
+                                            sid::shift(ptr, at_key<dim::k>(strides), k);
                                             *ptr = {i, j, c, bi, bj, k};
                                         }
 
@@ -111,12 +111,12 @@ namespace gridtools {
                                     for (int bj = 0; bj < n_blocks_j; ++bj)
                                         for (int k = 0; k < k_size; ++k) {
                                             auto ptr = origin();
-                                            sid::shift(ptr, host::at_key<dim::i>(strides), i);
-                                            sid::shift(ptr, host::at_key<dim::j>(strides), j);
-                                            sid::shift(ptr, host::at_key<dim::c>(strides), c);
-                                            sid::shift(ptr, host::at_key<sid::blocked_dim<dim::i>>(strides), bi);
-                                            sid::shift(ptr, host::at_key<sid::blocked_dim<dim::j>>(strides), bj);
-                                            sid::shift(ptr, host::at_key<dim::k>(strides), k);
+                                            sid::shift(ptr, at_key<dim::i>(strides), i);
+                                            sid::shift(ptr, at_key<dim::j>(strides), j);
+                                            sid::shift(ptr, at_key<dim::c>(strides), c);
+                                            sid::shift(ptr, at_key<sid::blocked_dim<dim::i>>(strides), bi);
+                                            sid::shift(ptr, at_key<sid::blocked_dim<dim::j>>(strides), bj);
+                                            sid::shift(ptr, at_key<dim::k>(strides), k);
                                             EXPECT_EQ((index_info{i, j, c, bi, bj, k}), *ptr);
                                         }
                 }
diff --git a/tests/unit_tests/stencil/gpu/test_tmp_storage_sid.cu b/tests/unit_tests/stencil/gpu/test_tmp_storage_sid.cu
index e517901f30..61b3ad720a 100644
--- a/tests/unit_tests/stencil/gpu/test_tmp_storage_sid.cu
+++ b/tests/unit_tests/stencil/gpu/test_tmp_storage_sid.cu
@@ -39,7 +39,7 @@ namespace gridtools {
             };
 
             TEST(tmp_cuda_storage, maker_with_device_allocator) {
-                sid::device::allocator<GT_INTEGRAL_CONSTANT_FROM_VALUE(&cuda_util::cuda_malloc<char[]>)> alloc;
+                sid::allocator<GT_INTEGRAL_CONSTANT_FROM_VALUE(&cuda_util::cuda_malloc<char[]>)> alloc;
                 auto testee = gpu_backend::make_tmp_storage<int>(1_c, 2_c, 2_c, extent<>{}, 1, 1, 2, alloc);
                 EXPECT_TRUE(on_device::exec(smoke_f{}, sid::get_origin(testee), sid::get_strides(testee)));
             }
diff --git a/tests/unit_tests/stencil/test_global_parameter.cpp b/tests/unit_tests/stencil/test_global_parameter.cpp
index 47661677a8..601b098c6f 100644
--- a/tests/unit_tests/stencil/test_global_parameter.cpp
+++ b/tests/unit_tests/stencil/test_global_parameter.cpp
@@ -17,17 +17,17 @@ namespace gridtools {
     namespace stencil {
         namespace {
             TEST(global_parameter, smoke) {
-                auto testee = make_global_parameter(42.);
+                auto testee = global_parameter(42.);
                 using testee_t = decltype(testee);
 
-                static_assert(is_sid<testee_t>(), "");
-                static_assert(std::is_same<sid::element_type<testee_t>, double>(), "");
-                static_assert(std::is_same<sid::reference_type<testee_t>, double>(), "");
-                static_assert(sizeof(sid::ptr_holder_type<testee_t>) == sizeof(double), "");
-                static_assert(sizeof(sid::ptr_type<testee_t>) == sizeof(double), "");
-                static_assert(std::is_empty<sid::ptr_diff_type<testee_t>>(), "");
-                static_assert(std::is_empty<sid::strides_type<testee_t>>(), "");
-                static_assert(tuple_util::size<sid::strides_type<testee_t>>::value == 0, "");
+                static_assert(is_sid<testee_t>());
+                static_assert(std::is_same_v<sid::element_type<testee_t>, double>);
+                static_assert(std::is_same_v<sid::reference_type<testee_t>, double>);
+                static_assert(sizeof(sid::ptr_holder_type<testee_t>) == sizeof(double));
+                static_assert(sizeof(sid::ptr_type<testee_t>) == sizeof(double));
+                static_assert(std::is_empty_v<sid::ptr_diff_type<testee_t>>);
+                static_assert(std::is_empty_v<sid::strides_type<testee_t>>);
+                static_assert(tuple_util::size<sid::strides_type<testee_t>>::value == 0);
 
                 EXPECT_EQ(42., *sid::get_origin(testee)());
             }
diff --git a/tests/unit_tests/stencil/test_positional.cpp b/tests/unit_tests/stencil/test_positional.cpp
index d388f9eee1..53c1091927 100644
--- a/tests/unit_tests/stencil/test_positional.cpp
+++ b/tests/unit_tests/stencil/test_positional.cpp
@@ -20,7 +20,7 @@ namespace gridtools {
             struct d;
             using testee_t = positional<d>;
 
-            static_assert(is_sid<testee_t>(), "");
+            static_assert(is_sid<testee_t>());
 
             TEST(positional, smoke) {
                 testee_t testee{1};
diff --git a/tests/unit_tests/storage/test_storage_facility.cpp b/tests/unit_tests/storage/test_storage_facility.cpp
index 18ac0d5daa..46f96c6ba3 100644
--- a/tests/unit_tests/storage/test_storage_facility.cpp
+++ b/tests/unit_tests/storage/test_storage_facility.cpp
@@ -66,143 +66,143 @@ TEST(StorageFacility, ViewTests) {
 
 template <int... Args>
 static constexpr bool expect_layout =
-    std::is_same<typename decltype(builder.dimensions(Args...)())::element_type::layout_t, layout_map<Args...>>::value;
+    std::is_same_v<typename decltype(builder.dimensions(Args...)())::element_type::layout_t, layout_map<Args...>>;
 
 template <class Layout, int... Args>
 static constexpr bool expect_special_layout =
-    std::is_same<typename decltype(builder.selector<Args...>().dimensions(Args...)())::element_type::layout_t,
-        Layout>::value;
+    std::is_same_v<typename decltype(builder.selector<Args...>().dimensions(Args...)())::element_type::layout_t,
+        Layout>;
 
 template <int... Args>
 static constexpr bool expect_custom_layout =
-    std::is_same<typename decltype(builder.layout<Args...>().dimensions(Args...)())::element_type::layout_t,
-        layout_map<Args...>>::value;
+    std::is_same_v<typename decltype(builder.layout<Args...>().dimensions(Args...)())::element_type::layout_t,
+        layout_map<Args...>>;
 
-static_assert(expect_custom_layout<2, 1, 0>, "");
-static_assert(expect_custom_layout<1, 0>, "");
-static_assert(expect_custom_layout<2, -1, 1, 0>, "");
+static_assert(expect_custom_layout<2, 1, 0>);
+static_assert(expect_custom_layout<1, 0>);
+static_assert(expect_custom_layout<2, -1, 1, 0>);
 
 #if defined(GT_STORAGE_CPU_KFIRST)
 
-static_assert(expect_layout<0>, "");
-static_assert(expect_layout<0, 1>, "");
-static_assert(expect_layout<0, 1, 2>, "");
-static_assert(expect_layout<1, 2, 3, 0>, "");
-static_assert(expect_layout<2, 3, 4, 0, 1>, "");
-
-static_assert(expect_special_layout<layout_map<2, 3, 4, 0, 1>, 1, 1, 1, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<-1, 2, 3, 0, 1>, 0, 1, 1, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<2, -1, 3, 0, 1>, 1, 0, 1, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<2, 3, -1, 0, 1>, 1, 1, 0, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<1, 2, 3, -1, 0>, 1, 1, 1, 0, 1>, "");
-static_assert(expect_special_layout<layout_map<1, 2, 3, 0, -1>, 1, 1, 1, 1, 0>, "");
-
-static_assert(expect_special_layout<layout_map<-1, -1, 2, 0, 1>, 0, 0, 1, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<2, -1, -1, 0, 1>, 1, 0, 0, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<1, 2, -1, -1, 0>, 1, 1, 0, 0, 1>, "");
-static_assert(expect_special_layout<layout_map<0, 1, 2, -1, -1>, 1, 1, 1, 0, 0>, "");
-
-static_assert(expect_special_layout<layout_map<-1, 2, -1, 0, 1>, 0, 1, 0, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<1, -1, 2, -1, 0>, 1, 0, 1, 0, 1>, "");
-static_assert(expect_special_layout<layout_map<1, 2, -1, 0, -1>, 1, 1, 0, 1, 0>, "");
-
-static_assert(expect_special_layout<layout_map<-1, 1, 2, -1, 0>, 0, 1, 1, 0, 1>, "");
-static_assert(expect_special_layout<layout_map<1, -1, 2, 0, -1>, 1, 0, 1, 1, 0>, "");
-
-static_assert(expect_special_layout<layout_map<-1, 1, 2, 0, -1>, 0, 1, 1, 1, 0>, "");
-
-static_assert(expect_special_layout<layout_map<-1, -1, -1, 0, 1>, 0, 0, 0, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<1, -1, -1, -1, 0>, 1, 0, 0, 0, 1>, "");
-static_assert(expect_special_layout<layout_map<0, 1, -1, -1, -1>, 1, 1, 0, 0, 0>, "");
-static_assert(expect_special_layout<layout_map<-1, 0, 1, -1, -1>, 0, 1, 1, 0, 0>, "");
-static_assert(expect_special_layout<layout_map<-1, -1, 1, 0, -1>, 0, 0, 1, 1, 0>, "");
-
-static_assert(expect_special_layout<layout_map<0, -1, -1, -1, -1>, 1, 0, 0, 0, 0>, "");
-static_assert(expect_special_layout<layout_map<-1, 0, -1, -1, -1>, 0, 1, 0, 0, 0>, "");
-static_assert(expect_special_layout<layout_map<-1, -1, 0, -1, -1>, 0, 0, 1, 0, 0>, "");
-static_assert(expect_special_layout<layout_map<-1, -1, -1, 0, -1>, 0, 0, 0, 1, 0>, "");
-static_assert(expect_special_layout<layout_map<-1, -1, -1, -1, 0>, 0, 0, 0, 0, 1>, "");
+static_assert(expect_layout<0>);
+static_assert(expect_layout<0, 1>);
+static_assert(expect_layout<0, 1, 2>);
+static_assert(expect_layout<1, 2, 3, 0>);
+static_assert(expect_layout<2, 3, 4, 0, 1>);
+
+static_assert(expect_special_layout<layout_map<2, 3, 4, 0, 1>, 1, 1, 1, 1, 1>);
+static_assert(expect_special_layout<layout_map<-1, 2, 3, 0, 1>, 0, 1, 1, 1, 1>);
+static_assert(expect_special_layout<layout_map<2, -1, 3, 0, 1>, 1, 0, 1, 1, 1>);
+static_assert(expect_special_layout<layout_map<2, 3, -1, 0, 1>, 1, 1, 0, 1, 1>);
+static_assert(expect_special_layout<layout_map<1, 2, 3, -1, 0>, 1, 1, 1, 0, 1>);
+static_assert(expect_special_layout<layout_map<1, 2, 3, 0, -1>, 1, 1, 1, 1, 0>);
+
+static_assert(expect_special_layout<layout_map<-1, -1, 2, 0, 1>, 0, 0, 1, 1, 1>);
+static_assert(expect_special_layout<layout_map<2, -1, -1, 0, 1>, 1, 0, 0, 1, 1>);
+static_assert(expect_special_layout<layout_map<1, 2, -1, -1, 0>, 1, 1, 0, 0, 1>);
+static_assert(expect_special_layout<layout_map<0, 1, 2, -1, -1>, 1, 1, 1, 0, 0>);
+
+static_assert(expect_special_layout<layout_map<-1, 2, -1, 0, 1>, 0, 1, 0, 1, 1>);
+static_assert(expect_special_layout<layout_map<1, -1, 2, -1, 0>, 1, 0, 1, 0, 1>);
+static_assert(expect_special_layout<layout_map<1, 2, -1, 0, -1>, 1, 1, 0, 1, 0>);
+
+static_assert(expect_special_layout<layout_map<-1, 1, 2, -1, 0>, 0, 1, 1, 0, 1>);
+static_assert(expect_special_layout<layout_map<1, -1, 2, 0, -1>, 1, 0, 1, 1, 0>);
+
+static_assert(expect_special_layout<layout_map<-1, 1, 2, 0, -1>, 0, 1, 1, 1, 0>);
+
+static_assert(expect_special_layout<layout_map<-1, -1, -1, 0, 1>, 0, 0, 0, 1, 1>);
+static_assert(expect_special_layout<layout_map<1, -1, -1, -1, 0>, 1, 0, 0, 0, 1>);
+static_assert(expect_special_layout<layout_map<0, 1, -1, -1, -1>, 1, 1, 0, 0, 0>);
+static_assert(expect_special_layout<layout_map<-1, 0, 1, -1, -1>, 0, 1, 1, 0, 0>);
+static_assert(expect_special_layout<layout_map<-1, -1, 1, 0, -1>, 0, 0, 1, 1, 0>);
+
+static_assert(expect_special_layout<layout_map<0, -1, -1, -1, -1>, 1, 0, 0, 0, 0>);
+static_assert(expect_special_layout<layout_map<-1, 0, -1, -1, -1>, 0, 1, 0, 0, 0>);
+static_assert(expect_special_layout<layout_map<-1, -1, 0, -1, -1>, 0, 0, 1, 0, 0>);
+static_assert(expect_special_layout<layout_map<-1, -1, -1, 0, -1>, 0, 0, 0, 1, 0>);
+static_assert(expect_special_layout<layout_map<-1, -1, -1, -1, 0>, 0, 0, 0, 0, 1>);
 
 #elif defined(GT_STORAGE_CPU_IFIRST)
 
-static_assert(expect_layout<0>, "");
-static_assert(expect_layout<1, 0>, "");
-static_assert(expect_layout<2, 0, 1>, "");
-static_assert(expect_layout<3, 1, 2, 0>, "");
-static_assert(expect_layout<4, 2, 3, 1, 0>, "");
-
-static_assert(expect_special_layout<layout_map<4, 2, 3, 1, 0>, 1, 1, 1, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<-1, 2, 3, 1, 0>, 0, 1, 1, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<3, -1, 2, 1, 0>, 1, 0, 1, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<3, 2, -1, 1, 0>, 1, 1, 0, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<3, 1, 2, -1, 0>, 1, 1, 1, 0, 1>, "");
-static_assert(expect_special_layout<layout_map<3, 1, 2, 0, -1>, 1, 1, 1, 1, 0>, "");
-
-static_assert(expect_special_layout<layout_map<-1, -1, 2, 1, 0>, 0, 0, 1, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<2, -1, -1, 1, 0>, 1, 0, 0, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<2, 1, -1, -1, 0>, 1, 1, 0, 0, 1>, "");
-static_assert(expect_special_layout<layout_map<2, 0, 1, -1, -1>, 1, 1, 1, 0, 0>, "");
-
-static_assert(expect_special_layout<layout_map<-1, 2, -1, 1, 0>, 0, 1, 0, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<2, -1, 1, -1, 0>, 1, 0, 1, 0, 1>, "");
-static_assert(expect_special_layout<layout_map<2, 1, -1, 0, -1>, 1, 1, 0, 1, 0>, "");
-
-static_assert(expect_special_layout<layout_map<-1, 1, 2, -1, 0>, 0, 1, 1, 0, 1>, "");
-static_assert(expect_special_layout<layout_map<2, -1, 1, 0, -1>, 1, 0, 1, 1, 0>, "");
-
-static_assert(expect_special_layout<layout_map<-1, 1, 2, 0, -1>, 0, 1, 1, 1, 0>, "");
-
-static_assert(expect_special_layout<layout_map<-1, -1, -1, 1, 0>, 0, 0, 0, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<1, -1, -1, -1, 0>, 1, 0, 0, 0, 1>, "");
-static_assert(expect_special_layout<layout_map<1, 0, -1, -1, -1>, 1, 1, 0, 0, 0>, "");
-static_assert(expect_special_layout<layout_map<-1, 0, 1, -1, -1>, 0, 1, 1, 0, 0>, "");
-static_assert(expect_special_layout<layout_map<-1, -1, 1, 0, -1>, 0, 0, 1, 1, 0>, "");
-
-static_assert(expect_special_layout<layout_map<0, -1, -1, -1, -1>, 1, 0, 0, 0, 0>, "");
-static_assert(expect_special_layout<layout_map<-1, 0, -1, -1, -1>, 0, 1, 0, 0, 0>, "");
-static_assert(expect_special_layout<layout_map<-1, -1, 0, -1, -1>, 0, 0, 1, 0, 0>, "");
-static_assert(expect_special_layout<layout_map<-1, -1, -1, 0, -1>, 0, 0, 0, 1, 0>, "");
-static_assert(expect_special_layout<layout_map<-1, -1, -1, -1, 0>, 0, 0, 0, 0, 1>, "");
+static_assert(expect_layout<0>);
+static_assert(expect_layout<1, 0>);
+static_assert(expect_layout<2, 0, 1>);
+static_assert(expect_layout<3, 1, 2, 0>);
+static_assert(expect_layout<4, 2, 3, 1, 0>);
+
+static_assert(expect_special_layout<layout_map<4, 2, 3, 1, 0>, 1, 1, 1, 1, 1>);
+static_assert(expect_special_layout<layout_map<-1, 2, 3, 1, 0>, 0, 1, 1, 1, 1>);
+static_assert(expect_special_layout<layout_map<3, -1, 2, 1, 0>, 1, 0, 1, 1, 1>);
+static_assert(expect_special_layout<layout_map<3, 2, -1, 1, 0>, 1, 1, 0, 1, 1>);
+static_assert(expect_special_layout<layout_map<3, 1, 2, -1, 0>, 1, 1, 1, 0, 1>);
+static_assert(expect_special_layout<layout_map<3, 1, 2, 0, -1>, 1, 1, 1, 1, 0>);
+
+static_assert(expect_special_layout<layout_map<-1, -1, 2, 1, 0>, 0, 0, 1, 1, 1>);
+static_assert(expect_special_layout<layout_map<2, -1, -1, 1, 0>, 1, 0, 0, 1, 1>);
+static_assert(expect_special_layout<layout_map<2, 1, -1, -1, 0>, 1, 1, 0, 0, 1>);
+static_assert(expect_special_layout<layout_map<2, 0, 1, -1, -1>, 1, 1, 1, 0, 0>);
+
+static_assert(expect_special_layout<layout_map<-1, 2, -1, 1, 0>, 0, 1, 0, 1, 1>);
+static_assert(expect_special_layout<layout_map<2, -1, 1, -1, 0>, 1, 0, 1, 0, 1>);
+static_assert(expect_special_layout<layout_map<2, 1, -1, 0, -1>, 1, 1, 0, 1, 0>);
+
+static_assert(expect_special_layout<layout_map<-1, 1, 2, -1, 0>, 0, 1, 1, 0, 1>);
+static_assert(expect_special_layout<layout_map<2, -1, 1, 0, -1>, 1, 0, 1, 1, 0>);
+
+static_assert(expect_special_layout<layout_map<-1, 1, 2, 0, -1>, 0, 1, 1, 1, 0>);
+
+static_assert(expect_special_layout<layout_map<-1, -1, -1, 1, 0>, 0, 0, 0, 1, 1>);
+static_assert(expect_special_layout<layout_map<1, -1, -1, -1, 0>, 1, 0, 0, 0, 1>);
+static_assert(expect_special_layout<layout_map<1, 0, -1, -1, -1>, 1, 1, 0, 0, 0>);
+static_assert(expect_special_layout<layout_map<-1, 0, 1, -1, -1>, 0, 1, 1, 0, 0>);
+static_assert(expect_special_layout<layout_map<-1, -1, 1, 0, -1>, 0, 0, 1, 1, 0>);
+
+static_assert(expect_special_layout<layout_map<0, -1, -1, -1, -1>, 1, 0, 0, 0, 0>);
+static_assert(expect_special_layout<layout_map<-1, 0, -1, -1, -1>, 0, 1, 0, 0, 0>);
+static_assert(expect_special_layout<layout_map<-1, -1, 0, -1, -1>, 0, 0, 1, 0, 0>);
+static_assert(expect_special_layout<layout_map<-1, -1, -1, 0, -1>, 0, 0, 0, 1, 0>);
+static_assert(expect_special_layout<layout_map<-1, -1, -1, -1, 0>, 0, 0, 0, 0, 1>);
 
 #elif defined(GT_STORAGE_GPU)
 
-static_assert(expect_layout<0>, "");
-static_assert(expect_layout<1, 0>, "");
-static_assert(expect_layout<2, 1, 0>, "");
-static_assert(expect_layout<3, 2, 1, 0>, "");
-static_assert(expect_layout<4, 3, 2, 1, 0>, "");
-
-static_assert(expect_special_layout<layout_map<4, 3, 2, 1, 0>, 1, 1, 1, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<-1, 3, 2, 1, 0>, 0, 1, 1, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<3, -1, 2, 1, 0>, 1, 0, 1, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<3, 2, -1, 1, 0>, 1, 1, 0, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<3, 2, 1, -1, 0>, 1, 1, 1, 0, 1>, "");
-static_assert(expect_special_layout<layout_map<3, 2, 1, 0, -1>, 1, 1, 1, 1, 0>, "");
-
-static_assert(expect_special_layout<layout_map<-1, -1, 2, 1, 0>, 0, 0, 1, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<2, -1, -1, 1, 0>, 1, 0, 0, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<2, 1, -1, -1, 0>, 1, 1, 0, 0, 1>, "");
-static_assert(expect_special_layout<layout_map<2, 1, 0, -1, -1>, 1, 1, 1, 0, 0>, "");
-
-static_assert(expect_special_layout<layout_map<-1, 2, -1, 1, 0>, 0, 1, 0, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<2, -1, 1, -1, 0>, 1, 0, 1, 0, 1>, "");
-static_assert(expect_special_layout<layout_map<2, 1, -1, 0, -1>, 1, 1, 0, 1, 0>, "");
-
-static_assert(expect_special_layout<layout_map<-1, 2, 1, -1, 0>, 0, 1, 1, 0, 1>, "");
-static_assert(expect_special_layout<layout_map<2, -1, 1, 0, -1>, 1, 0, 1, 1, 0>, "");
-
-static_assert(expect_special_layout<layout_map<-1, 2, 1, 0, -1>, 0, 1, 1, 1, 0>, "");
-
-static_assert(expect_special_layout<layout_map<-1, -1, -1, 1, 0>, 0, 0, 0, 1, 1>, "");
-static_assert(expect_special_layout<layout_map<1, -1, -1, -1, 0>, 1, 0, 0, 0, 1>, "");
-static_assert(expect_special_layout<layout_map<1, 0, -1, -1, -1>, 1, 1, 0, 0, 0>, "");
-static_assert(expect_special_layout<layout_map<-1, 1, 0, -1, -1>, 0, 1, 1, 0, 0>, "");
-static_assert(expect_special_layout<layout_map<-1, -1, 1, 0, -1>, 0, 0, 1, 1, 0>, "");
-
-static_assert(expect_special_layout<layout_map<0, -1, -1, -1, -1>, 1, 0, 0, 0, 0>, "");
-static_assert(expect_special_layout<layout_map<-1, 0, -1, -1, -1>, 0, 1, 0, 0, 0>, "");
-static_assert(expect_special_layout<layout_map<-1, -1, 0, -1, -1>, 0, 0, 1, 0, 0>, "");
-static_assert(expect_special_layout<layout_map<-1, -1, -1, 0, -1>, 0, 0, 0, 1, 0>, "");
-static_assert(expect_special_layout<layout_map<-1, -1, -1, -1, 0>, 0, 0, 0, 0, 1>, "");
+static_assert(expect_layout<0>);
+static_assert(expect_layout<1, 0>);
+static_assert(expect_layout<2, 1, 0>);
+static_assert(expect_layout<3, 2, 1, 0>);
+static_assert(expect_layout<4, 3, 2, 1, 0>);
+
+static_assert(expect_special_layout<layout_map<4, 3, 2, 1, 0>, 1, 1, 1, 1, 1>);
+static_assert(expect_special_layout<layout_map<-1, 3, 2, 1, 0>, 0, 1, 1, 1, 1>);
+static_assert(expect_special_layout<layout_map<3, -1, 2, 1, 0>, 1, 0, 1, 1, 1>);
+static_assert(expect_special_layout<layout_map<3, 2, -1, 1, 0>, 1, 1, 0, 1, 1>);
+static_assert(expect_special_layout<layout_map<3, 2, 1, -1, 0>, 1, 1, 1, 0, 1>);
+static_assert(expect_special_layout<layout_map<3, 2, 1, 0, -1>, 1, 1, 1, 1, 0>);
+
+static_assert(expect_special_layout<layout_map<-1, -1, 2, 1, 0>, 0, 0, 1, 1, 1>);
+static_assert(expect_special_layout<layout_map<2, -1, -1, 1, 0>, 1, 0, 0, 1, 1>);
+static_assert(expect_special_layout<layout_map<2, 1, -1, -1, 0>, 1, 1, 0, 0, 1>);
+static_assert(expect_special_layout<layout_map<2, 1, 0, -1, -1>, 1, 1, 1, 0, 0>);
+
+static_assert(expect_special_layout<layout_map<-1, 2, -1, 1, 0>, 0, 1, 0, 1, 1>);
+static_assert(expect_special_layout<layout_map<2, -1, 1, -1, 0>, 1, 0, 1, 0, 1>);
+static_assert(expect_special_layout<layout_map<2, 1, -1, 0, -1>, 1, 1, 0, 1, 0>);
+
+static_assert(expect_special_layout<layout_map<-1, 2, 1, -1, 0>, 0, 1, 1, 0, 1>);
+static_assert(expect_special_layout<layout_map<2, -1, 1, 0, -1>, 1, 0, 1, 1, 0>);
+
+static_assert(expect_special_layout<layout_map<-1, 2, 1, 0, -1>, 0, 1, 1, 1, 0>);
+
+static_assert(expect_special_layout<layout_map<-1, -1, -1, 1, 0>, 0, 0, 0, 1, 1>);
+static_assert(expect_special_layout<layout_map<1, -1, -1, -1, 0>, 1, 0, 0, 0, 1>);
+static_assert(expect_special_layout<layout_map<1, 0, -1, -1, -1>, 1, 1, 0, 0, 0>);
+static_assert(expect_special_layout<layout_map<-1, 1, 0, -1, -1>, 0, 1, 1, 0, 0>);
+static_assert(expect_special_layout<layout_map<-1, -1, 1, 0, -1>, 0, 0, 1, 1, 0>);
+
+static_assert(expect_special_layout<layout_map<0, -1, -1, -1, -1>, 1, 0, 0, 0, 0>);
+static_assert(expect_special_layout<layout_map<-1, 0, -1, -1, -1>, 0, 1, 0, 0, 0>);
+static_assert(expect_special_layout<layout_map<-1, -1, 0, -1, -1>, 0, 0, 1, 0, 0>);
+static_assert(expect_special_layout<layout_map<-1, -1, -1, 0, -1>, 0, 0, 0, 1, 0>);
+static_assert(expect_special_layout<layout_map<-1, -1, -1, -1, 0>, 0, 0, 0, 0, 1>);
 
 #endif
diff --git a/tests/unit_tests/storage/test_storage_sid.cpp b/tests/unit_tests/storage/test_storage_sid.cpp
index 4d124bfc3a..e0d2430d44 100644
--- a/tests/unit_tests/storage/test_storage_sid.cpp
+++ b/tests/unit_tests/storage/test_storage_sid.cpp
@@ -36,18 +36,18 @@ namespace gridtools {
             auto testee = builder.dimensions(10, 20, 30, 40)();
             using testee_t = decltype(testee);
 
-            static_assert(sid::concept_impl_::is_sid<testee_t>(), "");
-            static_assert(std::is_same<sid::ptr_type<testee_t>, double *>(), "");
-            static_assert(std::is_same<sid::ptr_diff_type<testee_t>, int_t>(), "");
-            static_assert(std::is_same<sid::strides_kind<testee_t>, typename testee_t::element_type::kind_t>(), "");
+            static_assert(sid::concept_impl_::is_sid<testee_t>());
+            static_assert(std::is_same_v<sid::ptr_type<testee_t>, double *>);
+            static_assert(std::is_same_v<sid::ptr_diff_type<testee_t>, int_t>);
+            static_assert(std::is_same_v<sid::strides_kind<testee_t>, typename testee_t::element_type::kind_t>);
 
             using strides_t = sid::strides_type<testee_t>;
 
-            static_assert(tu::size<strides_t>() == 4, "");
-            static_assert(std::is_same<tu::element<0, strides_t>, int_t>(), "");
-            static_assert(std::is_same<tu::element<1, strides_t>, integral_constant<int_t, 0>>(), "");
-            static_assert(std::is_same<tu::element<2, strides_t>, integral_constant<int_t, 1>>(), "");
-            static_assert(std::is_same<tu::element<3, strides_t>, int_t>(), "");
+            static_assert(tu::size<strides_t>() == 4);
+            static_assert(std::is_same_v<tu::element<0, strides_t>, int_t>);
+            static_assert(std::is_same_v<tu::element<1, strides_t>, integral_constant<int_t, 0>>);
+            static_assert(std::is_same_v<tu::element<2, strides_t>, integral_constant<int_t, 1>>);
+            static_assert(std::is_same_v<tu::element<3, strides_t>, int_t>);
 
             EXPECT_EQ(testee->get_target_ptr(), sid::get_origin(testee)());
 
@@ -87,10 +87,10 @@ namespace gridtools {
             auto testee = storage::builder<storage_traits_t>.type<double>().layout<-1>().dimensions(10)();
             using testee_t = decltype(testee);
 
-            static_assert(sid::concept_impl_::is_sid<testee_t>(), "");
+            static_assert(sid::concept_impl_::is_sid<testee_t>());
 
             using diff_t = sid::ptr_diff_type<testee_t>;
-            static_assert(std::is_empty<diff_t>(), "");
+            static_assert(std::is_empty_v<diff_t>);
 
             auto ptr = sid::get_origin(testee)();
 
@@ -99,28 +99,28 @@ namespace gridtools {
             using lower_bounds_t = sid::lower_bounds_type<testee_t>;
             using upper_bounds_t = sid::upper_bounds_type<testee_t>;
 
-            static_assert(tuple_util::size<lower_bounds_t>() == 0, "");
-            static_assert(tuple_util::size<upper_bounds_t>() == 0, "");
+            static_assert(tuple_util::size<lower_bounds_t>() == 0);
+            static_assert(tuple_util::size<upper_bounds_t>() == 0);
         }
 
         TEST(storage_sid, compile_time_lengths) {
             auto testee = storage::builder<storage_traits_t>.type<int>().layout<0, 1>().dimensions(10_c, 10_c)();
             using testee_t = decltype(testee);
 
-            static_assert(sid::concept_impl_::is_sid<testee_t>(), "");
+            static_assert(sid::is_sid<testee_t>());
 
             using strides_t = sid::strides_type<testee_t>;
             using bounds_t = sid::upper_bounds_type<testee_t>;
 
-            static_assert(tuple_util::is_empty_or_tuple_of_empties<strides_t>(), "");
-            static_assert(tuple_util::is_empty_or_tuple_of_empties<bounds_t>(), "");
+            static_assert(tuple_util::is_empty_or_tuple_of_empties<strides_t>());
+            static_assert(tuple_util::is_empty_or_tuple_of_empties<bounds_t>());
 
-            static_assert(tu::size<bounds_t>() == 2, "");
-            static_assert(tu::element<1, bounds_t>::value == 10, "");
-            static_assert(tu::element<0, bounds_t>::value == 10, "");
+            static_assert(tu::size<bounds_t>() == 2);
+            static_assert(tu::element<1, bounds_t>::value == 10);
+            static_assert(tu::element<0, bounds_t>::value == 10);
 
             auto expected_strides = testee->strides();
-            static_assert(tu::size<strides_t>() == 2, "");
+            static_assert(tu::size<strides_t>() == 2);
             EXPECT_EQ(expected_strides[0], (tu::element<0, strides_t>::value));
             EXPECT_EQ(expected_strides[1], (tu::element<1, strides_t>::value));
         }
diff --git a/tests/unit_tests/test_meta.cpp b/tests/unit_tests/test_meta.cpp
index 4f99d72775..5d24d7747c 100644
--- a/tests/unit_tests/test_meta.cpp
+++ b/tests/unit_tests/test_meta.cpp
@@ -24,135 +24,128 @@ namespace gridtools {
         struct h;
 
         // is_list
-        static_assert(!is_list<int>{}, "");
-        static_assert(is_list<list<int, void>>{}, "");
-        static_assert(is_list<f<void, int>>{}, "");
-        static_assert(is_list<std::pair<int, double>>{}, "");
-        static_assert(is_list<std::tuple<int, double>>{}, "");
+        static_assert(!is_list<int>{});
+        static_assert(is_list<list<int, void>>{});
+        static_assert(is_list<f<void, int>>{});
+        static_assert(is_list<std::pair<int, double>>{});
+        static_assert(is_list<std::tuple<int, double>>{});
 
         // has_type
-        static_assert(!has_type<int>{}, "");
-        static_assert(!has_type<g<>>{}, "");
-        static_assert(has_type<lazy::id<void>>{}, "");
-        static_assert(has_type<std::is_void<int>>{}, "");
+        static_assert(!has_type<int>{});
+        static_assert(!has_type<g<>>{});
+        static_assert(has_type<lazy::id<void>>{});
+        static_assert(has_type<std::is_void<int>>{});
 
         // length
-        static_assert(length<list<>>::value == 0, "");
-        static_assert(length<std::tuple<int>>::value == 1, "");
-        static_assert(length<std::pair<int, double>>::value == 2, "");
-        static_assert(length<f<int, int, double>>::value == 3, "");
+        static_assert(length<list<>>::value == 0);
+        static_assert(length<std::tuple<int>>::value == 1);
+        static_assert(length<std::pair<int, double>>::value == 2);
+        static_assert(length<f<int, int, double>>::value == 3);
 
         // ctor
-        static_assert(std::is_same<ctor<f<double>>::apply<int, void>, f<int, void>>{}, "");
+        static_assert(std::is_same_v<ctor<f<double>>::apply<int, void>, f<int, void>>);
 
         // rename
-        static_assert(std::is_same<rename<f, g<int, double>>, f<int, double>>{}, "");
+        static_assert(std::is_same_v<rename<f, g<int, double>>, f<int, double>>);
 
         // transform
-        static_assert(std::is_same<transform<f, g<>>, g<>>{}, "");
-        static_assert(std::is_same<transform<f, g<int, void>>, g<f<int>, f<void>>>{}, "");
-        static_assert(std::is_same<transform<f, g<int, void>, g<int *, void *>, g<int **, void **>>,
-                          g<f<int, int *, int **>, f<void, void *, void **>>>{},
-            "");
+        static_assert(std::is_same_v<transform<f, g<>>, g<>>);
+        static_assert(std::is_same_v<transform<f, g<int, void>>, g<f<int>, f<void>>>);
+        static_assert(std::is_same_v<transform<f, g<int, void>, g<int *, void *>, g<int **, void **>>,
+            g<f<int, int *, int **>, f<void, void *, void **>>>);
 
         // st_contains
-        static_assert(st_contains<g<int, bool>, int>{}, "");
-        static_assert(!st_contains<g<int, bool>, void>{}, "");
+        static_assert(st_contains<g<int, bool>, int>{});
+        static_assert(!st_contains<g<int, bool>, void>{});
 
         // mp_find
         using map = f<g<int, void *>, g<void, double *>, g<float, double *>>;
-        static_assert(std::is_same<mp_find<map, int>, g<int, void *>>{}, "");
-        static_assert(std::is_same<mp_find<map, double>, void>{}, "");
+        static_assert(std::is_same_v<mp_find<map, int>, g<int, void *>>);
+        static_assert(std::is_same_v<mp_find<map, double>, void>);
 
         // repeat
-        static_assert(std::is_same<repeat_c<0, f<int>>, f<>>{}, "");
-        static_assert(std::is_same<repeat_c<3, f<int>>, f<int, int, int>>{}, "");
+        static_assert(std::is_same_v<repeat_c<0, f<int>>, f<>>);
+        static_assert(std::is_same_v<repeat_c<3, f<int>>, f<int, int, int>>);
 
         // drop_front
-        static_assert(std::is_same<drop_front_c<0, f<int, double>>, f<int, double>>{}, "");
-        static_assert(std::is_same<drop_front_c<1, f<int, double>>, f<double>>{}, "");
-        static_assert(std::is_same<drop_front_c<2, f<int, double>>, f<>>{}, "");
+        static_assert(std::is_same_v<drop_front_c<0, f<int, double>>, f<int, double>>);
+        static_assert(std::is_same_v<drop_front_c<1, f<int, double>>, f<double>>);
+        static_assert(std::is_same_v<drop_front_c<2, f<int, double>>, f<>>);
 
         // at
-        static_assert(std::is_same<at_c<f<int, double>, 0>, int>{}, "");
-        static_assert(std::is_same<at_c<f<int, double>, 1>, double>{}, "");
-        static_assert(std::is_same<last<f<int, double>>, double>{}, "");
+        static_assert(std::is_same_v<at_c<f<int, double>, 0>, int>);
+        static_assert(std::is_same_v<at_c<f<int, double>, 1>, double>);
+        static_assert(std::is_same_v<last<f<int, double>>, double>);
 
         // conjunction
-        static_assert(conjunction_fast<>{}, "");
-        static_assert(conjunction_fast<std::true_type, std::true_type>{}, "");
-        static_assert(!conjunction_fast<std::true_type, std::false_type>{}, "");
-        static_assert(!conjunction_fast<std::false_type, std::true_type>{}, "");
-        static_assert(!conjunction_fast<std::false_type, std::false_type>{}, "");
+        static_assert(conjunction_fast<>{});
+        static_assert(conjunction_fast<std::true_type, std::true_type>{});
+        static_assert(!conjunction_fast<std::true_type, std::false_type>{});
+        static_assert(!conjunction_fast<std::false_type, std::true_type>{});
+        static_assert(!conjunction_fast<std::false_type, std::false_type>{});
 
         // disjunction
-        static_assert(!disjunction_fast<>{}, "");
-        static_assert(disjunction_fast<std::true_type, std::true_type>{}, "");
-        static_assert(disjunction_fast<std::true_type, std::false_type>{}, "");
-        static_assert(disjunction_fast<std::false_type, std::true_type>{}, "");
-        static_assert(!disjunction_fast<std::false_type, std::false_type>{}, "");
+        static_assert(!disjunction_fast<>{});
+        static_assert(disjunction_fast<std::true_type, std::true_type>{});
+        static_assert(disjunction_fast<std::true_type, std::false_type>{});
+        static_assert(disjunction_fast<std::false_type, std::true_type>{});
+        static_assert(!disjunction_fast<std::false_type, std::false_type>{});
 
         // st_position
-        static_assert(st_position<f<int, double>, int>{} == 0, "");
-        static_assert(st_position<f<double, int>, int>{} == 1, "");
-        static_assert(st_position<f<double, int>, void>{} == 2, "");
+        static_assert(st_position<f<int, double>, int>{} == 0);
+        static_assert(st_position<f<double, int>, int>{} == 1);
+        static_assert(st_position<f<double, int>, void>{} == 2);
 
         // combine
-        static_assert(std::is_same<combine<f, g<int>>, int>{}, "");
-        static_assert(std::is_same<combine<f, repeat_c<8, g<int>>>,
-                          f<f<f<int, int>, f<int, int>>, f<f<int, int>, f<int, int>>>>{},
-            "");
-        static_assert(std::is_same<combine<f, g<int, int, int>>, f<int, f<int, int>>>{}, "");
-        static_assert(std::is_same<combine<f, repeat_c<4, g<int>>>, f<f<int, int>, f<int, int>>>{}, "");
+        static_assert(std::is_same_v<combine<f, g<int>>, int>);
+        static_assert(std::is_same_v<combine<f, repeat_c<8, g<int>>>,
+            f<f<f<int, int>, f<int, int>>, f<f<int, int>, f<int, int>>>>);
+        static_assert(std::is_same_v<combine<f, g<int, int, int>>, f<int, f<int, int>>>);
+        static_assert(std::is_same_v<combine<f, repeat_c<4, g<int>>>, f<f<int, int>, f<int, int>>>);
 
         // concat
-        static_assert(std::is_same<concat<g<int>>, g<int>>{}, "");
-        static_assert(std::is_same<concat<g<int>, f<void>>, g<int, void>>{}, "");
-        static_assert(
-            std::is_same<concat<g<int>, g<void, double>, g<void, int>>, g<int, void, double, void, int>>{}, "");
+        static_assert(std::is_same_v<concat<g<int>>, g<int>>);
+        static_assert(std::is_same_v<concat<g<int>, f<void>>, g<int, void>>);
+        static_assert(std::is_same_v<concat<g<int>, g<void, double>, g<void, int>>, g<int, void, double, void, int>>);
 
         // flatten
-        static_assert(std::is_same<flatten<f<g<int>>>, g<int>>{}, "");
-        static_assert(std::is_same<flatten<f<g<int>, f<bool>>>, g<int, bool>>{}, "");
+        static_assert(std::is_same_v<flatten<f<g<int>>>, g<int>>);
+        static_assert(std::is_same_v<flatten<f<g<int>, f<bool>>>, g<int, bool>>);
 
         // filter
-        static_assert(std::is_same<filter<std::is_pointer, f<>>, f<>>{}, "");
-        static_assert(
-            std::is_same<filter<std::is_pointer, f<void, int *, double, double **>>, f<int *, double **>>{}, "");
+        static_assert(std::is_same_v<filter<std::is_pointer, f<>>, f<>>);
+        static_assert(std::is_same_v<filter<std::is_pointer, f<void, int *, double, double **>>, f<int *, double **>>);
 
         // all_of
-        static_assert(all_of<is_list, f<f<>, f<int>>>{}, "");
+        static_assert(all_of<is_list, f<f<>, f<int>>>{});
 
         // dedup
-        static_assert(std::is_same<dedup<f<>>, f<>>{}, "");
-        static_assert(std::is_same<dedup<f<int>>, f<int>>{}, "");
-        static_assert(std::is_same<dedup<f<int, void>>, f<int, void>>{}, "");
-        static_assert(std::is_same<dedup<f<int, void, void, void, int, void>>, f<int, void>>{}, "");
+        static_assert(std::is_same_v<dedup<f<>>, f<>>);
+        static_assert(std::is_same_v<dedup<f<int>>, f<int>>);
+        static_assert(std::is_same_v<dedup<f<int, void>>, f<int, void>>);
+        static_assert(std::is_same_v<dedup<f<int, void, void, void, int, void>>, f<int, void>>);
 
         // zip
-        static_assert(std::is_same<zip<f<int>, f<void>>, f<list<int, void>>>{}, "");
-        static_assert(std::is_same<zip<f<int, int *, int **>, f<void, void *, void **>, f<char, char *, char **>>,
-                          f<list<int, void, char>, list<int *, void *, char *>, list<int **, void **, char **>>>{},
-            "");
+        static_assert(std::is_same_v<zip<f<int>, f<void>>, f<list<int, void>>>);
+        static_assert(std::is_same_v<zip<f<int, int *, int **>, f<void, void *, void **>, f<char, char *, char **>>,
+            f<list<int, void, char>, list<int *, void *, char *>, list<int **, void **, char **>>>);
 
         // bind
-        static_assert(std::is_same<bind<f, _2, void, _1>::apply<int, double>, f<double, void, int>>{}, "");
+        static_assert(std::is_same_v<bind<f, _2, void, _1>::apply<int, double>, f<double, void, int>>);
 
         // is_instantiation_of
-        static_assert(is_instantiation_of<f, f<>>{}, "");
-        static_assert(is_instantiation_of<f, f<int, void>>{}, "");
-        static_assert(!is_instantiation_of<f, g<>>{}, "");
-        static_assert(!is_instantiation_of<f, int>{}, "");
-        static_assert(is_instantiation_of<f>::apply<f<int, void>>{}, "");
+        static_assert(is_instantiation_of<f, f<>>{});
+        static_assert(is_instantiation_of<f, f<int, void>>{});
+        static_assert(!is_instantiation_of<f, g<>>{});
+        static_assert(!is_instantiation_of<f, int>{});
+        static_assert(is_instantiation_of<f>::apply<f<int, void>>{});
 
-        static_assert(std::is_same<replace<f<int, double, int, double>, double, void>, f<int, void, int, void>>{}, "");
+        static_assert(std::is_same_v<replace<f<int, double, int, double>, double, void>, f<int, void, int, void>>);
 
-        static_assert(std::is_same<mp_replace<f<g<int, int *>, g<double, double *>>, int, void>,
-                          f<g<int, void>, g<double, double *>>>{},
-            "");
+        static_assert(std::is_same_v<mp_replace<f<g<int, int *>, g<double, double *>>, int, void>,
+            f<g<int, void>, g<double, double *>>>);
 
-        static_assert(
-            std::is_same<replace_at_c<f<int, double, int, double>, 1, void>, f<int, void, int, double>>{}, "");
+        static_assert(std::is_same_v<replace_at_c<f<int, double, int, double>, 1, void>, f<int, void, int, double>>);
 
         namespace nvcc_sizeof_workaround {
             template <class...>
@@ -170,121 +163,108 @@ namespace gridtools {
             using e = typename d<a<Ts>...>::c;
         } // namespace nvcc_sizeof_workaround
 
-        static_assert(is_set<f<>>{}, "");
-        static_assert(is_set<f<int>>{}, "");
-        static_assert(is_set<f<void>>{}, "");
-        static_assert(is_set<f<int, void>>{}, "");
-        static_assert(!is_set<int>{}, "");
-        static_assert(!is_set<f<int, void, int>>{}, "");
+        static_assert(is_set<f<>>{});
+        static_assert(is_set<f<int>>{});
+        static_assert(is_set<f<void>>{});
+        static_assert(is_set<f<int, void>>{});
+        static_assert(!is_set<int>{});
+        static_assert(!is_set<f<int, void, int>>{});
 
-        static_assert(is_set_fast<f<>>{}, "");
-        static_assert(is_set_fast<f<int>>{}, "");
-        static_assert(is_set_fast<f<void>>{}, "");
-        static_assert(is_set_fast<f<int, void>>{}, "");
-        static_assert(!is_set_fast<int>{}, "");
-        //        static_assert(!is_set_fast< f< int, void, int > >{}, "");
+        static_assert(is_set_fast<f<>>{});
+        static_assert(is_set_fast<f<int>>{});
+        static_assert(is_set_fast<f<void>>{});
+        static_assert(is_set_fast<f<int, void>>{});
+        static_assert(!is_set_fast<int>{});
+        //        static_assert(!is_set_fast< f< int, void, int > >{});
 
         // rfold
-        static_assert(std::is_same<foldl<f, int, g<>>, int>{}, "");
-        static_assert(std::is_same<foldl<f, int, g<int>>, f<int, int>>{}, "");
-        static_assert(std::is_same<foldl<f, int, g<int, int>>, f<f<int, int>, int>>{}, "");
-        static_assert(std::is_same<foldl<f, int, g<int, int>>, f<f<int, int>, int>>{}, "");
-        static_assert(std::is_same<foldl<f, int, g<int, int, int>>, f<f<f<int, int>, int>, int>>{}, "");
-        static_assert(std::is_same<foldl<f, int, g<int, int, int, int>>, f<f<f<f<int, int>, int>, int>, int>>{}, "");
+        static_assert(std::is_same_v<foldl<f, int, g<>>, int>);
+        static_assert(std::is_same_v<foldl<f, int, g<int>>, f<int, int>>);
+        static_assert(std::is_same_v<foldl<f, int, g<int, int>>, f<f<int, int>, int>>);
+        static_assert(std::is_same_v<foldl<f, int, g<int, int>>, f<f<int, int>, int>>);
+        static_assert(std::is_same_v<foldl<f, int, g<int, int, int>>, f<f<f<int, int>, int>, int>>);
+        static_assert(std::is_same_v<foldl<f, int, g<int, int, int, int>>, f<f<f<f<int, int>, int>, int>, int>>);
         static_assert(
-            std::is_same<foldl<f, int, g<int, int, int, int, int>>, f<f<f<f<f<int, int>, int>, int>, int>, int>>{}, "");
-        static_assert(std::is_same<foldl<f, int, g<int, int, int, int, int, int>>,
-                          f<f<f<f<f<f<int, int>, int>, int>, int>, int>, int>>{},
-            "");
+            std::is_same_v<foldl<f, int, g<int, int, int, int, int>>, f<f<f<f<f<int, int>, int>, int>, int>, int>>);
+        static_assert(std::is_same_v<foldl<f, int, g<int, int, int, int, int, int>>,
+            f<f<f<f<f<f<int, int>, int>, int>, int>, int>, int>>);
 
         // foldr
-        static_assert(std::is_same<foldr<f, int, g<>>, int>{}, "");
-        static_assert(std::is_same<foldr<f, int, g<int>>, f<int, int>>{}, "");
-        static_assert(std::is_same<foldr<f, int, g<int, int>>, f<f<int, int>, int>>{}, "");
-        static_assert(std::is_same<foldr<f, int, g<int, int, int>>, f<f<f<int, int>, int>, int>>{}, "");
-        static_assert(std::is_same<foldr<f, int, g<int, int, int, int>>, f<f<f<f<int, int>, int>, int>, int>>{}, "");
-        static_assert(
-            std::is_same<foldr<f, int, g<int, int, int, int, int>>, f<f<f<f<f<int, int>, int>, int>, int>, int>>{}, "");
-        static_assert(std::is_same<foldr<f, int, g<int, int, int, int, int, int>>,
-                          f<f<f<f<f<f<int, int>, int>, int>, int>, int>, int>>{},
-            "");
-
-        static_assert(std::is_same<cartesian_product<>, list<list<>>>{}, "");
-        static_assert(std::is_same<cartesian_product<f<>>, list<>>{}, "");
-        static_assert(std::is_same<cartesian_product<f<int>>, list<list<int>>>{}, "");
-        static_assert(std::is_same<cartesian_product<f<int, double>>, list<list<int>, list<double>>>{}, "");
-        static_assert(
-            std::is_same<cartesian_product<f<int, double>, g<void>>, list<list<int, void>, list<double, void>>>{}, "");
-        static_assert(std::is_same<cartesian_product<f<int, double>, g<int *, double *>>,
-                          list<list<int, int *>, list<int, double *>, list<double, int *>, list<double, double *>>>{},
-            "");
-        static_assert(std::is_same<cartesian_product<f<int, double>, g<>, f<void>>, list<>>{}, "");
-        static_assert(std::is_same<cartesian_product<f<>, g<int, double>>, list<>>{}, "");
-        static_assert(
-            std::is_same<cartesian_product<f<int>, g<double>, list<void>>, list<list<int, double, void>>>{}, "");
-
-        static_assert(std::is_same<reverse<f<int, int *, int **, int ***, int ****, int *****, int ******>>,
-                          f<int ******, int *****, int ****, int ***, int **, int *, int>>{},
-            "");
-
-        static_assert(find<f<>, int>::type::value == 0, "");
-        static_assert(find<f<void>, int>::type::value == 1, "");
-        static_assert(find<f<double, int, int, double, int>, int>::type::value == 1, "");
-        static_assert(find<f<double, int, int, double, int>, void>::type::value == 5, "");
-
-        static_assert(std::is_same<mp_insert<f<>, g<int, int *>>, f<g<int, int *>>>{}, "");
+        static_assert(std::is_same_v<foldr<f, int, g<>>, int>);
+        static_assert(std::is_same_v<foldr<f, int, g<int>>, f<int, int>>);
+        static_assert(std::is_same_v<foldr<f, int, g<int, int>>, f<f<int, int>, int>>);
+        static_assert(std::is_same_v<foldr<f, int, g<int, int, int>>, f<f<f<int, int>, int>, int>>);
+        static_assert(std::is_same_v<foldr<f, int, g<int, int, int, int>>, f<f<f<f<int, int>, int>, int>, int>>);
         static_assert(
-            std::is_same<mp_insert<f<g<void, void *>>, g<int, int *>>, f<g<void, void *>, g<int, int *>>>{}, "");
-        static_assert(std::is_same<mp_insert<f<g<int, int *>>, g<int, int **>>, f<g<int, int *, int **>>>{}, "");
-
-        static_assert(std::is_same<mp_remove<f<g<int, int *>>, void>, f<g<int, int *>>>{}, "");
-        static_assert(std::is_same<mp_remove<f<g<int, int *>>, int>, f<>>{}, "");
-        static_assert(std::is_same<mp_remove<f<g<int, int *>, g<void, void *>>, int>, f<g<void, void *>>>{}, "");
-
-        static_assert(std::is_same<mp_inverse<f<>>, f<>>{}, "");
+            std::is_same_v<foldr<f, int, g<int, int, int, int, int>>, f<f<f<f<f<int, int>, int>, int>, int>, int>>);
+        static_assert(std::is_same_v<foldr<f, int, g<int, int, int, int, int, int>>,
+            f<f<f<f<f<f<int, int>, int>, int>, int>, int>, int>>);
+
+        static_assert(std::is_same_v<cartesian_product<>, list<list<>>>);
+        static_assert(std::is_same_v<cartesian_product<f<>>, list<>>);
+        static_assert(std::is_same_v<cartesian_product<f<int>>, list<list<int>>>);
+        static_assert(std::is_same_v<cartesian_product<f<int, double>>, list<list<int>, list<double>>>);
         static_assert(
-            std::is_same<mp_inverse<f<g<int, int *>, g<void, void *>>>, f<g<int *, int>, g<void *, void>>>{}, "");
-        static_assert(std::is_same<mp_inverse<f<g<int, int *, int **>, g<void, void *>>>,
-                          f<g<int *, int>, g<int **, int>, g<void *, void>>>{},
-            "");
-        static_assert(std::is_same<mp_inverse<f<g<int *, int>, g<int **, int>, g<void *, void>>>,
-                          f<g<int, int *, int **>, g<void, void *>>>{},
-            "");
+            std::is_same_v<cartesian_product<f<int, double>, g<void>>, list<list<int, void>, list<double, void>>>);
+        static_assert(std::is_same_v<cartesian_product<f<int, double>, g<int *, double *>>,
+            list<list<int, int *>, list<int, double *>, list<double, int *>, list<double, double *>>>);
+        static_assert(std::is_same_v<cartesian_product<f<int, double>, g<>, f<void>>, list<>>);
+        static_assert(std::is_same_v<cartesian_product<f<>, g<int, double>>, list<>>);
+        static_assert(std::is_same_v<cartesian_product<f<int>, g<double>, list<void>>, list<list<int, double, void>>>);
+
+        static_assert(std::is_same_v<reverse<f<int, int *, int **, int ***, int ****, int *****, int ******>>,
+            f<int ******, int *****, int ****, int ***, int **, int *, int>>);
+
+        static_assert(find<f<>, int>::type::value == 0);
+        static_assert(find<f<void>, int>::type::value == 1);
+        static_assert(find<f<double, int, int, double, int>, int>::type::value == 1);
+        static_assert(find<f<double, int, int, double, int>, void>::type::value == 5);
+
+        static_assert(std::is_same_v<mp_insert<f<>, g<int, int *>>, f<g<int, int *>>>);
+        static_assert(std::is_same_v<mp_insert<f<g<void, void *>>, g<int, int *>>, f<g<void, void *>, g<int, int *>>>);
+        static_assert(std::is_same_v<mp_insert<f<g<int, int *>>, g<int, int **>>, f<g<int, int *, int **>>>);
+
+        static_assert(std::is_same_v<mp_remove<f<g<int, int *>>, void>, f<g<int, int *>>>);
+        static_assert(std::is_same_v<mp_remove<f<g<int, int *>>, int>, f<>>);
+        static_assert(std::is_same_v<mp_remove<f<g<int, int *>, g<void, void *>>, int>, f<g<void, void *>>>);
+
+        static_assert(std::is_same_v<mp_inverse<f<>>, f<>>);
+        static_assert(std::is_same_v<mp_inverse<f<g<int, int *>, g<void, void *>>>, f<g<int *, int>, g<void *, void>>>);
+        static_assert(std::is_same_v<mp_inverse<f<g<int, int *, int **>, g<void, void *>>>,
+            f<g<int *, int>, g<int **, int>, g<void *, void>>>);
+        static_assert(std::is_same_v<mp_inverse<f<g<int *, int>, g<int **, int>, g<void *, void>>>,
+            f<g<int, int *, int **>, g<void, void *>>>);
 
         // take
-        static_assert(std::is_same<take_c<2, f<int, double, void, void>>, f<int, double>>::value, "");
-        static_assert(std::is_same<take_c<20, repeat_c<100, g<int>>>, repeat_c<20, g<int>>>::value, "");
+        static_assert(std::is_same_v<take_c<2, f<int, double, void, void>>, f<int, double>>);
+        static_assert(std::is_same_v<take_c<20, repeat_c<100, g<int>>>, repeat_c<20, g<int>>>);
 
         // insert
-        static_assert(std::is_same<insert_c<3, f<void, void, void, void, void>, int, double>,
-                          f<void, void, void, int, double, void, void>>::value,
-            "");
+        static_assert(std::is_same_v<insert_c<3, f<void, void, void, void, void>, int, double>,
+            f<void, void, void, int, double, void, void>>);
 
         // group
-        static_assert(std::is_same<group<are_same, g, f<>>, f<>>::value, "");
-        static_assert(std::is_same<group<are_same, g, f<int>>, f<g<int>>>::value, "");
-        static_assert(std::is_same<group<are_same, g, f<int, int, int, double, void, void, int, int>>,
-                          f<g<int, int, int>, g<double>, g<void, void>, g<int, int>>>::value,
-            "");
+        static_assert(std::is_same_v<group<are_same, g, f<>>, f<>>);
+        static_assert(std::is_same_v<group<are_same, g, f<int>>, f<g<int>>>);
+        static_assert(std::is_same_v<group<are_same, g, f<int, int, int, double, void, void, int, int>>,
+            f<g<int, int, int>, g<double>, g<void, void>, g<int, int>>>);
 
         // trim
-        static_assert(std::is_same<trim<std::is_void, f<int, void, int>>, f<int, void, int>>::value, "");
-        static_assert(std::is_same<trim<std::is_void, f<>>, f<>>::value, "");
-        static_assert(std::is_same<trim<std::is_void, f<void, void>>, f<>>::value, "");
+        static_assert(std::is_same_v<trim<std::is_void, f<int, void, int>>, f<int, void, int>>);
+        static_assert(std::is_same_v<trim<std::is_void, f<>>, f<>>);
+        static_assert(std::is_same_v<trim<std::is_void, f<void, void>>, f<>>);
         static_assert(
-            std::is_same<trim<std::is_void, f<void, void, int, int, void, int, void>>, f<int, int, void, int>>::value,
-            "");
+            std::is_same_v<trim<std::is_void, f<void, void, int, int, void, int, void>>, f<int, int, void, int>>);
 
         // mp_make
-        static_assert(std::is_same<mp_make<h, f<>>, f<>>::value, "");
-        static_assert(std::is_same<mp_make<h, f<g<int, int *>>>, f<h<g<int, int *>>>>::value, "");
+        static_assert(std::is_same_v<mp_make<h, f<>>, f<>>);
+        static_assert(std::is_same_v<mp_make<h, f<g<int, int *>>>, f<h<g<int, int *>>>>);
+        static_assert(
+            std::is_same_v<mp_make<h, f<g<int, int *>, g<void, void *>>>, f<h<g<int, int *>>, h<g<void, void *>>>>);
         static_assert(
-            std::is_same<mp_make<h, f<g<int, int *>, g<void, void *>>>, f<h<g<int, int *>>, h<g<void, void *>>>>::value,
-            "");
+            std::is_same_v<mp_make<h, f<g<int, int *>, g<int, int **>>>, f<h<g<int, int *>, g<int, int **>>>>);
         static_assert(
-            std::is_same<mp_make<h, f<g<int, int *>, g<int, int **>>>, f<h<g<int, int *>, g<int, int **>>>>::value, "");
-        static_assert(std::is_same<mp_make<h, f<g<void, void *>, g<int, int *>, g<int, int **>, g<double, double **>>>,
-                          f<h<g<void, void *>>, h<g<int, int *>, g<int, int **>>, h<g<double, double **>>>>::value,
-            "");
+            std::is_same_v<mp_make<h, f<g<void, void *>, g<int, int *>, g<int, int **>, g<double, double **>>>,
+                f<h<g<void, void *>>, h<g<int, int *>, g<int, int **>>, h<g<double, double **>>>>);
     } // namespace meta
 } // namespace gridtools