diff --git a/CMakeLists.txt b/CMakeLists.txt
index f59f0a8c7..d969a486b 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -7,7 +7,7 @@
 # The full license is in the file LICENSE, distributed with this software. #
 ############################################################################
 
-cmake_minimum_required(VERSION 3.5)
+cmake_minimum_required(VERSION 3.29)
 project(xtensor CXX)
 
 set(XTENSOR_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/include)
@@ -29,7 +29,7 @@ message(STATUS "Building xtensor v${${PROJECT_NAME}_VERSION}")
 # Dependencies
 # ============
 
-set(xtl_REQUIRED_VERSION 0.7.5)
+set(xtl_REQUIRED_VERSION 0.8.0)
 if(TARGET xtl)
     set(xtl_VERSION ${XTL_VERSION_MAJOR}.${XTL_VERSION_MINOR}.${XTL_VERSION_PATCH})
     # Note: This is not SEMVER compatible comparison
@@ -194,7 +194,7 @@ target_include_directories(xtensor INTERFACE
     $<BUILD_INTERFACE:${XTENSOR_INCLUDE_DIR}>
     $<INSTALL_INTERFACE:include>)
 
-target_compile_features(xtensor INTERFACE cxx_std_14)
+target_compile_features(xtensor INTERFACE cxx_std_17)
 
 target_link_libraries(xtensor INTERFACE xtl)
 
@@ -205,8 +205,6 @@ OPTION(BUILD_TESTS "xtensor test suite" OFF)
 OPTION(BUILD_BENCHMARK "xtensor benchmark" OFF)
 OPTION(DOWNLOAD_GBENCHMARK "download google benchmark and build from source" ON)
 OPTION(DEFAULT_COLUMN_MAJOR "set default layout to column major" OFF)
-OPTION(DISABLE_VS2017 "disables the compilation of some test with Visual Studio 2017" OFF)
-OPTION(CPP17 "enables C++17" OFF)
 OPTION(CPP20 "enables C++20 (experimental)" OFF)
 OPTION(XTENSOR_DISABLE_EXCEPTIONS "Disable C++ exceptions" OFF)
 OPTION(DISABLE_MSVC_ITERATOR_CHECK "Disable the MVSC iterator check" ON)
diff --git a/environment-dev.yml b/environment-dev.yml
index f320d623f..a594f896d 100644
--- a/environment-dev.yml
+++ b/environment-dev.yml
@@ -3,7 +3,7 @@ channels:
 - conda-forge
 dependencies:
 - cmake
-- xtl=0.7.5
+- xtl=0.8.0
 - xsimd=13.2.0
 - nlohmann_json
 - doctest
diff --git a/include/xtensor/containers/xadapt.hpp b/include/xtensor/containers/xadapt.hpp
index 75cd7fc0d..725a75d42 100644
--- a/include/xtensor/containers/xadapt.hpp
+++ b/include/xtensor/containers/xadapt.hpp
@@ -52,13 +52,13 @@ namespace xt
         using default_allocator_for_ptr_t = typename default_allocator_for_ptr<P>::type;
 
         template <class T>
-        using not_an_array = xtl::negation<is_array<T>>;
+        using not_an_array = std::negation<is_array<T>>;
 
         template <class T>
-        using not_a_pointer = xtl::negation<std::is_pointer<T>>;
+        using not_a_pointer = std::negation<std::is_pointer<T>>;
 
         template <class T>
-        using not_a_layout = xtl::negation<std::is_same<layout_type, T>>;
+        using not_a_layout = std::negation<std::is_same<layout_type, T>>;
     }
 
 #ifndef IN_DOXYGEN
diff --git a/include/xtensor/containers/xscalar.hpp b/include/xtensor/containers/xscalar.hpp
index 497a2134d..bfeba09b7 100644
--- a/include/xtensor/containers/xscalar.hpp
+++ b/include/xtensor/containers/xscalar.hpp
@@ -322,13 +322,13 @@ namespace xt
         template <class... E>
         struct all_xscalar
         {
-            static constexpr bool value = xtl::conjunction<is_xscalar<std::decay_t<E>>...>::value;
+            static constexpr bool value = std::conjunction<is_xscalar<std::decay_t<E>>...>::value;
         };
     }
 
     // Note: MSVC bug workaround. Cannot just define
     // template <class... E>
-    // using all_xscalar = xtl::conjunction<is_xscalar<std::decay_t<E>>...>;
+    // using all_xscalar = std::conjunction<is_xscalar<std::decay_t<E>>...>;
 
     template <class... E>
     using all_xscalar = detail::all_xscalar<E...>;
diff --git a/include/xtensor/core/xassign.hpp b/include/xtensor/core/xassign.hpp
index ea8e1dbea..904113814 100644
--- a/include/xtensor/core/xassign.hpp
+++ b/include/xtensor/core/xassign.hpp
@@ -214,18 +214,15 @@ namespace xt
     template <class E1, class E2>
     inline void assign_xexpression(xexpression<E1>& e1, const xexpression<E2>& e2)
     {
-        xtl::mpl::static_if<has_assign_to<E1, E2>::value>(
-            [&](auto self)
-            {
-                self(e2).derived_cast().assign_to(e1);
-            },
-            /*else*/
-            [&](auto /*self*/)
-            {
-                using tag = xexpression_tag_t<E1, E2>;
-                xexpression_assigner<tag>::assign_xexpression(e1, e2);
-            }
-        );
+        if constexpr (has_assign_to<E1, E2>::value)
+        {
+            e2.derived_cast().assign_to(e1);
+        }
+        else
+        {
+            using tag = xexpression_tag_t<E1, E2>;
+            xexpression_assigner<tag>::assign_xexpression(e1, e2);
+        }
     }
 
     template <class E1, class E2>
@@ -320,7 +317,7 @@ namespace xt
         template <class F, class... CT>
         struct use_strided_loop<xfunction<F, CT...>>
         {
-            static constexpr bool value = xtl::conjunction<use_strided_loop<std::decay_t<CT>>...>::value;
+            static constexpr bool value = std::conjunction<use_strided_loop<std::decay_t<CT>>...>::value;
         };
 
         /**
@@ -585,31 +582,28 @@ namespace xt
     template <class E1, class F, class... CT>
     inline bool xexpression_assigner<Tag>::resize(E1& e1, const xfunction<F, CT...>& e2)
     {
-        return xtl::mpl::static_if<detail::is_fixed<typename xfunction<F, CT...>::shape_type>::value>(
-            [&](auto /*self*/)
-            {
-                /*
-                 * If the shape of the xfunction is statically known, we can compute the broadcast triviality
-                 * at compile time plus we can resize right away.
-                 */
-                // resize in case LHS is not a fixed size container. If it is, this is a NOP
-                e1.resize(typename xfunction<F, CT...>::shape_type{});
-                return detail::static_trivial_broadcast<
-                    detail::is_fixed<typename xfunction<F, CT...>::shape_type>::value,
-                    CT...>::value;
-            },
-            /* else */
-            [&](auto /*self*/)
-            {
-                using index_type = xindex_type_t<typename E1::shape_type>;
-                using size_type = typename E1::size_type;
-                size_type size = e2.dimension();
-                index_type shape = uninitialized_shape<index_type>(size);
-                bool trivial_broadcast = e2.broadcast_shape(shape, true);
-                e1.resize(std::move(shape));
-                return trivial_broadcast;
-            }
-        );
+        if constexpr (detail::is_fixed<typename xfunction<F, CT...>::shape_type>::value)
+        {
+            /*
+             * If the shape of the xfunction is statically known, we can compute the broadcast triviality
+             * at compile time plus we can resize right away.
+             */
+            // resize in case LHS is not a fixed size container. If it is, this is a NOP
+            e1.resize(typename xfunction<F, CT...>::shape_type{});
+            return detail::static_trivial_broadcast<
+                detail::is_fixed<typename xfunction<F, CT...>::shape_type>::value,
+                CT...>::value;
+        }
+        else
+        {
+            using index_type = xindex_type_t<typename E1::shape_type>;
+            using size_type = typename E1::size_type;
+            size_type size = e2.dimension();
+            index_type shape = uninitialized_shape<index_type>(size);
+            bool trivial_broadcast = e2.broadcast_shape(shape, true);
+            e1.resize(std::move(shape));
+            return trivial_broadcast;
+        }
     }
 
     /***********************************
diff --git a/include/xtensor/core/xexpression.hpp b/include/xtensor/core/xexpression.hpp
index b9174cb5f..f32879035 100644
--- a/include/xtensor/core/xexpression.hpp
+++ b/include/xtensor/core/xexpression.hpp
@@ -168,7 +168,7 @@ namespace xt
 
         template <template <class> class B, class E, template <class> class F>
         struct is_crtp_base_of_impl<B, F<E>>
-            : xtl::disjunction<std::is_base_of<B<E>, F<E>>, std::is_base_of<B<F<E>>, F<E>>>
+            : std::disjunction<std::is_base_of<B<E>, F<E>>, std::is_base_of<B<F<E>>, F<E>>>
         {
         };
     }
@@ -186,7 +186,7 @@ namespace xt
     using disable_xexpression = typename std::enable_if<!is_xexpression<E>::value, R>::type;
 
     template <class... E>
-    using has_xexpression = xtl::disjunction<is_xexpression<E>...>;
+    using has_xexpression = std::disjunction<is_xexpression<E>...>;
 
     template <class E>
     using is_xsharable_expression = is_crtp_base_of<xsharable_expression, E>;
@@ -405,7 +405,7 @@ namespace xt
 
     template <class... E>
     struct xoptional_comparable
-        : xtl::conjunction<xtl::disjunction<is_xtensor_expression<E>, is_xoptional_expression<E>>...>
+        : std::conjunction<std::disjunction<is_xtensor_expression<E>, is_xoptional_expression<E>>...>
     {
     };
 
diff --git a/include/xtensor/core/xfunction.hpp b/include/xtensor/core/xfunction.hpp
index 2d3b58244..65ee5050e 100644
--- a/include/xtensor/core/xfunction.hpp
+++ b/include/xtensor/core/xfunction.hpp
@@ -38,7 +38,7 @@ namespace xt
     {
 
         template <bool... B>
-        using conjunction_c = xtl::conjunction<std::integral_constant<bool, B>...>;
+        using conjunction_c = std::conjunction<std::integral_constant<bool, B>...>;
 
         /************************
          * xfunction_cache_impl *
@@ -155,7 +155,7 @@ namespace xt
     };
 
     template <class T, class F, class... CT>
-    struct has_simd_interface<xfunction<F, CT...>, T> : xtl::conjunction<
+    struct has_simd_interface<xfunction<F, CT...>, T> : std::conjunction<
                                                             has_simd_type<T>,
                                                             has_simd_apply<F, xt_simd::simd_type<T>>,
                                                             has_simd_interface<std::decay_t<CT>, T>...>
@@ -589,16 +589,13 @@ namespace xt
     template <class F, class... CT>
     inline auto xfunction<F, CT...>::shape() const -> const inner_shape_type&
     {
-        xtl::mpl::static_if<!detail::is_fixed<inner_shape_type>::value>(
-            [&](auto self)
+        if constexpr (!detail::is_fixed<inner_shape_type>::value)
+        {
+            if (!m_cache.is_initialized)
             {
-                if (!m_cache.is_initialized)
-                {
-                    self(this)->compute_cached_shape();
-                }
-            },
-            [](auto /*self*/) {}
-        );
+                compute_cached_shape();
+            }
+        }
         return m_cache.shape;
     }
 
