diff --git a/libs/datastructures/CMakeLists.txt b/libs/datastructures/CMakeLists.txt
index f68621e81d10..b95ed852e91d 100644
--- a/libs/datastructures/CMakeLists.txt
+++ b/libs/datastructures/CMakeLists.txt
@@ -6,12 +6,24 @@
 
 cmake_minimum_required(VERSION 3.3.2 FATAL_ERROR)
 
+# Compatibility with using Boost.FileSystem, introduced in V1.4.0
+hpx_option(HPX_DATASTRUCTURES_WITH_ADAPT_STD_TUPLE
+  BOOL "Enable compatibility of hpx::util::tuple with std::tuple. (default: ON)"
+  ON ADVANCED CATEGORY "Modules")
+
+if(HPX_DATASTRUCTURES_WITH_ADAPT_STD_TUPLE)
+  hpx_add_config_define_namespace(
+    DEFINE HPX_DATASTRUCTURES_HAVE_ADAPT_STD_TUPLE
+    NAMESPACE DATASTRUCTURES)
+endif()
+
 set(datastructures_headers
   hpx/datastructures/any.hpp
   hpx/datastructures/tuple.hpp
   hpx/datastructures/optional.hpp
   hpx/datastructures/detail/pack.hpp
   hpx/traits/supports_streaming_with_any.hpp
+  hpx/traits/is_tuple_like.hpp
 )
 
 set(datastructures_compat_headers
@@ -41,3 +53,7 @@ add_hpx_module(datastructures
     hpx_type_support
   CMAKE_SUBDIRS examples tests
 )
+
+if(HPX_DATASTRUCTURES_WITH_ADAPT_STD_TUPLE)
+  hpx_info("    Adapted hpx::util::tuple to be usable with std::tuple")
+endif()
diff --git a/libs/datastructures/include/hpx/datastructures/tuple.hpp b/libs/datastructures/include/hpx/datastructures/tuple.hpp
index d2e5b0d45013..a32dc44687aa 100644
--- a/libs/datastructures/include/hpx/datastructures/tuple.hpp
+++ b/libs/datastructures/include/hpx/datastructures/tuple.hpp
@@ -10,6 +10,7 @@
 #define HPX_UTIL_TUPLE_HPP
 
 #include <hpx/config.hpp>
+#include <hpx/datastructures/config/defines.hpp>
 #include <hpx/datastructures/detail/pack.hpp>
 #include <hpx/type_support/decay.hpp>
 
@@ -18,6 +19,7 @@
 #include <algorithm>
 #include <array>
 #include <cstddef>    // for size_t
+#include <tuple>
 #include <type_traits>
 #include <utility>
 
@@ -26,7 +28,13 @@
 #pragma warning(disable : 4520)    // multiple default constructors specified
 #endif
 
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wmismatched-tags"
+#endif
+
 namespace hpx { namespace util {
+
     template <typename... Ts>
     class tuple;
 
@@ -36,27 +44,59 @@ namespace hpx { namespace util {
     template <std::size_t I, typename T>
     struct tuple_element;    // undefined
 
-    template <std::size_t I, typename Tuple>
-    HPX_CONSTEXPR HPX_HOST_DEVICE HPX_FORCEINLINE
-        typename tuple_element<I, Tuple>::type&
-        get(Tuple& t) noexcept;
+    // Hide implementations of get<> inside an internal namespace to be able to
+    // import those into the namespace std below without pulling in all of
+    // hpx::util.
+    namespace adl_barrier {
+
+        template <std::size_t I, typename Tuple>
+        HPX_CONSTEXPR HPX_HOST_DEVICE HPX_FORCEINLINE
+            typename tuple_element<I, Tuple>::type&
+            get(Tuple& t) noexcept;
+
+        template <std::size_t I, typename Tuple>
+        HPX_CONSTEXPR HPX_HOST_DEVICE HPX_FORCEINLINE
+            typename tuple_element<I, Tuple>::type const&
+            get(Tuple const& t) noexcept;
+
+        template <std::size_t I, typename Tuple>
+        HPX_CONSTEXPR HPX_HOST_DEVICE HPX_FORCEINLINE
+            typename tuple_element<I, Tuple>::type&&
+            get(Tuple&& t) noexcept;
+
+        template <std::size_t I, typename Tuple>
+        HPX_CONSTEXPR HPX_HOST_DEVICE HPX_FORCEINLINE
+            typename tuple_element<I, Tuple>::type const&&
+            get(Tuple const&& t) noexcept;
+    }    // namespace adl_barrier
+
+    using hpx::util::adl_barrier::get;
+}}    // namespace hpx::util
 
-    template <std::size_t I, typename Tuple>
-    HPX_CONSTEXPR HPX_HOST_DEVICE HPX_FORCEINLINE
-        typename tuple_element<I, Tuple>::type const&
-        get(Tuple const& t) noexcept;
+#if defined(HPX_DATASTRUCTURES_HAVE_ADAPT_STD_TUPLE)
+// Adapt hpx::util::tuple to be useable with std::tuple
+namespace std {
 
-    template <std::size_t I, typename Tuple>
-    HPX_CONSTEXPR HPX_HOST_DEVICE HPX_FORCEINLINE
-        typename tuple_element<I, Tuple>::type&&
-        get(Tuple&& t) noexcept;
+    template <typename... Ts>
+    struct tuple_size<hpx::util::tuple<Ts...>>
+      : public hpx::util::tuple_size<hpx::util::tuple<Ts...>>
+    {
+    };
 
-    template <std::size_t I, typename Tuple>
-    HPX_CONSTEXPR HPX_HOST_DEVICE HPX_FORCEINLINE
-        typename tuple_element<I, Tuple>::type const&&
-        get(Tuple const&& t) noexcept;
+    template <std::size_t I, typename... Ts>
+    struct tuple_element<I, hpx::util::tuple<Ts...>>
+      : public hpx::util::tuple_element<I, hpx::util::tuple<Ts...>>
+    {
+    };
+
+    using hpx::util::adl_barrier::get;
+}    // namespace std
+#endif
+
+namespace hpx { namespace util {
 
     namespace detail {
+
         ///////////////////////////////////////////////////////////////////////
         template <std::size_t I, typename T, typename Enable = void>
         struct tuple_member    //-V690
@@ -163,8 +203,8 @@ namespace hpx { namespace util {
         struct are_tuples_compatible_impl<detail::pack_c<std::size_t, Is...>,
             tuple<Ts...>, UTuple>
         {
-            typedef char (&no_type)[1];
-            typedef char (&yes_type)[2];
+            using no_type = char (&)[1];
+            using yes_type = char (&)[2];
 
             static no_type call(...);
             static yes_type call(Ts...);
@@ -173,7 +213,7 @@ namespace hpx { namespace util {
                 sizeof(call(util::get<Is>(std::declval<UTuple>())...)    //-V510
                     ) == sizeof(yes_type);
 
-            typedef std::integral_constant<bool, value> type;
+            using type = std::integral_constant<bool, value>;
         };
 
         template <typename TTuple, typename UTuple, typename Enable = void>
@@ -307,6 +347,32 @@ namespace hpx { namespace util {
                     typename detail::at_index<I, Ts...>::type> const&>(*this)
                     .value();
             }
+
+#if defined(HPX_DATASTRUCTURES_HAVE_ADAPT_STD_TUPLE)
+            HPX_HOST_DEVICE
+            operator std::tuple<Ts...>() const&
+            {
+                return std::make_tuple(get<Is>()...);
+            }
+
+            HPX_HOST_DEVICE
+            operator std::tuple<Ts...>() &&
+            {
+                return std::make_tuple(std::move(get<Is>())...);
+            }
+
+            HPX_HOST_DEVICE
+            operator std::tuple<Ts...>() &
+            {
+                return std::make_tuple(get<Is>()...);
+            }
+
+            HPX_HOST_DEVICE
+            operator std::tuple<Ts...>() const&&
+            {
+                return std::make_tuple(std::move(get<Is>())...);
+            }
+#endif
         };
 
         ///////////////////////////////////////////////////////////////////////
@@ -333,12 +399,12 @@ namespace hpx { namespace util {
         // tuple(const tuple& u) = default;
         // Initializes each element of *this with the corresponding element
         // of u.
-        HPX_CONSTEXPR HPX_HOST_DEVICE tuple(tuple const& /*other*/) {}
+        HPX_CONSTEXPR HPX_HOST_DEVICE tuple(tuple const& /*other*/) = default;
 
         // tuple(tuple&& u) = default;
         // For all i, initializes the ith element of *this with
         // std::forward<Ti>(get<i>(u)).
-        HPX_CONSTEXPR HPX_HOST_DEVICE tuple(tuple&& /*other*/) {}
+        HPX_CONSTEXPR HPX_HOST_DEVICE tuple(tuple&& /*other*/) = default;
 
         // 20.4.2.2, tuple assignment
 
@@ -362,6 +428,13 @@ namespace hpx { namespace util {
         // Calls swap for each element in *this and its corresponding element
         // in rhs.
         HPX_HOST_DEVICE void swap(tuple& /*other*/) noexcept {}
+
+#if defined(HPX_DATASTRUCTURES_HAVE_ADAPT_STD_TUPLE)
+        operator std::tuple<>() const
+        {
+            return std::tuple<>();
+        }
+#endif
     };
 
     template <typename... Ts>
@@ -503,6 +576,28 @@ namespace hpx { namespace util {
         {
             _impl.swap(other._impl);
         }
+
+#if defined(HPX_DATASTRUCTURES_HAVE_ADAPT_STD_TUPLE)
+        operator std::tuple<Ts...>() const&
+        {
+            return _impl;
+        }
+
+        operator std::tuple<Ts...>() &
+        {
+            return _impl;
+        }
+
+        operator std::tuple<Ts...>() &&
+        {
+            return _impl;
+        }
+
+        operator std::tuple<Ts...>() const&&
+        {
+            return _impl;
+        }
+#endif
     };
 
     // 20.4.2.5, tuple helper classes
@@ -553,6 +648,13 @@ namespace hpx { namespace util {
     {
     };
 
+#if defined(HPX_DATASTRUCTURES_HAVE_ADAPT_STD_TUPLE)
+    template <typename... Ts>
+    struct tuple_size<std::tuple<Ts...>> : std::tuple_size<std::tuple<Ts...>>
+    {
+    };
+#endif
+
     // template <size_t I, class Tuple>
     // class tuple_element
     template <std::size_t I, typename T>
@@ -581,7 +683,7 @@ namespace hpx { namespace util {
     template <std::size_t I, typename... Ts>
     struct tuple_element<I, tuple<Ts...>>
     {
-        typedef typename detail::at_index<I, Ts...>::type type;
+        using type = typename detail::at_index<I, Ts...>::type;
 
         static HPX_CONSTEXPR HPX_HOST_DEVICE HPX_FORCEINLINE type& get(
             tuple<Ts...>& tuple) noexcept
@@ -599,7 +701,7 @@ namespace hpx { namespace util {
     template <typename T0, typename T1>
     struct tuple_element<0, std::pair<T0, T1>>
     {
-        typedef T0 type;
+        using type = T0;
 
         static HPX_CONSTEXPR HPX_HOST_DEVICE HPX_FORCEINLINE type& get(
             std::pair<T0, T1>& tuple) noexcept
@@ -617,7 +719,7 @@ namespace hpx { namespace util {
     template <typename T0, typename T1>
     struct tuple_element<1, std::pair<T0, T1>>
     {
-        typedef T1 type;
+        using type = T1;
 
         static HPX_CONSTEXPR HPX_HOST_DEVICE HPX_FORCEINLINE type& get(
             std::pair<T0, T1>& tuple) noexcept
@@ -635,7 +737,7 @@ namespace hpx { namespace util {
     template <std::size_t I, typename Type, std::size_t Size>
     struct tuple_element<I, boost::array<Type, Size>>
     {
-        typedef Type type;
+        using type = Type;
 
         static HPX_CONSTEXPR HPX_HOST_DEVICE HPX_FORCEINLINE type& get(
             boost::array<Type, Size>& tuple) noexcept
@@ -653,7 +755,7 @@ namespace hpx { namespace util {
     template <std::size_t I, typename Type, std::size_t Size>
     struct tuple_element<I, std::array<Type, Size>>
     {
-        typedef Type type;
+        using type = Type;
 
         static HPX_CONSTEXPR HPX_HOST_DEVICE HPX_FORCEINLINE type& get(
             std::array<Type, Size>& tuple) noexcept
@@ -668,53 +770,87 @@ namespace hpx { namespace util {
         }
     };
 
-    // 20.4.2.6, element access
-
-    // template <size_t I, class... Types>
-    // constexpr typename tuple_element<I, tuple<Types...> >::type&
-    // get(tuple<Types...>& t) noexcept;
-    template <std::size_t I, typename Tuple>
-    HPX_CONSTEXPR HPX_HOST_DEVICE HPX_FORCEINLINE
-        typename tuple_element<I, Tuple>::type&
-        get(Tuple& t) noexcept
+#if defined(HPX_DATASTRUCTURES_HAVE_ADAPT_STD_TUPLE)
+    template <std::size_t I, typename... Ts>
+    struct tuple_element<I, std::tuple<Ts...>>
     {
-        return tuple_element<I, Tuple>::get(t);
-    }
+        using type = typename std::tuple_element<I, std::tuple<Ts...>>::type;
 
-    // template <size_t I, class... Types>
-    // constexpr typename tuple_element<I, tuple<Types...> >::type const&
-    // get(const tuple<Types...>& t) noexcept;
-    template <std::size_t I, typename Tuple>
-    HPX_CONSTEXPR HPX_HOST_DEVICE HPX_FORCEINLINE
-        typename tuple_element<I, Tuple>::type const&
-        get(Tuple const& t) noexcept
-    {
-        return tuple_element<I, Tuple>::get(t);
-    }
+        static HPX_CONSTEXPR HPX_HOST_DEVICE HPX_FORCEINLINE type& get(
+            std::tuple<Ts...>& tuple) noexcept
+        {
+            return std::get<I>(tuple);
+        }
 
-    // template <size_t I, class... Types>
-    // constexpr typename tuple_element<I, tuple<Types...> >::type&&
-    // get(tuple<Types...>&& t) noexcept;
-    template <std::size_t I, typename Tuple>
-    HPX_CONSTEXPR HPX_HOST_DEVICE HPX_FORCEINLINE
-        typename tuple_element<I, Tuple>::type&&
-        get(Tuple&& t) noexcept
-    {
-        return std::forward<typename tuple_element<I, Tuple>::type>(
-            util::get<I>(t));
-    }
+        static HPX_CONSTEXPR HPX_HOST_DEVICE HPX_FORCEINLINE type const& get(
+            std::tuple<Ts...> const& tuple) noexcept
+        {
+            return std::get<I>(tuple);
+        }
 
-    // template <size_t I, class... Types>
-    // constexpr typename tuple_element<I, tuple<Types...> >::type const&&
-    // get(const tuple<Types...>&& t) noexcept;
-    template <std::size_t I, typename Tuple>
-    HPX_CONSTEXPR HPX_HOST_DEVICE HPX_FORCEINLINE
-        typename tuple_element<I, Tuple>::type const&&
-        get(Tuple const&& t) noexcept
-    {
-        return std::forward<typename tuple_element<I, Tuple>::type const>(
-            util::get<I>(t));
-    }
+        static HPX_CONSTEXPR HPX_HOST_DEVICE HPX_FORCEINLINE type&& get(
+            std::tuple<Ts...>&& tuple) noexcept
+        {
+            return std::get<I>(std::move(tuple));
+        }
+
+        static HPX_CONSTEXPR HPX_HOST_DEVICE HPX_FORCEINLINE type const&& get(
+            std::tuple<Ts...> const&& tuple) noexcept
+        {
+            return std::get<I>(std::move(tuple));
+        }
+    };
+#endif
+
+    // 20.4.2.6, element access
+    namespace adl_barrier {
+
+        // template <size_t I, class... Types>
+        // constexpr typename tuple_element<I, tuple<Types...> >::type&
+        // get(tuple<Types...>& t) noexcept;
+        template <std::size_t I, typename Tuple>
+        HPX_CONSTEXPR HPX_HOST_DEVICE HPX_FORCEINLINE
+            typename tuple_element<I, Tuple>::type&
+            get(Tuple& t) noexcept
+        {
+            return tuple_element<I, Tuple>::get(t);
+        }
+
+        // template <size_t I, class... Types>
+        // constexpr typename tuple_element<I, tuple<Types...> >::type const&
+        // get(const tuple<Types...>& t) noexcept;
+        template <std::size_t I, typename Tuple>
+        HPX_CONSTEXPR HPX_HOST_DEVICE HPX_FORCEINLINE
+            typename tuple_element<I, Tuple>::type const&
+            get(Tuple const& t) noexcept
+        {
+            return tuple_element<I, Tuple>::get(t);
+        }
+
+        // template <size_t I, class... Types>
+        // constexpr typename tuple_element<I, tuple<Types...> >::type&&
+        // get(tuple<Types...>&& t) noexcept;
+        template <std::size_t I, typename Tuple>
+        HPX_CONSTEXPR HPX_HOST_DEVICE HPX_FORCEINLINE
+            typename tuple_element<I, Tuple>::type&&
+            get(Tuple&& t) noexcept
+        {
+            return std::forward<typename tuple_element<I, Tuple>::type>(
+                util::get<I>(t));
+        }
+
+        // template <size_t I, class... Types>
+        // constexpr typename tuple_element<I, tuple<Types...> >::type const&&
+        // get(const tuple<Types...>&& t) noexcept;
+        template <std::size_t I, typename Tuple>
+        HPX_CONSTEXPR HPX_HOST_DEVICE HPX_FORCEINLINE
+            typename tuple_element<I, Tuple>::type const&&
+            get(Tuple const&& t) noexcept
+        {
+            return std::forward<typename tuple_element<I, Tuple>::type const>(
+                util::get<I>(t));
+        }
+    }    // namespace adl_barrier
 
     // 20.4.2.4, tuple creation functions
     detail::ignore_type const ignore = {};
@@ -754,6 +890,7 @@ namespace hpx { namespace util {
     //template <class... Tuples>
     //constexpr tuple<Ctypes ...> tuple_cat(Tuples&&...);
     namespace detail {
+
         /// Deduces to the overall size of all given tuples
         template <std::size_t Size, typename Tuples>
         struct tuple_cat_size_impl;
@@ -800,9 +937,8 @@ namespace hpx { namespace util {
           : tuple_cat_element<I - tuple_size<Head>::value,
                 detail::pack<Tail...>>
         {
-            typedef tuple_cat_element<I - tuple_size<Head>::value,
-                detail::pack<Tail...>>
-                base_type;
+            using base_type = tuple_cat_element<I - tuple_size<Head>::value,
+                detail::pack<Tail...>>;
 
             template <typename THead, typename... TTail>
             static HPX_CONSTEXPR HPX_HOST_DEVICE HPX_FORCEINLINE auto get(
@@ -1018,4 +1154,8 @@ namespace hpx { namespace util {
 #pragma warning(pop)
 #endif
 
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+
 #endif
diff --git a/hpx/traits/is_tuple_like.hpp b/libs/datastructures/include/hpx/traits/is_tuple_like.hpp
similarity index 67%
rename from hpx/traits/is_tuple_like.hpp
rename to libs/datastructures/include/hpx/traits/is_tuple_like.hpp
index 77a12cdb8236..75a8af15ee9a 100644
--- a/hpx/traits/is_tuple_like.hpp
+++ b/libs/datastructures/include/hpx/traits/is_tuple_like.hpp
@@ -9,31 +9,31 @@
 
 #include <type_traits>
 
-#include <hpx/type_support/always_void.hpp>
 #include <hpx/datastructures/tuple.hpp>
+#include <hpx/type_support/always_void.hpp>
 
-namespace hpx { namespace traits
-{
-    namespace detail
-    {
+namespace hpx { namespace traits {
+    namespace detail {
         template <typename T, typename Enable = void>
-        struct is_tuple_like_impl
-          : std::false_type
-        {};
+        struct is_tuple_like_impl : std::false_type
+        {
+        };
 
         template <typename T>
-        struct is_tuple_like_impl<T, typename util::always_void<
-            decltype(util::tuple_size<T>::value)>::type
-        > : std::true_type
-        {};
-    }
+        struct is_tuple_like_impl<T,
+            typename util::always_void<decltype(
+                util::tuple_size<T>::value)>::type> : std::true_type
+        {
+        };
+    }    // namespace detail
 
     /// Deduces to a true type if the given parameter T
     /// has a specific tuple like size.
     template <typename T>
     struct is_tuple_like
       : detail::is_tuple_like_impl<typename std::remove_cv<T>::type>
-    {};
-}}
+    {
+    };
+}}    // namespace hpx::traits
 
 #endif /*HPX_TRAITS_IS_TUPLE_LIKE_HPP*/
diff --git a/libs/datastructures/tests/unit/any.cpp b/libs/datastructures/tests/unit/any.cpp
index b578f1cc5c4b..34a3625de9c5 100644
--- a/libs/datastructures/tests/unit/any.cpp
+++ b/libs/datastructures/tests/unit/any.cpp
@@ -7,11 +7,8 @@
 ////////////////////////////////////////////////////////////////////////////////
 
 #include <hpx/datastructures/any.hpp>
-#include <hpx/hpx_init.hpp>
 #include <hpx/testing.hpp>
 
-#include <hpx/util/storage/tuple.hpp>
-
 #include <iostream>
 #include <sstream>
 #include <string>
@@ -24,11 +21,8 @@ using hpx::util::any_cast;
 using hpx::util::any_nonser;
 using hpx::util::streamable_any_nonser;
 
-using hpx::finalize;
-using hpx::init;
-
 ///////////////////////////////////////////////////////////////////////////////
-int hpx_main()
+int main()
 {
     {
         streamable_any_nonser any1(big_object(30, 40));
@@ -134,13 +128,5 @@ int hpx_main()
         }
     }
 
-    finalize();
     return hpx::util::report_errors();
 }
-
-///////////////////////////////////////////////////////////////////////////////
-int main(int argc, char* argv[])
-{
-    // Initialize and run HPX
-    return init(argc, argv);
-}
diff --git a/libs/datastructures/tests/unit/small_big_object.hpp b/libs/datastructures/tests/unit/small_big_object.hpp
index 93555b4ad1aa..13c425b46a30 100644
--- a/libs/datastructures/tests/unit/small_big_object.hpp
+++ b/libs/datastructures/tests/unit/small_big_object.hpp
@@ -9,8 +9,6 @@
 #ifndef HPX_SMALL_BIG_OBJECT_HPP
 #define HPX_SMALL_BIG_OBJECT_HPP
 
-#include <hpx/runtime/serialization/serialize.hpp>
-
 #include <cstdint>
 #include <iostream>
 
@@ -22,8 +20,7 @@ struct small_object
 private:
     std::uint64_t x_;
 
-    friend class hpx::serialization::access;
-
+public:
     template <typename Archive>
     void serialize(Archive& ar, unsigned const)
     {
@@ -130,8 +127,7 @@ struct big_object
     std::uint64_t x_;
     std::uint64_t y_;
 
-    friend class hpx::serialization::access;
-
+public:
     template <typename Archive>
     void serialize(Archive& ar, unsigned const)
     {
diff --git a/libs/datastructures/tests/unit/tuple.cpp b/libs/datastructures/tests/unit/tuple.cpp
index bed34963a507..9875bcfb53ba 100644
--- a/libs/datastructures/tests/unit/tuple.cpp
+++ b/libs/datastructures/tests/unit/tuple.cpp
@@ -21,7 +21,6 @@
 // clang-format on
 
 #include <hpx/config.hpp>
-#include <hpx/hpx_init.hpp>
 #include <hpx/datastructures/tuple.hpp>
 #include <hpx/testing.hpp>
 
@@ -537,6 +536,48 @@ void tuple_swap_test()
     HPX_TEST(j == 1);
 }
 
+void tuple_std_test()
+{
+#if defined(HPX_DATASTRUCTURES_HAVE_ADAPT_STD_TUPLE)
+    hpx::util::tuple<int, float, double> t1(1, 2.0f, 3.0);
+    std::tuple<int, float, double> t2 = t1;
+    hpx::util::tuple<int, float, double> t3 = t2;
+    HPX_TEST(std::get<0>(t1) == 1);
+    HPX_TEST(std::get<0>(t2) == 1);
+    HPX_TEST(std::get<0>(t3) == 1);
+
+    HPX_TEST(hpx::util::get<0>(t1) == 1);
+    HPX_TEST(hpx::util::get<0>(t2) == 1);
+    HPX_TEST(hpx::util::get<0>(t3) == 1);
+
+    HPX_TEST(std::get<1>(t1) == 2.0f);
+    HPX_TEST(std::get<1>(t2) == 2.0f);
+    HPX_TEST(std::get<1>(t3) == 2.0f);
+
+    HPX_TEST(hpx::util::get<1>(t1) == 2.0f);
+    HPX_TEST(hpx::util::get<1>(t2) == 2.0f);
+    HPX_TEST(hpx::util::get<1>(t3) == 2.0f);
+
+    HPX_TEST(std::get<2>(t1) == 3.0);
+    HPX_TEST(std::get<2>(t2) == 3.0);
+    HPX_TEST(std::get<2>(t3) == 3.0);
+
+    HPX_TEST(hpx::util::get<2>(t1) == 3.0);
+    HPX_TEST(hpx::util::get<2>(t2) == 3.0);
+    HPX_TEST(hpx::util::get<2>(t3) == 3.0);
+#endif
+}
+
+void tuple_structured_binding_test()
+{
+#if defined(HPX_HAVE_CXX17_STRUCTURED_BINDINGS)
+    auto [a1, a2] = hpx::util::make_tuple(1, '2');
+
+    HPX_TEST_EQ(a1, 1);
+    HPX_TEST_EQ(a2, '2');
+#endif
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 int main(int argc, char* argv[])
 {
@@ -553,6 +594,7 @@ int main(int argc, char* argv[])
         const_tuple_test();
         tuple_length_test();
         tuple_swap_test();
+        tuple_structured_binding_test();
     }
 
     return hpx::util::report_errors();
diff --git a/libs/filesystem/CMakeLists.txt b/libs/filesystem/CMakeLists.txt
index bafc00f330e2..60ed0b5cb732 100644
--- a/libs/filesystem/CMakeLists.txt
+++ b/libs/filesystem/CMakeLists.txt
@@ -14,7 +14,7 @@ endif()
 # Compatibility with using Boost.FileSystem, introduced in V1.4.0
 hpx_option(HPX_FILESYSTEM_WITH_BOOST_FILESYSTEM_COMPATIBILITY
   BOOL "Enable Boost.FileSystem compatibility. (default: ${__filesystem_compatibility_default})"
-  ON ADVANCED CATEGORY "Modules")
+  ${__filesystem_compatibility_default} ADVANCED CATEGORY "Modules")
 
 set(__boost_filesystem)
 if(HPX_FILESYSTEM_WITH_BOOST_FILESYSTEM_COMPATIBILITY)