diff --git a/include/xtensor/core/xiterable.hpp b/include/xtensor/core/xiterable.hpp
index 48ebc27cc..d0caf9d6f 100644
--- a/include/xtensor/core/xiterable.hpp
+++ b/include/xtensor/core/xiterable.hpp
@@ -948,17 +948,14 @@ namespace xt
     template <layout_type L>
     inline auto xcontiguous_iterable<D>::begin() noexcept -> select_iterator<L>
     {
-        return xtl::mpl::static_if<L == static_layout>(
-            [&](auto self)
-            {
-                return self(*this).derived_cast().linear_begin();
-            },
-            /*else*/
-            [&](auto self)
-            {
-                return self(*this).iterable_base::template begin<L>();
-            }
-        );
+        if constexpr (L == static_layout)
+        {
+            return derived_cast().linear_begin();
+        }
+        else
+        {
+            return iterable_base::template begin<L>();
+        }
     }
 
     /**
@@ -970,17 +967,14 @@ namespace xt
     template <layout_type L>
     inline auto xcontiguous_iterable<D>::end() noexcept -> select_iterator<L>
     {
-        return xtl::mpl::static_if<L == static_layout>(
-            [&](auto self)
-            {
-                return self(*this).derived_cast().linear_end();
-            },
-            /*else*/
-            [&](auto self)
-            {
-                return self(*this).iterable_base::template end<L>();
-            }
-        );
+        if constexpr (L == static_layout)
+        {
+            return derived_cast().linear_end();
+        }
+        else
+        {
+            return iterable_base::template end<L>();
+        }
     }
 
     /**
@@ -1014,17 +1008,14 @@ namespace xt
     template <layout_type L>
     inline auto xcontiguous_iterable<D>::cbegin() const noexcept -> select_const_iterator<L>
     {
-        return xtl::mpl::static_if<L == static_layout>(
-            [&](auto self)
-            {
-                return self(*this).derived_cast().linear_cbegin();
-            },
-            /*else*/
-            [&](auto self)
-            {
-                return self(*this).iterable_base::template cbegin<L>();
-            }
-        );
+        if constexpr (L == static_layout)
+        {
+            return derived_cast().linear_cbegin();
+        }
+        else
+        {
+            return iterable_base::template cbegin<L>();
+        }
     }
 
     /**
@@ -1036,17 +1027,14 @@ namespace xt
     template <layout_type L>
     inline auto xcontiguous_iterable<D>::cend() const noexcept -> select_const_iterator<L>
     {
-        return xtl::mpl::static_if<L == static_layout>(
-            [&](auto self)
-            {
-                return self(*this).derived_cast().linear_cend();
-            },
-            /*else*/
-            [&](auto self)
-            {
-                return self(*this).iterable_base::template cend<L>();
-            }
-        );
+        if constexpr (L == static_layout)
+        {
+            return derived_cast().linear_cend();
+        }
+        else
+        {
+            return iterable_base::template cend<L>();
+        }
     }
 
     //@}
@@ -1063,17 +1051,14 @@ namespace xt
     template <layout_type L>
     inline auto xcontiguous_iterable<D>::rbegin() noexcept -> select_reverse_iterator<L>
     {
-        return xtl::mpl::static_if<L == static_layout>(
-            [&](auto self)
-            {
-                return self(*this).derived_cast().linear_rbegin();
-            },
-            /*else*/
-            [&](auto self)
-            {
-                return self(*this).iterable_base::template rbegin<L>();
-            }
-        );
+        if constexpr (L == static_layout)
+        {
+            return derived_cast().linear_rbegin();
+        }
+        else
+        {
+            return iterable_base::template rbegin<L>();
+        }
     }
 
     /**
@@ -1085,17 +1070,14 @@ namespace xt
     template <layout_type L>
     inline auto xcontiguous_iterable<D>::rend() noexcept -> select_reverse_iterator<L>
     {
-        return xtl::mpl::static_if<L == static_layout>(
-            [&](auto self)
-            {
-                return self(*this).derived_cast().linear_rend();
-            },
-            /*else*/
-            [&](auto self)
-            {
-                return self(*this).iterable_base::template rend<L>();
-            }
-        );
+        if constexpr (L == static_layout)
+        {
+            return derived_cast().linear_rend();
+        }
+        else
+        {
+            return iterable_base::template rend<L>();
+        }
     }
 
     /**
@@ -1129,17 +1111,14 @@ namespace xt
     template <layout_type L>
     inline auto xcontiguous_iterable<D>::crbegin() const noexcept -> select_const_reverse_iterator<L>
     {
-        return xtl::mpl::static_if<L == static_layout>(
-            [&](auto self)
-            {
-                return self(*this).derived_cast().linear_crbegin();
-            },
-            /*else*/
-            [&](auto self)
-            {
-                return self(*this).iterable_base::template crbegin<L>();
-            }
-        );
+        if constexpr (L == static_layout)
+        {
+            return derived_cast().linear_crbegin();
+        }
+        else
+        {
+            return iterable_base::template crbegin<L>();
+        }
     }
 
     /**
@@ -1151,17 +1130,14 @@ namespace xt
     template <layout_type L>
     inline auto xcontiguous_iterable<D>::crend() const noexcept -> select_const_reverse_iterator<L>
     {
-        return xtl::mpl::static_if<L == static_layout>(
-            [&](auto self)
-            {
-                return self(*this).derived_cast().linear_crend();
-            },
-            /*else*/
-            [&](auto self)
-            {
-                return self(*this).iterable_base::template crend<L>();
-            }
-        );
+        if constexpr (L == static_layout)
+        {
+            return derived_cast().linear_crend();
+        }
+        else
+        {
+            return iterable_base::template crend<L>();
+        }
     }
 
     //@}
diff --git a/include/xtensor/core/xiterator.hpp b/include/xtensor/core/xiterator.hpp
index 8b5f4e616..ca3faef21 100644
--- a/include/xtensor/core/xiterator.hpp
+++ b/include/xtensor/core/xiterator.hpp
@@ -420,65 +420,53 @@ namespace xt
     template <class C>
     XTENSOR_CONSTEXPR_RETURN auto linear_begin(C& c) noexcept
     {
-        return xtl::mpl::static_if<detail::has_linear_iterator<C>::value>(
-            [&](auto self)
-            {
-                return self(c).linear_begin();
-            },
-            /*else*/
-            [&](auto self)
-            {
-                return self(c).begin();
-            }
-        );
+        if constexpr (detail::has_linear_iterator<C>::value)
+        {
+            return c.linear_begin();
+        }
+        else
+        {
+            return c.begin();
+        }
     }
 
     template <class C>
     XTENSOR_CONSTEXPR_RETURN auto linear_end(C& c) noexcept
     {
-        return xtl::mpl::static_if<detail::has_linear_iterator<C>::value>(
-            [&](auto self)
-            {
-                return self(c).linear_end();
-            },
-            /*else*/
-            [&](auto self)
-            {
-                return self(c).end();
-            }
-        );
+        if constexpr (detail::has_linear_iterator<C>::value)
+        {
+            return c.linear_end();
+        }
+        else
+        {
+            return c.end();
+        }
     }
 
     template <class C>
     XTENSOR_CONSTEXPR_RETURN auto linear_begin(const C& c) noexcept
     {
-        return xtl::mpl::static_if<detail::has_linear_iterator<C>::value>(
-            [&](auto self)
-            {
-                return self(c).linear_cbegin();
-            },
-            /*else*/
-            [&](auto self)
-            {
-                return self(c).cbegin();
-            }
-        );
+        if constexpr (detail::has_linear_iterator<C>::value)
+        {
+            return c.linear_cbegin();
+        }
+        else
+        {
+            return c.cbegin();
+        }
     }
 
     template <class C>
     XTENSOR_CONSTEXPR_RETURN auto linear_end(const C& c) noexcept
     {
-        return xtl::mpl::static_if<detail::has_linear_iterator<C>::value>(
-            [&](auto self)
-            {
-                return self(c).linear_cend();
-            },
-            /*else*/
-            [&](auto self)
-            {
-                return self(c).cend();
-            }
-        );
+        if constexpr (detail::has_linear_iterator<C>::value)
+        {
+            return c.linear_cend();
+        }
+        else
+        {
+            return c.cend();
+        }
     }
 
     /***************************
diff --git a/include/xtensor/core/xmath.hpp b/include/xtensor/core/xmath.hpp
index 24235031b..77f864929 100644
--- a/include/xtensor/core/xmath.hpp
+++ b/include/xtensor/core/xmath.hpp
@@ -370,7 +370,7 @@ namespace xt
         class E,                                                                                                     \
         class X,                                                                                                     \
         class EVS = DEFAULT_STRATEGY_REDUCERS,                                                                       \
-        XTL_REQUIRES(xtl::negation<is_reducer_options<X>>, xtl::negation<xtl::is_integral<std::decay_t<X>>>)>        \
+        XTL_REQUIRES(std::negation<is_reducer_options<X>>, std::negation<xtl::is_integral<std::decay_t<X>>>)>        \
     inline auto NAME(E&& e, X&& axes, EVS es = EVS())                                                                \
     {                                                                                                                \
         using init_value_type = std::conditional_t<std::is_same<T, void>::value, INIT_VALUE_TYPE, T>;                \
@@ -389,7 +389,7 @@ namespace xt
         class E,                                                                                                     \
         class X,                                                                                                     \
         class EVS = DEFAULT_STRATEGY_REDUCERS,                                                                       \
-        XTL_REQUIRES(xtl::negation<is_reducer_options<X>>, xtl::is_integral<std::decay_t<X>>)>                       \
+        XTL_REQUIRES(std::negation<is_reducer_options<X>>, xtl::is_integral<std::decay_t<X>>)>                       \
     inline auto NAME(E&& e, X axis, EVS es = EVS())                                                                  \
     {                                                                                                                \
         return NAME(std::forward<E>(e), {axis}, es);                                                                 \
@@ -1874,7 +1874,7 @@ namespace xt
             class X,
             class D,
             class EVS,
-            XTL_REQUIRES(xtl::negation<is_reducer_options<X>>, xtl::is_integral<D>)>
+            XTL_REQUIRES(std::negation<is_reducer_options<X>>, xtl::is_integral<D>)>
         inline auto mean(E&& e, X&& axes, const D& ddof, EVS es)
         {
             // sum cannot always be a double. It could be a complex number which cannot operate on
@@ -1928,7 +1928,7 @@ namespace xt
         class E,
         class X,
         class EVS = DEFAULT_STRATEGY_REDUCERS,
-        XTL_REQUIRES(xtl::negation<is_reducer_options<X>>)>
+        XTL_REQUIRES(std::negation<is_reducer_options<X>>)>
     inline auto mean(E&& e, X&& axes, EVS es = EVS())
     {
         return detail::mean<T>(std::forward<E>(e), std::forward<X>(axes), 0u, es);
@@ -1969,7 +1969,7 @@ namespace xt
         class W,
         class X,
         class EVS = DEFAULT_STRATEGY_REDUCERS,
-        XTL_REQUIRES(is_reducer_options<EVS>, xtl::negation<xtl::is_integral<X>>)>
+        XTL_REQUIRES(is_reducer_options<EVS>, std::negation<xtl::is_integral<X>>)>
     inline auto average(E&& e, W&& weights, X&& axes, EVS ev = EVS())
     {
         xindex_type_t<typename std::decay_t<E>::shape_type> broadcast_shape;
@@ -2113,7 +2113,7 @@ namespace xt
         class X,
         class D,
         class EVS = DEFAULT_STRATEGY_REDUCERS,
-        XTL_REQUIRES(xtl::negation<is_reducer_options<X>>, xtl::is_integral<D>)>
+        XTL_REQUIRES(std::negation<is_reducer_options<X>>, xtl::is_integral<D>)>
     inline auto variance(E&& e, X&& axes, const D& ddof, EVS es = EVS())
     {
         decltype(auto) sc = detail::shared_forward<E>(e);
@@ -2142,7 +2142,7 @@ namespace xt
         class E,
         class X,
         class EVS = DEFAULT_STRATEGY_REDUCERS,
-        XTL_REQUIRES(xtl::negation<is_reducer_options<X>>, xtl::negation<xtl::is_integral<std::decay_t<X>>>, is_reducer_options<EVS>)>
+        XTL_REQUIRES(std::negation<is_reducer_options<X>>, std::negation<xtl::is_integral<std::decay_t<X>>>, is_reducer_options<EVS>)>
     inline auto variance(E&& e, X&& axes, EVS es = EVS())
     {
         return variance<T>(std::forward<E>(e), std::forward<X>(axes), 0u, es);
@@ -2174,7 +2174,7 @@ namespace xt
         class E,
         class X,
         class EVS = DEFAULT_STRATEGY_REDUCERS,
-        XTL_REQUIRES(xtl::negation<is_reducer_options<X>>)>
+        XTL_REQUIRES(std::negation<is_reducer_options<X>>)>
     inline auto stddev(E&& e, X&& axes, EVS es = EVS())
     {
         return sqrt(variance<T>(std::forward<E>(e), std::forward<X>(axes), es));
@@ -2541,7 +2541,7 @@ namespace xt
         class E,
         class X,
         class EVS = DEFAULT_STRATEGY_REDUCERS,
-        XTL_REQUIRES(xtl::negation<is_reducer_options<X>>, xtl::negation<xtl::is_integral<X>>)>
+        XTL_REQUIRES(std::negation<is_reducer_options<X>>, std::negation<xtl::is_integral<X>>)>
     inline auto count_nonzero(E&& e, X&& axes, EVS es = EVS())
     {
         COUNT_NON_ZEROS_CONTENT;
@@ -2557,7 +2557,7 @@ namespace xt
         class E,
         class X,
         class EVS = DEFAULT_STRATEGY_REDUCERS,
-        XTL_REQUIRES(xtl::negation<is_reducer_options<X>>, xtl::is_integral<X>)>
+        XTL_REQUIRES(std::negation<is_reducer_options<X>>, xtl::is_integral<X>)>
     inline auto count_nonzero(E&& e, X axis, EVS es = EVS())
     {
         return count_nonzero(std::forward<E>(e), {axis}, es);
@@ -2587,7 +2587,7 @@ namespace xt
         class E,
         class X,
         class EVS = DEFAULT_STRATEGY_REDUCERS,
-        XTL_REQUIRES(xtl::negation<is_reducer_options<X>>, xtl::negation<xtl::is_integral<X>>)>
+        XTL_REQUIRES(std::negation<is_reducer_options<X>>, std::negation<xtl::is_integral<X>>)>
     inline auto count_nonnan(E&& e, X&& axes, EVS es = EVS())
     {
         return xt::count_nonzero(!xt::isnan(std::forward<E>(e)), std::forward<X>(axes), es);
@@ -2597,7 +2597,7 @@ namespace xt
         class E,
         class X,
         class EVS = DEFAULT_STRATEGY_REDUCERS,
-        XTL_REQUIRES(xtl::negation<is_reducer_options<X>>, xtl::is_integral<X>)>
+        XTL_REQUIRES(std::negation<is_reducer_options<X>>, xtl::is_integral<X>)>
     inline auto count_nonnan(E&& e, X&& axes, EVS es = EVS())
     {
         return xt::count_nonzero(!xt::isnan(std::forward<E>(e)), {axes}, es);
@@ -2742,7 +2742,7 @@ namespace xt
         class E,
         class X,
         class EVS = DEFAULT_STRATEGY_REDUCERS,
-        XTL_REQUIRES(xtl::negation<is_reducer_options<X>>)>
+        XTL_REQUIRES(std::negation<is_reducer_options<X>>)>
     inline auto nanmean(E&& e, X&& axes, EVS es = EVS())
     {
         decltype(auto) sc = detail::shared_forward<E>(e);
@@ -2819,7 +2819,7 @@ namespace xt
         class E,
         class X,
         class EVS = DEFAULT_STRATEGY_REDUCERS,
-        XTL_REQUIRES(xtl::negation<is_reducer_options<X>>)>
+        XTL_REQUIRES(std::negation<is_reducer_options<X>>)>
     inline auto nanvar(E&& e, X&& axes, EVS es = EVS())
     {
         decltype(auto) sc = detail::shared_forward<E>(e);
@@ -2867,7 +2867,7 @@ namespace xt
         class E,
         class X,
         class EVS = DEFAULT_STRATEGY_REDUCERS,
-        XTL_REQUIRES(xtl::negation<is_reducer_options<X>>)>
+        XTL_REQUIRES(std::negation<is_reducer_options<X>>)>
     inline auto nanstd(E&& e, X&& axes, EVS es = EVS())
     {
         return sqrt(nanvar<T>(std::forward<E>(e), std::forward<X>(axes), es));
diff --git a/include/xtensor/core/xoperation.hpp b/include/xtensor/core/xoperation.hpp
index 407139ae7..533ad6513 100644
--- a/include/xtensor/core/xoperation.hpp
+++ b/include/xtensor/core/xoperation.hpp
@@ -44,21 +44,21 @@ namespace xt
     }
 
 #define DEFINE_COMPLEX_OVERLOAD(OP)                                                           \
-    template <class T1, class T2, XTL_REQUIRES(xtl::negation<std::is_same<T1, T2>>)>          \
+    template <class T1, class T2, XTL_REQUIRES(std::negation<std::is_same<T1, T2>>)>          \
     constexpr auto operator OP(const std::complex<T1>& arg1, const std::complex<T2>& arg2)    \
     {                                                                                         \
         using result_type = typename xtl::promote_type_t<std::complex<T1>, std::complex<T2>>; \
         return (result_type(arg1) OP result_type(arg2));                                      \
     }                                                                                         \
                                                                                               \
-    template <class T1, class T2, XTL_REQUIRES(xtl::negation<std::is_same<T1, T2>>)>          \
+    template <class T1, class T2, XTL_REQUIRES(std::negation<std::is_same<T1, T2>>)>          \
     constexpr auto operator OP(const T1& arg1, const std::complex<T2>& arg2)                  \
     {                                                                                         \
         using result_type = typename xtl::promote_type_t<T1, std::complex<T2>>;               \
         return (result_type(arg1) OP result_type(arg2));                                      \
     }                                                                                         \
                                                                                               \
-    template <class T1, class T2, XTL_REQUIRES(xtl::negation<std::is_same<T1, T2>>)>          \
+    template <class T1, class T2, XTL_REQUIRES(std::negation<std::is_same<T1, T2>>)>          \
     constexpr auto operator OP(const std::complex<T1>& arg1, const T2& arg2)                  \
     {                                                                                         \
         using result_type = typename xtl::promote_type_t<std::complex<T1>, T2>;               \
diff --git a/include/xtensor/core/xshape.hpp b/include/xtensor/core/xshape.hpp
index df0b84392..b4027d9dd 100644
--- a/include/xtensor/core/xshape.hpp
+++ b/include/xtensor/core/xshape.hpp
@@ -338,7 +338,7 @@ namespace xt
 
             using type = xt::fixed_shape<
                 broadcast_fixed_shape_cmp_impl<JX, fixed_shape<I...>, fixed_shape<J...>>::ordinate...>;
-            static constexpr bool value = xtl::conjunction<
+            static constexpr bool value = std::conjunction<
                 broadcast_fixed_shape_cmp_impl<JX, fixed_shape<I...>, fixed_shape<J...>>...>::value;
         };
 
@@ -390,18 +390,18 @@ namespace xt
         };
 
         template <class... S>
-        using only_array = xtl::conjunction<xtl::disjunction<is_array<S>, is_fixed<S>>...>;
+        using only_array = std::conjunction<std::disjunction<is_array<S>, is_fixed<S>>...>;
 
         // test that at least one argument is a fixed shape. If yes, then either argument has to be fixed or
         // scalar
         template <class... S>
         using only_fixed = std::integral_constant<
             bool,
-            xtl::disjunction<is_fixed<S>...>::value
-                && xtl::conjunction<xtl::disjunction<is_fixed<S>, is_scalar_shape<S>>...>::value>;
+            std::disjunction<is_fixed<S>...>::value
+                && std::conjunction<std::disjunction<is_fixed<S>, is_scalar_shape<S>>...>::value>;
 
         template <class... S>
-        using all_fixed = xtl::conjunction<is_fixed<S>...>;
+        using all_fixed = std::conjunction<is_fixed<S>...>;
 
         // The promote_index meta-function returns std::vector<promoted_value_type> in the
         // general case and an array of the promoted value type and maximal size if all
@@ -461,7 +461,7 @@ namespace xt
         public:
 
             using type = typename result::type;
-            static constexpr bool value = xtl::conjunction<intermediate, result>::value;
+            static constexpr bool value = std::conjunction<intermediate, result>::value;
         };
 
         template <bool all_index, bool all_array, class... S>
diff --git a/include/xtensor/generators/xbuilder.hpp b/include/xtensor/generators/xbuilder.hpp
index 4d3263107..cb94cea0f 100644
--- a/include/xtensor/generators/xbuilder.hpp
+++ b/include/xtensor/generators/xbuilder.hpp
@@ -203,7 +203,7 @@ namespace xt
             }
         }
 
-        template <class R, class E, class U, class X, XTL_REQUIRES(xtl::negation<xtl::is_integral<X>>)>
+        template <class R, class E, class U, class X, XTL_REQUIRES(std::negation<xtl::is_integral<X>>)>
         inline void arange_assign_to(xexpression<E>& e, U start, U stop, X step, bool endpoint) noexcept
         {
             auto& buf = e.derived_cast().storage();
@@ -282,15 +282,15 @@ namespace xt
         };
 
         template <class T, class S>
-        using both_integer = xtl::conjunction<xtl::is_integral<T>, xtl::is_integral<S>>;
+        using both_integer = std::conjunction<xtl::is_integral<T>, xtl::is_integral<S>>;
 
         template <class T, class S>
-        using integer_with_signed_integer = xtl::conjunction<both_integer<T, S>, xtl::is_signed<S>>;
+        using integer_with_signed_integer = std::conjunction<both_integer<T, S>, xtl::is_signed<S>>;
 
         template <class T, class S>
-        using integer_with_unsigned_integer = xtl::conjunction<both_integer<T, S>, std::is_unsigned<S>>;
+        using integer_with_unsigned_integer = std::conjunction<both_integer<T, S>, std::is_unsigned<S>>;
 
-        template <class T, class S = T, XTL_REQUIRES(xtl::negation<both_integer<T, S>>)>
+        template <class T, class S = T, XTL_REQUIRES(std::negation<both_integer<T, S>>)>
         inline auto arange_impl(T start, T stop, S step = 1) noexcept
         {
             std::size_t shape = static_cast<std::size_t>(std::ceil((stop - start) / step));
@@ -712,7 +712,7 @@ namespace xt
     namespace detail
     {
         template <bool... values>
-        using all_true = xtl::conjunction<std::integral_constant<bool, values>...>;
+        using all_true = std::conjunction<std::integral_constant<bool, values>...>;
 
         template <class X, class Y, std::size_t axis, class AxesSequence>
         struct concat_fixed_shape_impl;
diff --git a/include/xtensor/io/xjson.hpp b/include/xtensor/io/xjson.hpp
index 8aa20c9c9..18623b7f8 100644
--- a/include/xtensor/io/xjson.hpp
+++ b/include/xtensor/io/xjson.hpp
@@ -58,7 +58,7 @@ namespace xt
                 size_type nrows = view.shape()[0];
                 for (size_type i = 0; i != nrows; ++i)
                 {
-                    slices.push_back(i);
+                    slices.push_back(static_cast<std::ptrdiff_t>(i));
                     nlohmann::basic_json<M> k;
                     to_json_impl(k, e, slices);
                     j.push_back(std::move(k));
@@ -83,7 +83,7 @@ namespace xt
                 size_type nrows = view.shape()[0];
                 for (size_type i = 0; i != nrows; ++i)
                 {
-                    slices.push_back(i);
+                    slices.push_back(static_cast<std::ptrdiff_t>(i));
                     const nlohmann::basic_json<M>& k = j[i];
                     from_json_impl(k, e, slices);
                     slices.pop_back();
diff --git a/include/xtensor/io/xnpy.hpp b/include/xtensor/io/xnpy.hpp
index 382e06e32..369d68c9d 100644
--- a/include/xtensor/io/xnpy.hpp
+++ b/include/xtensor/io/xnpy.hpp
@@ -418,11 +418,11 @@ namespace xt
                 ss_shape << *shape_it << ", ";
             }
             s_shape = ss_shape.str();
-            if (xtl::sequence_size(shape) > 1)
+            if (std::size(shape) > 1)
             {
                 s_shape = s_shape.erase(s_shape.size() - 2);
             }
-            else if (xtl::sequence_size(shape) == 1)
+            else if (std::size(shape) == 1)
             {
                 s_shape = s_shape.erase(s_shape.size() - 1);
             }
diff --git a/include/xtensor/misc/xexpression_holder.hpp b/include/xtensor/misc/xexpression_holder.hpp
index ec495721e..f720cc006 100644
--- a/include/xtensor/misc/xexpression_holder.hpp
+++ b/include/xtensor/misc/xexpression_holder.hpp
@@ -17,7 +17,6 @@
 #include "../containers/xarray.hpp"
 #include "../core/xtensor_config.hpp"
 #include "../io/xjson.hpp"
-#include "xtl/xany.hpp"
 
 namespace xt
 {
diff --git a/include/xtensor/misc/xmanipulation.hpp b/include/xtensor/misc/xmanipulation.hpp
index aa1b38038..42395dd57 100644
--- a/include/xtensor/misc/xmanipulation.hpp
+++ b/include/xtensor/misc/xmanipulation.hpp
@@ -147,7 +147,7 @@ namespace xt
         template <class E, class S>
         inline auto transpose_impl(E&& e, S&& permutation, check_policy::none)
         {
-            if (sequence_size(permutation) != e.dimension())
+            if (std::size(permutation) != e.dimension())
             {
                 XTENSOR_THROW(transpose_error, "Permutation does not have the same size as shape");
             }
@@ -197,9 +197,9 @@ namespace xt
         inline auto transpose_impl(E&& e, S&& permutation, check_policy::full)
         {
             // check if axis appears twice in permutation
-            for (std::size_t i = 0; i < sequence_size(permutation); ++i)
+            for (std::size_t i = 0; i < std::size(permutation); ++i)
             {
-                for (std::size_t j = i + 1; j < sequence_size(permutation); ++j)
+                for (std::size_t j = i + 1; j < std::size(permutation); ++j)
                 {
                     if (permutation[i] == permutation[j])
                     {
diff --git a/include/xtensor/misc/xpad.hpp b/include/xtensor/misc/xpad.hpp
index 90a55782b..1204632f3 100644
--- a/include/xtensor/misc/xpad.hpp
+++ b/include/xtensor/misc/xpad.hpp
@@ -298,7 +298,7 @@ namespace xt
         return detail::tile(std::forward<E>(e), std::vector<S>{reps});
     }
 
-    template <class E, class C, XTL_REQUIRES(xtl::negation<xtl::is_integral<C>>)>
+    template <class E, class C, XTL_REQUIRES(std::negation<xtl::is_integral<C>>)>
     inline auto tile(E&& e, const C& reps)
     {
         return detail::tile(std::forward<E>(e), reps);
diff --git a/include/xtensor/reducers/xblockwise_reducer.hpp b/include/xtensor/reducers/xblockwise_reducer.hpp
index 57187798f..902b41f08 100644
--- a/include/xtensor/reducers/xblockwise_reducer.hpp
+++ b/include/xtensor/reducers/xblockwise_reducer.hpp
@@ -291,7 +291,7 @@ namespace xt
         class BS,                                                                                             \
         class X,                                                                                              \
         class O = DEFAULT_STRATEGY_REDUCERS,                                                                  \
-        XTL_REQUIRES(xtl::negation<is_reducer_options<X>>, xtl::negation<xtl::is_integral<std::decay_t<X>>>)> \
+        XTL_REQUIRES(std::negation<is_reducer_options<X>>, std::negation<xtl::is_integral<std::decay_t<X>>>)> \
     auto FNAME(E&& e, BS&& block_shape, X&& axes, O options = O())                                            \
     {                                                                                                         \
         using input_expression_type = std::decay_t<E>;                                                        \
@@ -329,7 +329,7 @@ namespace xt
         class E,                                                                                              \
         class BS,                                                                                             \
         class O = DEFAULT_STRATEGY_REDUCERS,                                                                  \
-        XTL_REQUIRES(is_reducer_options<O>, xtl::negation<xtl::is_integral<std::decay_t<O>>>)>                \
+        XTL_REQUIRES(is_reducer_options<O>, std::negation<xtl::is_integral<std::decay_t<O>>>)>                \
     auto FNAME(E&& e, BS&& block_shape, O options = O())                                                      \
     {                                                                                                         \
         using input_expression_type = std::decay_t<E>;                                                        \
@@ -380,7 +380,7 @@ namespace xt
         class BS,                                                                                                               \
         class X,                                                                                                                \
         class O = DEFAULT_STRATEGY_REDUCERS,                                                                                    \
-        XTL_REQUIRES(xtl::negation<is_reducer_options<X>>, xtl::negation<xtl::is_integral<std::decay_t<X>>>)>                   \
+        XTL_REQUIRES(std::negation<is_reducer_options<X>>, std::negation<xtl::is_integral<std::decay_t<X>>>)>                   \
     auto FNAME(E&& e, BS&& block_shape, X&& axes, O options = O())                                                              \
     {                                                                                                                           \
         using input_expression_type = std::decay_t<E>;                                                                          \
@@ -411,7 +411,7 @@ namespace xt
         class E,                                                                                                                \
         class BS,                                                                                                               \
         class O = DEFAULT_STRATEGY_REDUCERS,                                                                                    \
-        XTL_REQUIRES(is_reducer_options<O>, xtl::negation<xtl::is_integral<std::decay_t<O>>>)>                                  \
+        XTL_REQUIRES(is_reducer_options<O>, std::negation<xtl::is_integral<std::decay_t<O>>>)>                                  \
     auto FNAME(E&& e, BS&& block_shape, O options = O())                                                                        \
     {                                                                                                                           \
         using input_expression_type = std::decay_t<E>;                                                                          \
@@ -458,7 +458,7 @@ namespace xt
         class BS,                                                                                                               \
         class X,                                                                                                                \
         class O = DEFAULT_STRATEGY_REDUCERS,                                                                                    \
-        XTL_REQUIRES(xtl::negation<is_reducer_options<X>>, xtl::negation<xtl::is_integral<std::decay_t<X>>>)>                   \
+        XTL_REQUIRES(std::negation<is_reducer_options<X>>, std::negation<xtl::is_integral<std::decay_t<X>>>)>                   \
     auto FNAME(E&& e, BS&& block_shape, double p, X&& axes, O options = O())                                                    \
     {                                                                                                                           \
         using input_expression_type = std::decay_t<E>;                                                                          \
@@ -489,7 +489,7 @@ namespace xt
         class E,                                                                                                                \
         class BS,                                                                                                               \
         class O = DEFAULT_STRATEGY_REDUCERS,                                                                                    \
-        XTL_REQUIRES(is_reducer_options<O>, xtl::negation<xtl::is_integral<std::decay_t<O>>>)>                                  \
+        XTL_REQUIRES(is_reducer_options<O>, std::negation<xtl::is_integral<std::decay_t<O>>>)>                                  \
     auto FNAME(E&& e, BS&& block_shape, double p, O options = O())                                                              \
     {                                                                                                                           \
         using input_expression_type = std::decay_t<E>;                                                                          \
diff --git a/include/xtensor/reducers/xnorm.hpp b/include/xtensor/reducers/xnorm.hpp
index aadeea4f9..b883573f6 100644
--- a/include/xtensor/reducers/xnorm.hpp
+++ b/include/xtensor/reducers/xnorm.hpp
@@ -395,7 +395,7 @@ namespace xt
 #define XTENSOR_EMPTY
 #define XTENSOR_COMMA ,
 #define XTENSOR_NORM_FUNCTION(NAME, RESULT_TYPE, REDUCE_EXPR, REDUCE_OP, MERGE_FUNC)                                       \
-    template <class E, class X, class EVS = DEFAULT_STRATEGY_REDUCERS, XTL_REQUIRES(xtl::negation<is_reducer_options<X>>)> \
+    template <class E, class X, class EVS = DEFAULT_STRATEGY_REDUCERS, XTL_REQUIRES(std::negation<is_reducer_options<X>>)> \
     inline auto NAME(E&& e, X&& axes, EVS es = EVS()) noexcept                                                             \
     {                                                                                                                      \
         using value_type = typename std::decay_t<E>::value_type;                                                           \
@@ -512,7 +512,7 @@ namespace xt
         class E,
         class X,
         class EVS = DEFAULT_STRATEGY_REDUCERS,
-        XTL_REQUIRES(is_xexpression<E>, xtl::negation<is_reducer_options<X>>)>
+        XTL_REQUIRES(is_xexpression<E>, std::negation<is_reducer_options<X>>)>
     inline auto norm_l2(E&& e, X&& axes, EVS es = EVS()) noexcept
     {
         return sqrt(norm_sq(std::forward<E>(e), std::forward<X>(axes), es));
@@ -553,7 +553,7 @@ namespace xt
      * When no axes are provided, the norm is calculated over the entire array. In this case,
      * the reducer represents a scalar result, otherwise an array of appropriate dimension.
      */
-    template <class E, class X, class EVS = DEFAULT_STRATEGY_REDUCERS, XTL_REQUIRES(xtl::negation<is_reducer_options<X>>)>
+    template <class E, class X, class EVS = DEFAULT_STRATEGY_REDUCERS, XTL_REQUIRES(std::negation<is_reducer_options<X>>)>
     inline auto norm_lp_to_p(E&& e, double p, X&& axes, EVS es = EVS()) noexcept
     {
         using value_type = typename std::decay_t<E>::value_type;
@@ -597,7 +597,7 @@ namespace xt
      * When no axes are provided, the norm is calculated over the entire array. In this case,
      * the reducer represents a scalar result, otherwise an array of appropriate dimension.
      */
-    template <class E, class X, class EVS = DEFAULT_STRATEGY_REDUCERS, XTL_REQUIRES(xtl::negation<is_reducer_options<X>>)>
+    template <class E, class X, class EVS = DEFAULT_STRATEGY_REDUCERS, XTL_REQUIRES(std::negation<is_reducer_options<X>>)>
     inline auto norm_lp(E&& e, double p, X&& axes, EVS es = EVS())
     {
         XTENSOR_PRECONDITION(p != 0, "norm_lp(): p must be nonzero, use norm_l0() instead.");
diff --git a/include/xtensor/reducers/xreducer.hpp b/include/xtensor/reducers/xreducer.hpp
index bce3e7b11..3cf8ec76f 100644
--- a/include/xtensor/reducers/xreducer.hpp
+++ b/include/xtensor/reducers/xreducer.hpp
@@ -130,19 +130,11 @@ namespace xt
 
         reducer_options(const T& tpl)
         {
-            xtl::mpl::static_if<initial_val_idx != std::tuple_size<T>::value>(
-                [this, &tpl](auto no_compile)
-                {
-                    // use no_compile to prevent compilation if initial_val_idx is out of bounds!
-                    this->initial_value = no_compile(
-                                              std::get < initial_val_idx != std::tuple_size<T>::value
-                                                  ? initial_val_idx
-                                                  : 0 > (tpl)
-                    )
-                                              .value();
-                },
-                [](auto /*np_compile*/) {}
-            );
+            if constexpr (initial_val_idx != std::tuple_size<T>::value)
+            {
+                initial_value = std::get < initial_val_idx != std::tuple_size<T>::value ? initial_val_idx
+                                                                                        : 0 > (tpl).value();
+            }
         }
 
         using evaluation_strategy = std::conditional_t<
@@ -272,7 +264,7 @@ namespace xt
         class F,
         class E,
         class R,
-        XTL_REQUIRES(xtl::negation<std::is_convertible<typename E::value_type, typename R::value_type>>)>
+        XTL_REQUIRES(std::negation<std::is_convertible<typename E::value_type, typename R::value_type>>)>
     inline void copy_to_reduced(F& f, const E& e, R& result)
     {
         if (e.layout() == layout_type::row_major)
@@ -998,7 +990,7 @@ namespace xt
         class E,
         class X,
         class EVS = DEFAULT_STRATEGY_REDUCERS,
-        XTL_REQUIRES(xtl::negation<is_reducer_options<X>>, detail::is_xreducer_functors<F>)>
+        XTL_REQUIRES(std::negation<is_reducer_options<X>>, detail::is_xreducer_functors<F>)>
     inline auto reduce(F&& f, E&& e, X&& axes, EVS&& options = EVS())
     {
         return detail::reduce_impl(
@@ -1015,7 +1007,7 @@ namespace xt
         class E,
         class X,
         class EVS = DEFAULT_STRATEGY_REDUCERS,
-        XTL_REQUIRES(xtl::negation<is_reducer_options<X>>, xtl::negation<detail::is_xreducer_functors<F>>)>
+        XTL_REQUIRES(std::negation<is_reducer_options<X>>, std::negation<detail::is_xreducer_functors<F>>)>
     inline auto reduce(F&& f, E&& e, X&& axes, EVS&& options = EVS())
     {
         return reduce(
@@ -1049,7 +1041,7 @@ namespace xt
         class F,
         class E,
         class EVS = DEFAULT_STRATEGY_REDUCERS,
-        XTL_REQUIRES(is_reducer_options<EVS>, xtl::negation<detail::is_xreducer_functors<F>>)>
+        XTL_REQUIRES(is_reducer_options<EVS>, std::negation<detail::is_xreducer_functors<F>>)>
     inline auto reduce(F&& f, E&& e, EVS&& options = EVS())
     {
         return reduce(make_xreducer_functor(std::forward<F>(f)), std::forward<E>(e), std::forward<EVS>(options));
@@ -1081,7 +1073,7 @@ namespace xt
         class I,
         std::size_t N,
         class EVS = DEFAULT_STRATEGY_REDUCERS,
-        XTL_REQUIRES(xtl::negation<detail::is_xreducer_functors<F>>)>
+        XTL_REQUIRES(std::negation<detail::is_xreducer_functors<F>>)>
     inline auto reduce(F&& f, E&& e, const I (&axes)[N], EVS options = EVS())
     {
         return reduce(make_xreducer_functor(std::forward<F>(f)), std::forward<E>(e), axes, options);
@@ -1154,7 +1146,7 @@ namespace xt
         template <std::size_t X, std::size_t... I>
         struct in
         {
-            static constexpr bool value = xtl::disjunction<std::integral_constant<bool, X == I>...>::value;
+            static constexpr bool value = std::disjunction<std::integral_constant<bool, X == I>...>::value;
         };
 
         template <std::size_t Z, class S1, class S2, class R>
diff --git a/include/xtensor/utils/xutils.hpp b/include/xtensor/utils/xutils.hpp
index 3f309c74f..4f83a7a79 100644
--- a/include/xtensor/utils/xutils.hpp
+++ b/include/xtensor/utils/xutils.hpp
@@ -428,7 +428,7 @@ namespace xt
         -> std::enable_if_t<xtl::is_signed<std::decay_t<decltype(*std::begin(axes))>>::value, R>
     {
         R res;
-        xt::resize_container(res, xtl::sequence_size(axes));
+        xt::resize_container(res, std::size(axes));
         auto dim = expr.dimension();
         std::transform(
             std::begin(axes),
@@ -460,7 +460,7 @@ namespace xt
         static_cast<void>(expr);
 
         R res;
-        xt::resize_container(res, xtl::sequence_size(axes));
+        xt::resize_container(res, std::size(axes));
         std::copy(std::begin(axes), std::end(axes), std::begin(res));
         XTENSOR_ASSERT(std::all_of(
             res.begin(),
@@ -620,24 +620,6 @@ namespace xt
         return detail::to_array_impl(a, std::make_index_sequence<N>{});
     }
 
-    /********************************
-     * sequence_size implementation *
-     ********************************/
-
-    // equivalent to std::size(c) in c++17
-    template <class C>
-    constexpr auto sequence_size(const C& c) -> decltype(c.size())
-    {
-        return c.size();
-    }
-
-    // equivalent to std::size(a) in c++17
-    template <class T, std::size_t N>
-    constexpr std::size_t sequence_size(const T (&)[N])
-    {
-        return N;
-    }
-
     /***********************************
      * has_storage_type implementation *
      ***********************************/
@@ -652,7 +634,7 @@ namespace xt
 
     template <class T>
     struct has_storage_type<T, void_t<typename xcontainer_inner_types<T>::storage_type>>
-        : xtl::negation<
+        : std::negation<
               std::is_same<typename std::remove_cv<typename xcontainer_inner_types<T>::storage_type>::type, invalid_type>>
     {
     };
diff --git a/include/xtensor/views/xdynamic_view.hpp b/include/xtensor/views/xdynamic_view.hpp
index c09f294f1..5ab298f23 100644
--- a/include/xtensor/views/xdynamic_view.hpp
+++ b/include/xtensor/views/xdynamic_view.hpp
@@ -9,8 +9,9 @@
 #ifndef XTENSOR_DYNAMIC_VIEW_HPP
 #define XTENSOR_DYNAMIC_VIEW_HPP
 
+#include <variant>
+
 #include <xtl/xsequence.hpp>
-#include <xtl/xvariant.hpp>
 
 #include "../core/xexpression.hpp"
 #include "../core/xiterable.hpp"
@@ -143,7 +144,7 @@ namespace xt
         using bool_load_type = typename base_type::bool_load_type;
 
         using strides_vt = typename strides_type::value_type;
-        using slice_type = xtl::variant<detail::xfake_slice<strides_vt>, xkeep_slice<strides_vt>, xdrop_slice<strides_vt>>;
+        using slice_type = std::variant<detail::xfake_slice<strides_vt>, xkeep_slice<strides_vt>, xdrop_slice<strides_vt>>;
         using slice_vector_type = std::vector<slice_type>;
 
         template <class CTA, class SA>
@@ -287,7 +288,7 @@ namespace xt
      **************************/
 
     template <class T>
-    using xdynamic_slice = xtl::variant<
+    using xdynamic_slice = std::variant<
         T,
 
         xrange_adaptor<placeholders::xtuph, T, T>,
@@ -505,7 +506,7 @@ namespace xt
     inline auto xdynamic_view<CT, S, L, FST>::data_offset() const noexcept -> size_type
     {
         size_type offset = base_type::data_offset();
-        size_type sl_offset = xtl::visit(
+        size_type sl_offset = std::visit(
             [](const auto& sl)
             {
                 return sl(size_type(0));
@@ -648,7 +649,7 @@ namespace xt
     xdynamic_view<CT, S, L, FST>::adjust_offset_impl(offset_type offset, size_type idx_offset, T idx, Args... args)
         const noexcept -> offset_type
     {
-        offset_type sl_offset = xtl::visit(
+        offset_type sl_offset = std::visit(
             [idx](const auto& sl)
             {
                 using type = typename std::decay_t<decltype(sl)>::size_type;
@@ -681,7 +682,7 @@ namespace xt
         for (offset_type i = loop_offset; i < dim; ++i, ++first)
         {
             offset_type j = static_cast<offset_type>(first[idx_offset]);
-            offset_type sl_offset = xtl::visit(
+            offset_type sl_offset = std::visit(
                 [j](const auto& sl)
                 {
                     return static_cast<offset_type>(sl(j));
@@ -764,11 +765,11 @@ namespace xt
                 get_strides_t<S>& strides
             )
             {
-                auto* sl = xtl::get_if<SL>(&slices[sl_idx]);
+                auto* sl = std::get_if<SL>(&slices[sl_idx]);
                 if (sl != nullptr)
                 {
                     new_slices[i] = *sl;
-                    auto& ns = xtl::get<SL>(new_slices[i]);
+                    auto& ns = std::get<SL>(new_slices[i]);
                     ns.normalize(old_shape);
                     shape[i] = static_cast<std::size_t>(ns.size());
                     strides[i] = std::ptrdiff_t(0);
diff --git a/include/xtensor/views/xfunctor_view.hpp b/include/xtensor/views/xfunctor_view.hpp
index a0b8404cc..9f2daf712 100644
--- a/include/xtensor/views/xfunctor_view.hpp
+++ b/include/xtensor/views/xfunctor_view.hpp
@@ -359,7 +359,7 @@ namespace xt
 
     template <class D, class T>
     struct has_simd_interface<xfunctor_applier_base<D>, T>
-        : xtl::conjunction<
+        : std::conjunction<
               has_simd_type<T>,
               has_simd_interface<typename xfunctor_applier_base<D>::xexpression_type>,
               detail::has_simd_interface_impl<xfunctor_applier_base<D>, T>>
diff --git a/include/xtensor/views/xslice.hpp b/include/xtensor/views/xslice.hpp
index 04d4efc5b..4faa17cca 100644
--- a/include/xtensor/views/xslice.hpp
+++ b/include/xtensor/views/xslice.hpp
@@ -67,7 +67,7 @@ namespace xt
     using disable_xslice = typename std::enable_if<!is_xslice<E>::value, R>::type;
 
     template <class... E>
-    using has_xslice = xtl::disjunction<is_xslice<E>...>;
+    using has_xslice = std::disjunction<is_xslice<E>...>;
 
     /**************
      * slice tags *
diff --git a/include/xtensor/views/xstrided_view.hpp b/include/xtensor/views/xstrided_view.hpp
index fba2c5ce5..b52da8e30 100644
--- a/include/xtensor/views/xstrided_view.hpp
+++ b/include/xtensor/views/xstrided_view.hpp
@@ -15,9 +15,9 @@
 #include <tuple>
 #include <type_traits>
 #include <utility>
+#include <variant>
 
 #include <xtl/xsequence.hpp>
-#include <xtl/xvariant.hpp>
 
 #include "../containers/xstorage.hpp"
 #include "../core/xexpression.hpp"
@@ -315,7 +315,7 @@ namespace xt
      **************************/
 
     template <class T>
-    using xstrided_slice = xtl::variant<
+    using xstrided_slice = std::variant<
         T,
 
         xrange_adaptor<placeholders::xtuph, T, T>,
diff --git a/include/xtensor/views/xstrided_view_base.hpp b/include/xtensor/views/xstrided_view_base.hpp
index 640aedcca..be67ee191 100644
--- a/include/xtensor/views/xstrided_view_base.hpp
+++ b/include/xtensor/views/xstrided_view_base.hpp
@@ -11,9 +11,9 @@
 #define XTENSOR_STRIDED_VIEW_BASE_HPP
 
 #include <type_traits>
+#include <variant>
 
 #include <xtl/xsequence.hpp>
-#include <xtl/xvariant.hpp>
 
 #include "../core/xaccessible.hpp"
 #include "../core/xstrides.hpp"
@@ -87,7 +87,7 @@ namespace xt
 
         template <class E, class ST>
         struct provides_data_interface
-            : xtl::conjunction<has_data_interface<std::decay_t<E>>, xtl::negation<is_flat_expression_adaptor<ST>>>
+            : std::conjunction<has_data_interface<std::decay_t<E>>, std::negation<is_flat_expression_adaptor<ST>>>
         {
         };
     }
@@ -846,17 +846,17 @@ namespace xt
                 bool has_ellipsis = false;
                 for (const auto& el : slices)
                 {
-                    if (xtl::get_if<xt::xnewaxis_tag>(&el) != nullptr)
+                    if (std::get_if<xt::xnewaxis_tag>(&el) != nullptr)
                     {
                         ++dimension;
                         ++n_newaxis;
                     }
-                    else if (xtl::get_if<std::ptrdiff_t>(&el) != nullptr)
+                    else if (std::get_if<std::ptrdiff_t>(&el) != nullptr)
                     {
                         --dimension;
                         --dimension_check;
                     }
-                    else if (xtl::get_if<xt::xellipsis_tag>(&el) != nullptr)
+                    else if (std::get_if<xt::xellipsis_tag>(&el) != nullptr)
                     {
                         if (has_ellipsis == true)
                         {
@@ -899,19 +899,19 @@ namespace xt
                 for (; i < slices.size(); ++i)
                 {
                     i_ax = static_cast<std::size_t>(static_cast<std::ptrdiff_t>(i) - axis_skip);
-                    auto ptr = xtl::get_if<std::ptrdiff_t>(&slices[i]);
+                    auto ptr = std::get_if<std::ptrdiff_t>(&slices[i]);
                     if (ptr != nullptr)
                     {
                         auto slice0 = static_cast<old_strides_value_type>(*ptr);
                         new_offset += static_cast<std::size_t>(slice0 * old_strides[i_ax]);
                     }
-                    else if (xtl::get_if<xt::xnewaxis_tag>(&slices[i]) != nullptr)
+                    else if (std::get_if<xt::xnewaxis_tag>(&slices[i]) != nullptr)
                     {
                         new_shape[idx] = 1;
                         base_type::set_fake_slice(idx);
                         ++axis_skip, ++idx;
                     }
-                    else if (xtl::get_if<xt::xellipsis_tag>(&slices[i]) != nullptr)
+                    else if (std::get_if<xt::xellipsis_tag>(&slices[i]) != nullptr)
                     {
                         for (std::size_t j = 0; j < n_add_all; ++j)
                         {
@@ -922,7 +922,7 @@ namespace xt
                         }
                         axis_skip = axis_skip - static_cast<std::ptrdiff_t>(n_add_all) + 1;
                     }
-                    else if (xtl::get_if<xt::xall_tag>(&slices[i]) != nullptr)
+                    else if (std::get_if<xt::xall_tag>(&slices[i]) != nullptr)
                     {
                         new_shape[idx] = old_shape[i_ax];
                         new_strides[idx] = old_strides[i_ax];
@@ -936,7 +936,7 @@ namespace xt
                     else
                     {
                         slice_getter.idx = i_ax;
-                        auto info = xtl::visit(slice_getter, slices[i]);
+                        auto info = std::visit(slice_getter, slices[i]);
                         new_offset += static_cast<std::size_t>(info[0] * old_strides[i_ax]);
                         new_shape[idx] = static_cast<std::size_t>(info[1]);
                         new_strides[idx] = info[2] * old_strides[i_ax];
diff --git a/include/xtensor/views/xview.hpp b/include/xtensor/views/xview.hpp
index a66ca56c7..85515da22 100644
--- a/include/xtensor/views/xview.hpp
+++ b/include/xtensor/views/xview.hpp
@@ -155,7 +155,7 @@ namespace xt
         struct is_strided_view
             : std::integral_constant<
                   bool,
-                  xtl::conjunction<has_data_interface<E>, is_strided_slice_impl<std::decay_t<S>>...>::value>
+                  std::conjunction<has_data_interface<E>, is_strided_slice_impl<std::decay_t<S>>...>::value>
         {
         };
 
@@ -272,7 +272,7 @@ namespace xt
         {
             // if we have no `range` in the slices we can re-use the shape with an offset
             using type = std::conditional_t<
-                xtl::disjunction<is_xrange<S>...>::value,
+                std::disjunction<is_xrange<S>...>::value,
                 typename xview_shape_type<typename E::shape_type, S...>::type,
                 // In the false branch we know that we have only integers at the front OR end, and NO range
                 typename unwrap_offset_container<E::static_layout, typename E::inner_shape_type, integral_count<S...>()>::type>;
@@ -405,7 +405,7 @@ namespace xt
         using storage_type = typename inner_types::storage_type;
 
         static constexpr bool has_trivial_strides = is_contiguous_view
-                                                    && !xtl::disjunction<detail::is_xrange<S>...>::value;
+                                                    && !std::disjunction<detail::is_xrange<S>...>::value;
         using inner_strides_type = std::conditional_t<
             has_trivial_strides,
             typename detail::unwrap_offset_container<
@@ -973,30 +973,22 @@ namespace xt
     template <class CT, class... S>
     inline layout_type xview<CT, S...>::layout() const noexcept
     {
-        return xtl::mpl::static_if<is_strided_view>(
-            [&](auto self)
+        if constexpr (is_strided_view)
+        {
+            if (static_layout != layout_type::dynamic)
             {
-                if (static_layout != layout_type::dynamic)
-                {
-                    return static_layout;
-                }
-                else
-                {
-                    bool strides_match = do_strides_match(
-                        self(this)->shape(),
-                        self(this)->strides(),
-                        self(this)->m_e.layout(),
-                        true
-                    );
-                    return strides_match ? self(this)->m_e.layout() : layout_type::dynamic;
-                }
-            },
-            /* else */
-            [&](auto /*self*/)
+                return static_layout;
+            }
+            else
             {
-                return layout_type::dynamic;
+                bool strides_match = do_strides_match(shape(), strides(), m_e.layout(), true);
+                return strides_match ? m_e.layout() : layout_type::dynamic;
             }
-        );
+        }
+        else
+        {
+            return layout_type::dynamic;
+        }
     }
 
     template <class CT, class... S>
@@ -1020,17 +1012,14 @@ namespace xt
     template <class T>
     inline void xview<CT, S...>::fill(const T& value)
     {
-        xtl::mpl::static_if<static_layout != layout_type::dynamic>(
-            [&](auto self)
-            {
-                std::fill(self(this)->linear_begin(), self(this)->linear_end(), value);
-            },
-            /*else*/
-            [&](auto self)
-            {
-                std::fill(self(this)->begin(), self(this)->end(), value);
-            }
-        );
+        if constexpr (static_layout != layout_type::dynamic)
+        {
+            std::fill(linear_begin(), linear_end(), value);
+        }
+        else
+        {
+            std::fill(this->begin(), this->end(), value);
+        }
     }
 
     /**
@@ -1409,18 +1398,14 @@ namespace xt
     template <class ST>
     inline bool xview<CT, S...>::has_linear_assign(const ST& str) const
     {
-        return xtl::mpl::static_if<is_strided_view>(
-            [&](auto self)
-            {
-                return str.size() == self(this)->strides().size()
-                       && std::equal(str.cbegin(), str.cend(), self(this)->strides().begin());
-            },
-            /*else*/
-            [](auto /*self*/)
-            {
-                return false;
-            }
-        );
+        if constexpr (is_strided_view)
+        {
+            return str.size() == strides().size() && std::equal(str.cbegin(), str.cend(), strides().begin());
+        }
+        else
+        {
+            return false;
+        }
     }
 
     //@}
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 19a03dc4d..cc2f9281a 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -7,7 +7,7 @@
 # The full license is in the file LICENSE, distributed with this software. #
 ############################################################################
 
-cmake_minimum_required(VERSION 3.5)
+cmake_minimum_required(VERSION 3.29)
 
 if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
     project(xtensor-test CXX)
@@ -34,19 +34,7 @@ string(TOUPPER "${CMAKE_BUILD_TYPE}" U_CMAKE_BUILD_TYPE)
 
 include(set_compiler_flag.cmake)
 
-
-
-if(CPP17)
-  # User requested C++17, but compiler might not oblige.
-  set_compiler_flag(
-    _cxx_std_flag CXX
-    "-std=c++17"  # this should work with GNU, Intel, PGI
-    "/std:c++17"  # this should work with MSVC
-  )
-  if(_cxx_std_flag)
-    message(STATUS "Building with C++17")
-  endif()
-elseif(CPP20)
+if(CPP20)
   # User requested C++17, but compiler might not oblige.
   set_compiler_flag(
     _cxx_std_flag CXX
@@ -59,14 +47,14 @@ elseif(CPP20)
 else()
   set_compiler_flag(
     _cxx_std_flag CXX REQUIRED
-    "-std=c++14"  # this should work with GNU, Intel, PGI
-    "/std:c++14"  # this should work with MSVC
+    "-std=c++17"  # this should work with GNU, Intel, PGI
+    "/std:c++17"  # this should work with MSVC
   )
-  message(STATUS "Building with C++14")
+  message(STATUS "Building with C++17")
 endif()
 
 if(NOT _cxx_std_flag)
-  message(FATAL_ERROR "xtensor-blas needs a C++14-compliant compiler.")
+  message(FATAL_ERROR "xtensor needs a C++17-compliant compiler.")
 endif()
 
 OPTION(XTENSOR_ENABLE_WERROR "Turn on -Werror" OFF)
@@ -223,11 +211,6 @@ if(nlohmann_json_FOUND)
     list(APPEND XTENSOR_TESTS test_xexpression_holder.cpp)
 endif()
 
-# remove xinfo tests for compilers < GCC 5
-if(("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") AND (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5))
-    list(REMOVE_ITEM XTENSOR_TESTS test_xinfo.cpp)
-endif()
-
 # Add files for npy tests
 set(XNPY_FILES
     bool