diff --git a/libs/core/algorithms/include/hpx/algorithms/traits/is_pair.hpp b/libs/core/algorithms/include/hpx/algorithms/traits/is_pair.hpp
index 3272051bb22e..c2cdb7f63d99 100644
--- a/libs/core/algorithms/include/hpx/algorithms/traits/is_pair.hpp
+++ b/libs/core/algorithms/include/hpx/algorithms/traits/is_pair.hpp
@@ -15,6 +15,6 @@ namespace hpx::traits {
     HPX_CXX_CORE_EXPORT template <typename T>
     inline constexpr bool is_pair_v = false;
 
-    HPX_CXX_CORE_EXPORT template <typename T1, typename T2>
+    template <typename T1, typename T2>
     inline constexpr bool is_pair_v<std::pair<T1, T2>> = true;
 }    // namespace hpx::traits
diff --git a/libs/core/algorithms/include/hpx/algorithms/traits/pointer_category.hpp b/libs/core/algorithms/include/hpx/algorithms/traits/pointer_category.hpp
index 40ce683993fd..989aaf62261e 100644
--- a/libs/core/algorithms/include/hpx/algorithms/traits/pointer_category.hpp
+++ b/libs/core/algorithms/include/hpx/algorithms/traits/pointer_category.hpp
@@ -41,7 +41,7 @@ namespace hpx::traits {
             using type = std::underlying_type_t<T>;
         };
 
-        HPX_CXX_CORE_EXPORT template <typename T>
+        template <typename T>
         struct unwrap_enum<T, false>
         {
             using type = T;
@@ -69,7 +69,7 @@ namespace hpx::traits {
         };
 
         // every type is layout-compatible with itself
-        HPX_CXX_CORE_EXPORT template <typename T>
+        template <typename T>
         struct pointer_category_helper<T, T>
         {
             using type = std::conditional_t<std::is_trivially_copyable_v<T>,
@@ -77,19 +77,19 @@ namespace hpx::traits {
         };
 
         // pointers are layout compatible
-        HPX_CXX_CORE_EXPORT template <typename T>
+        template <typename T>
         struct pointer_category_helper<T*, T const*>
         {
             using type = trivially_copyable_pointer_tag;
         };
 
-        HPX_CXX_CORE_EXPORT template <typename T>
+        template <typename T>
         struct pointer_category_helper<T*, T volatile*>
         {
             using type = trivially_copyable_pointer_tag;
         };
 
-        HPX_CXX_CORE_EXPORT template <typename T>
+        template <typename T>
         struct pointer_category_helper<T*, T const volatile*>
         {
             using type = trivially_copyable_pointer_tag;
@@ -116,7 +116,7 @@ namespace hpx::traits {
                 general_pointer_tag>;
         };
 
-        HPX_CXX_CORE_EXPORT template <typename Source, typename Dest>
+        template <typename Source, typename Dest>
         struct pointer_move_category<Source, Dest, false>
         {
             using type = general_pointer_tag;
@@ -134,7 +134,7 @@ namespace hpx::traits {
                 general_pointer_tag>;
         };
 
-        HPX_CXX_CORE_EXPORT template <typename Source, typename Dest>
+        template <typename Source, typename Dest>
         struct pointer_copy_category<Source, Dest, false>
         {
             using type = general_pointer_tag;
@@ -150,7 +150,7 @@ namespace hpx::traits {
                 relocatable_pointer_tag, general_pointer_tag>;
         };
 
-        HPX_CXX_CORE_EXPORT template <typename Source, typename Dest>
+        template <typename Source, typename Dest>
         struct pointer_relocate_category<Source, Dest, false>
         {
             using type = general_pointer_tag;
diff --git a/libs/core/algorithms/include/hpx/algorithms/traits/projected.hpp b/libs/core/algorithms/include/hpx/algorithms/traits/projected.hpp
index 0ef3f4537429..4e992c10dd76 100644
--- a/libs/core/algorithms/include/hpx/algorithms/traits/projected.hpp
+++ b/libs/core/algorithms/include/hpx/algorithms/traits/projected.hpp
@@ -28,7 +28,7 @@ namespace hpx::traits {
 
     // For segmented iterators, we consider the local_raw_iterator instead of
     // the given one.
-    HPX_CXX_CORE_EXPORT template <typename Iterator>
+    template <typename Iterator>
     struct projected_iterator<Iterator,
         std::enable_if_t<is_segmented_iterator_v<Iterator>>>
     {
@@ -39,7 +39,7 @@ namespace hpx::traits {
             local_iterator>::local_raw_iterator;
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Iterator>
+    template <typename Iterator>
     struct projected_iterator<Iterator,
         std::void_t<typename std::decay_t<Iterator>::proxy_type>>
     {
@@ -59,7 +59,7 @@ namespace hpx::parallel::traits {
             typename Enable = void>
         struct projected_result_of;
 
-        HPX_CXX_CORE_EXPORT template <typename Proj, typename Iter>
+        template <typename Proj, typename Iter>
         struct projected_result_of<Proj, Iter,
             std::enable_if_t<hpx::traits::is_iterator_v<Iter>>>
           : hpx::util::invoke_result<Proj, hpx::traits::iter_reference_t<Iter>>
@@ -92,7 +92,7 @@ namespace hpx::parallel::traits {
             typename Enable = void>
         struct projected_result_of_vector_pack;
 
-        HPX_CXX_CORE_EXPORT template <typename Projected>
+        template <typename Projected>
         struct projected_result_of_vector_pack<Projected,
             std::void_t<typename Projected::iterator_type>>
           : projected_result_of_vector_pack_<typename Projected::projector_type,
@@ -123,7 +123,7 @@ namespace hpx::parallel::traits {
         // void
 
         // clang-format off
-        HPX_CXX_CORE_EXPORT template <typename Proj, typename Iter>
+        template <typename Proj, typename Iter>
         struct is_projected<Proj, Iter,
             std::enable_if_t<
                 hpx::traits::is_iterator_v<Iter> &&
@@ -142,7 +142,7 @@ namespace hpx::parallel::traits {
         {
         };
 
-        HPX_CXX_CORE_EXPORT template <typename Projected>
+        template <typename Projected>
         struct is_projected_indirect<Projected,
             std::void_t<typename Projected::projector_type>>
           : detail::is_projected<typename Projected::projector_type,
@@ -180,7 +180,7 @@ namespace hpx::parallel::traits {
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Projected>
+    template <typename Projected>
     struct is_projected_zip_iterator<Projected,
         std::void_t<typename Projected::iterator_type>>
       : hpx::traits::is_zip_iterator<typename Projected::iterator_type>
@@ -201,8 +201,7 @@ namespace hpx::parallel::traits {
         {
         };
 
-        HPX_CXX_CORE_EXPORT template <typename ExPolicy, typename F,
-            typename... Projected>
+        template <typename ExPolicy, typename F, typename... Projected>
         struct is_indirect_callable<ExPolicy, F, hpx::util::pack<Projected...>,
             std::enable_if_t<
                 hpx::util::all_of_v<is_projected_indirect<Projected>...> &&
@@ -218,8 +217,7 @@ namespace hpx::parallel::traits {
         // Vector pack execution policies used with zip-iterators require
         // special handling because zip_iterator<>::reference is not a real
         // reference type.
-        HPX_CXX_CORE_EXPORT template <typename ExPolicy, typename F,
-            typename... Projected>
+        template <typename ExPolicy, typename F, typename... Projected>
         struct is_indirect_callable<ExPolicy, F, hpx::util::pack<Projected...>,
             std::enable_if_t<
                 hpx::util::all_of_v<is_projected_indirect<Projected>...> &&
diff --git a/libs/core/algorithms/include/hpx/algorithms/traits/projected_range.hpp b/libs/core/algorithms/include/hpx/algorithms/traits/projected_range.hpp
index dc4550dce90a..27ccfffb1cd6 100644
--- a/libs/core/algorithms/include/hpx/algorithms/traits/projected_range.hpp
+++ b/libs/core/algorithms/include/hpx/algorithms/traits/projected_range.hpp
@@ -21,7 +21,7 @@ namespace hpx::parallel::traits {
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Proj, typename Rng>
+    template <typename Proj, typename Rng>
     struct projected_range_result_of<Proj, Rng,
         std::enable_if_t<std::ranges::range<Rng>>>
       : detail::projected_result_of<std::decay_t<Proj>,
@@ -36,7 +36,7 @@ namespace hpx::parallel::traits {
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Proj, typename Rng>
+    template <typename Proj, typename Rng>
     struct is_projected_range<Proj, Rng,
         std::enable_if_t<std::ranges::range<Rng>>>
       : detail::is_projected<std::decay_t<Proj>, std::ranges::iterator_t<Rng>>
@@ -54,7 +54,7 @@ namespace hpx::parallel::traits {
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Proj, typename Rng>
+    template <typename Proj, typename Rng>
     struct projected_range<Proj, Rng, std::enable_if_t<std::ranges::range<Rng>>>
     {
         using projector_type = std::decay_t<Proj>;
diff --git a/libs/core/algorithms/include/hpx/parallel/algorithms/copy.hpp b/libs/core/algorithms/include/hpx/parallel/algorithms/copy.hpp
index dc0071d214a2..203f92dfdd6c 100644
--- a/libs/core/algorithms/include/hpx/parallel/algorithms/copy.hpp
+++ b/libs/core/algorithms/include/hpx/parallel/algorithms/copy.hpp
@@ -439,7 +439,7 @@ namespace hpx::parallel {
             typename Enable = void>
         struct copy_iter;
 
-        HPX_CXX_CORE_EXPORT template <typename FwdIter1, typename FwdIter2>
+        template <typename FwdIter1, typename FwdIter2>
         struct copy_iter<FwdIter1, FwdIter2,
             std::enable_if_t<
                 iterators_are_segmented<FwdIter1, FwdIter2>::value>>
@@ -451,7 +451,7 @@ namespace hpx::parallel {
         {
         };
 
-        HPX_CXX_CORE_EXPORT template <typename FwdIter1, typename FwdIter2>
+        template <typename FwdIter1, typename FwdIter2>
         struct copy_iter<FwdIter1, FwdIter2,
             std::enable_if_t<
                 iterators_are_not_segmented<FwdIter1, FwdIter2>::value>>
diff --git a/libs/core/algorithms/include/hpx/parallel/algorithms/detail/dispatch.hpp b/libs/core/algorithms/include/hpx/parallel/algorithms/detail/dispatch.hpp
index e6941755a28f..dfdd20ad739b 100644
--- a/libs/core/algorithms/include/hpx/parallel/algorithms/detail/dispatch.hpp
+++ b/libs/core/algorithms/include/hpx/parallel/algorithms/detail/dispatch.hpp
@@ -35,7 +35,7 @@ namespace hpx::parallel::detail {
             Result>::local_raw_iterator;
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Result1, typename Result2>
+    template <typename Result1, typename Result2>
     struct local_algorithm_result<util::in_out_result<Result1, Result2>>
     {
         using type1 = typename hpx::traits::segmented_local_iterator_traits<
@@ -46,7 +46,7 @@ namespace hpx::parallel::detail {
         using type = util::in_out_result<type1, type2>;
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Result>
+    template <typename Result>
     struct local_algorithm_result<util::min_max_result<Result>>
     {
         using type1 = typename hpx::traits::segmented_local_iterator_traits<
@@ -55,8 +55,7 @@ namespace hpx::parallel::detail {
         using type = util::min_max_result<type1>;
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Result1, typename Result2,
-        typename Result3>
+    template <typename Result1, typename Result2, typename Result3>
     struct local_algorithm_result<
         util::in_in_out_result<Result1, Result2, Result3>>
     {
diff --git a/libs/core/algorithms/include/hpx/parallel/algorithms/for_each.hpp b/libs/core/algorithms/include/hpx/parallel/algorithms/for_each.hpp
index 963d27626f07..482222c1e9d3 100644
--- a/libs/core/algorithms/include/hpx/parallel/algorithms/for_each.hpp
+++ b/libs/core/algorithms/include/hpx/parallel/algorithms/for_each.hpp
@@ -327,7 +327,7 @@ namespace hpx::parallel {
             }
         };
 
-        HPX_CXX_CORE_EXPORT template <typename ExPolicy, typename F>
+        template <typename ExPolicy, typename F>
         struct for_each_iteration<ExPolicy, F, hpx::identity>
         {
             using execution_policy_type = std::decay_t<ExPolicy>;
diff --git a/libs/core/algorithms/include/hpx/parallel/algorithms/for_loop.hpp b/libs/core/algorithms/include/hpx/parallel/algorithms/for_loop.hpp
index 871178aaf950..90ae90f01351 100644
--- a/libs/core/algorithms/include/hpx/parallel/algorithms/for_loop.hpp
+++ b/libs/core/algorithms/include/hpx/parallel/algorithms/for_loop.hpp
@@ -811,8 +811,7 @@ namespace hpx::parallel {
             typename S = void, typename Tuple = hpx::tuple<>>
         struct part_iterations;
 
-        HPX_CXX_CORE_EXPORT template <typename ExPolicy, typename F, typename S,
-            typename... Ts>
+        template <typename ExPolicy, typename F, typename S, typename... Ts>
         struct part_iterations<ExPolicy, F, S, hpx::tuple<Ts...>>
         {
             using fun_type = std::decay_t<F>;
@@ -915,7 +914,7 @@ namespace hpx::parallel {
             }
         };
 
-        HPX_CXX_CORE_EXPORT template <typename ExPolicy, typename F, typename S>
+        template <typename ExPolicy, typename F, typename S>
         struct part_iterations<ExPolicy, F, S, hpx::tuple<>>
         {
             using fun_type = std::decay_t<F>;
@@ -1016,8 +1015,7 @@ namespace hpx::parallel {
             }
         };
 
-        HPX_CXX_CORE_EXPORT template <typename ExPolicy, typename F,
-            typename... Ts>
+        template <typename ExPolicy, typename F, typename... Ts>
         struct part_iterations<ExPolicy, F, void, hpx::tuple<Ts...>>
         {
             using fun_type = std::decay_t<F>;
@@ -1097,7 +1095,7 @@ namespace hpx::parallel {
             }
         };
 
-        HPX_CXX_CORE_EXPORT template <typename ExPolicy, typename F>
+        template <typename ExPolicy, typename F>
         struct part_iterations<ExPolicy, F, void, hpx::tuple<>>
         {
             using fun_type = std::decay_t<F>;
diff --git a/libs/core/algorithms/include/hpx/parallel/algorithms/for_loop_induction.hpp b/libs/core/algorithms/include/hpx/parallel/algorithms/for_loop_induction.hpp
index e0ec1c358485..d76d9194889a 100644
--- a/libs/core/algorithms/include/hpx/parallel/algorithms/for_loop_induction.hpp
+++ b/libs/core/algorithms/include/hpx/parallel/algorithms/for_loop_induction.hpp
@@ -58,7 +58,7 @@ namespace hpx::parallel::detail {
         T curr_;
     };
 
-    HPX_CXX_CORE_EXPORT template <typename T>
+    template <typename T>
     struct induction_helper<T&>
     {
         explicit constexpr induction_helper(T& var) noexcept
@@ -138,7 +138,7 @@ namespace hpx::parallel::detail {
         std::size_t stride_;
     };
 
-    HPX_CXX_CORE_EXPORT template <typename T>
+    template <typename T>
     struct induction_stride_helper<T&>
     {
         constexpr induction_stride_helper(T& var, std::size_t stride) noexcept
diff --git a/libs/core/algorithms/include/hpx/parallel/algorithms/move.hpp b/libs/core/algorithms/include/hpx/parallel/algorithms/move.hpp
index 97e5af73feb7..aca83bf0d179 100644
--- a/libs/core/algorithms/include/hpx/parallel/algorithms/move.hpp
+++ b/libs/core/algorithms/include/hpx/parallel/algorithms/move.hpp
@@ -185,7 +185,7 @@ namespace hpx::parallel {
             typename Enable = void>
         struct move;
 
-        HPX_CXX_CORE_EXPORT template <typename FwdIter1, typename FwdIter2>
+        template <typename FwdIter1, typename FwdIter2>
         struct move<FwdIter1, FwdIter2,
             std::enable_if_t<
                 iterators_are_segmented<FwdIter1, FwdIter2>::value>>
@@ -197,7 +197,7 @@ namespace hpx::parallel {
         {
         };
 
-        HPX_CXX_CORE_EXPORT template <typename FwdIter1, typename FwdIter2>
+        template <typename FwdIter1, typename FwdIter2>
         struct move<FwdIter1, FwdIter2,
             std::enable_if_t<
                 iterators_are_not_segmented<FwdIter1, FwdIter2>::value>>
diff --git a/libs/core/algorithms/include/hpx/parallel/algorithms/shift_right.hpp b/libs/core/algorithms/include/hpx/parallel/algorithms/shift_right.hpp
index a32f2d0bf0de..da5e981c6f1a 100644
--- a/libs/core/algorithms/include/hpx/parallel/algorithms/shift_right.hpp
+++ b/libs/core/algorithms/include/hpx/parallel/algorithms/shift_right.hpp
@@ -180,7 +180,7 @@ namespace hpx::parallel {
         HPX_CXX_CORE_EXPORT template <typename I, typename Tag, typename = void>
         inline constexpr bool is_category = false;
 
-        HPX_CXX_CORE_EXPORT template <typename I, typename Tag>
+        template <typename I, typename Tag>
         inline constexpr bool is_category<I, Tag,
             std::enable_if_t<
                 std::is_convertible_v<iterator_category_t<I>, Tag>>> = true;
@@ -321,8 +321,7 @@ namespace hpx {
                 std::is_integral_v<Size>
             )
         // clang-format on
-        friend typename hpx::parallel::util::detail::algorithm_result<ExPolicy,
-            FwdIter>::type
+        friend parallel::util::detail::algorithm_result_t<ExPolicy, FwdIter>
         tag_fallback_invoke(shift_right_t, ExPolicy&& policy, FwdIter first,
             FwdIter last, Size n)
         {
diff --git a/libs/core/algorithms/include/hpx/parallel/algorithms/transform.hpp b/libs/core/algorithms/include/hpx/parallel/algorithms/transform.hpp
index f83178bb24ce..349cba1a4a80 100644
--- a/libs/core/algorithms/include/hpx/parallel/algorithms/transform.hpp
+++ b/libs/core/algorithms/include/hpx/parallel/algorithms/transform.hpp
@@ -332,7 +332,7 @@ namespace hpx::parallel {
             }
         };
 
-        HPX_CXX_CORE_EXPORT template <typename F>
+        template <typename F>
         struct transform_projected<F, hpx::identity>
         {
             std::decay_t<F> f_{};
@@ -407,7 +407,7 @@ namespace hpx::parallel {
             }
         };
 
-        HPX_CXX_CORE_EXPORT template <typename ExPolicy, typename F>
+        template <typename ExPolicy, typename F>
         struct transform_iteration<ExPolicy, F, hpx::identity>
         {
             using execution_policy_type = std::decay_t<ExPolicy>;
@@ -631,7 +631,7 @@ namespace hpx::parallel {
             }
         };
 
-        HPX_CXX_CORE_EXPORT template <typename ExPolicy, typename F>
+        template <typename ExPolicy, typename F>
         struct transform_binary_iteration<ExPolicy, F, hpx::identity,
             hpx::identity>
         {
diff --git a/libs/core/algorithms/include/hpx/parallel/container_algorithms/contains.hpp b/libs/core/algorithms/include/hpx/parallel/container_algorithms/contains.hpp
index ba227e97cf98..77faf6359778 100644
--- a/libs/core/algorithms/include/hpx/parallel/container_algorithms/contains.hpp
+++ b/libs/core/algorithms/include/hpx/parallel/container_algorithms/contains.hpp
@@ -86,7 +86,7 @@ namespace hpx::parallel::detail {
         typename Enable = void>
     struct contains_subrange_helper;
 
-    HPX_CXX_CORE_EXPORT template <typename ExPolicy, typename T>
+    template <typename ExPolicy, typename T>
     struct contains_subrange_helper<ExPolicy, T,
         std::enable_if_t<!hpx::is_async_execution_policy_v<ExPolicy>>>
     {
@@ -96,7 +96,7 @@ namespace hpx::parallel::detail {
         }
     };
 
-    HPX_CXX_CORE_EXPORT template <typename ExPolicy, typename T>
+    template <typename ExPolicy, typename T>
     struct contains_subrange_helper<ExPolicy, T,
         std::enable_if_t<hpx::is_async_execution_policy_v<ExPolicy>>>
     {
@@ -200,8 +200,7 @@ namespace hpx::ranges {
                 typename std::iterator_traits<Iterator>::value_type>
             )
         // clang-format on
-        friend typename parallel::util::detail::algorithm_result<ExPolicy,
-            bool>::type
+        friend parallel::util::detail::algorithm_result_t<ExPolicy, bool>
         tag_fallback_invoke(hpx::ranges::contains_t, ExPolicy&& policy,
             Iterator first, Sentinel last, T const& val, Proj&& proj = Proj())
         {
@@ -225,8 +224,7 @@ namespace hpx::ranges {
                 hpx::parallel::traits::is_projected_range_v<Proj, Rng>
             )
         // clang-format on
-        friend typename parallel::util::detail::algorithm_result<ExPolicy,
-            bool>::type
+        friend parallel::util::detail::algorithm_result_t<ExPolicy, bool>
         tag_fallback_invoke(hpx::ranges::contains_t, ExPolicy&& policy,
             Rng&& rng, T const& t, Proj proj = Proj())
         {
@@ -318,8 +316,7 @@ namespace hpx::ranges {
                     typename std::iterator_traits<FwdIter2>::value_type>
             )
         // clang-format on
-        friend typename parallel::util::detail::algorithm_result<ExPolicy,
-            bool>::type
+        friend parallel::util::detail::algorithm_result_t<ExPolicy, bool>
         tag_fallback_invoke(hpx::ranges::contains_subrange_t, ExPolicy&& policy,
             FwdIter1 first1, Sent1 last1, FwdIter2 first2, Sent2 last2,
             Pred pred = Pred(), Proj1&& proj1 = Proj1(),
@@ -352,8 +349,7 @@ namespace hpx::ranges {
                 >
             )
         // clang-format on
-        friend typename parallel::util::detail::algorithm_result<ExPolicy,
-            bool>::type
+        friend parallel::util::detail::algorithm_result_t<ExPolicy, bool>
         tag_fallback_invoke(hpx::ranges::contains_subrange_t, ExPolicy&& policy,
             Rng1&& rng1, Rng2&& rng2, Pred pred = Pred(), Proj1 proj1 = Proj1(),
             Proj2 proj2 = Proj2())
diff --git a/libs/core/algorithms/include/hpx/parallel/datapar/iterator_helpers.hpp b/libs/core/algorithms/include/hpx/parallel/datapar/iterator_helpers.hpp
index 3e7b92496e12..e7aae8915c59 100644
--- a/libs/core/algorithms/include/hpx/parallel/datapar/iterator_helpers.hpp
+++ b/libs/core/algorithms/include/hpx/parallel/datapar/iterator_helpers.hpp
@@ -31,7 +31,7 @@ namespace hpx::parallel::util::detail {
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename... Ts>
+    template <typename... Ts>
     struct is_lvalue_ref<hpx::tuple<Ts...>>
       : hpx::util::all_of<std::is_lvalue_reference<Ts>...>
     {
@@ -105,7 +105,7 @@ namespace hpx::parallel::util::detail {
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Iter>
+    template <typename Iter>
     struct iterator_datapar_compatible<Iter,
         std::enable_if_t<std::random_access_iterator<Iter>>>
       : iterator_datapar_compatible_impl<std::decay_t<Iter>>::type
@@ -201,7 +201,7 @@ namespace hpx::parallel::util::detail {
         }
     };
 
-    HPX_CXX_CORE_EXPORT template <typename I, bool IsConst>
+    template <typename I, bool IsConst>
     struct datapar_loop_step<I, IsConst,
         std::enable_if_t<std::is_integral_v<I>>>
     {
diff --git a/libs/core/algorithms/include/hpx/parallel/datapar/loop.hpp b/libs/core/algorithms/include/hpx/parallel/datapar/loop.hpp
index 8f253657a13f..b1cee7e99050 100644
--- a/libs/core/algorithms/include/hpx/parallel/datapar/loop.hpp
+++ b/libs/core/algorithms/include/hpx/parallel/datapar/loop.hpp
@@ -272,7 +272,7 @@ namespace hpx::parallel::util {
             typename Enable = void>
         struct datapar_loop_n;
 
-        HPX_CXX_CORE_EXPORT template <typename Iterator, bool IsConst>
+        template <typename Iterator, bool IsConst>
         struct datapar_loop_n<Iterator, IsConst,
             std::enable_if_t<hpx::traits::is_iterator_v<Iterator>>>
         {
@@ -362,7 +362,7 @@ namespace hpx::parallel::util {
             }
         };
 
-        HPX_CXX_CORE_EXPORT template <typename I, bool IsConst>
+        template <typename I, bool IsConst>
         struct datapar_loop_n<I, IsConst,
             std::enable_if_t<std::is_integral_v<I>>>
         {
diff --git a/libs/core/algorithms/include/hpx/parallel/datapar/zip_iterator.hpp b/libs/core/algorithms/include/hpx/parallel/datapar/zip_iterator.hpp
index d5c35b0283a4..7fba34576218 100644
--- a/libs/core/algorithms/include/hpx/parallel/datapar/zip_iterator.hpp
+++ b/libs/core/algorithms/include/hpx/parallel/datapar/zip_iterator.hpp
@@ -23,7 +23,7 @@
 namespace hpx::parallel::util::detail {
 
     ///////////////////////////////////////////////////////////////////////////
-    HPX_CXX_CORE_EXPORT template <typename... Iter>
+    template <typename... Iter>
     struct is_data_aligned_impl<hpx::util::zip_iterator<Iter...>>
     {
         template <std::size_t... Is>
@@ -43,7 +43,7 @@ namespace hpx::parallel::util::detail {
     };
 
     ///////////////////////////////////////////////////////////////////////////
-    HPX_CXX_CORE_EXPORT template <typename... Iter>
+    template <typename... Iter>
     struct iterator_datapar_compatible_impl<hpx::util::zip_iterator<Iter...>>
       : hpx::util::all_of<std::is_arithmetic<
             typename std::iterator_traits<Iter>::value_type>...>
@@ -84,7 +84,7 @@ namespace hpx::parallel::traits {
         }
     }    // namespace detail
 
-    HPX_CXX_CORE_EXPORT template <typename... Vector, typename ValueType>
+    template <typename... Vector, typename ValueType>
     struct vector_pack_load<hpx::tuple<Vector...>, ValueType>
     {
         using value_type = hpx::tuple<Vector...>;
@@ -136,7 +136,7 @@ namespace hpx::parallel::traits {
         }
     }    // namespace detail
 
-    HPX_CXX_CORE_EXPORT template <typename... Vector, typename ValueType>
+    template <typename... Vector, typename ValueType>
     struct vector_pack_store<hpx::tuple<Vector...>, ValueType>
     {
         template <typename V, typename... Iter>
diff --git a/libs/core/algorithms/include/hpx/parallel/util/compare_projected.hpp b/libs/core/algorithms/include/hpx/parallel/util/compare_projected.hpp
index f71b8bd16d63..ad4ece7ebd50 100644
--- a/libs/core/algorithms/include/hpx/parallel/util/compare_projected.hpp
+++ b/libs/core/algorithms/include/hpx/parallel/util/compare_projected.hpp
@@ -20,7 +20,7 @@ namespace hpx::parallel::util {
     struct compare_projected;
 
     ///////////////////////////////////////////////////////////////////////////
-    HPX_CXX_CORE_EXPORT template <typename Compare, typename Proj>
+    template <typename Compare, typename Proj>
     struct compare_projected<Compare, Proj>
     {
         template <typename Compare_, typename Proj_>
@@ -41,7 +41,7 @@ namespace hpx::parallel::util {
         Proj proj_;
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Compare>
+    template <typename Compare>
     struct compare_projected<Compare, hpx::identity>
     {
         template <typename Compare_>
@@ -60,8 +60,7 @@ namespace hpx::parallel::util {
     };
 
     ///////////////////////////////////////////////////////////////////////////
-    HPX_CXX_CORE_EXPORT template <typename Compare, typename Proj1,
-        typename Proj2>
+    template <typename Compare, typename Proj1, typename Proj2>
     struct compare_projected<Compare, Proj1, Proj2>
     {
         template <typename Compare_, typename Proj1_, typename Proj2_>
@@ -85,7 +84,7 @@ namespace hpx::parallel::util {
         Proj2 proj2_;
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Compare, typename Proj2>
+    template <typename Compare, typename Proj2>
     struct compare_projected<Compare, hpx::identity, Proj2>
     {
         template <typename Compare_, typename Proj2_>
@@ -107,7 +106,7 @@ namespace hpx::parallel::util {
         Proj2 proj2_;
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Compare, typename Proj1>
+    template <typename Compare, typename Proj1>
     struct compare_projected<Compare, Proj1, hpx::identity>
     {
         template <typename Compare_, typename Proj1_>
@@ -129,7 +128,7 @@ namespace hpx::parallel::util {
         Proj1 proj1_;
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Compare>
+    template <typename Compare>
     struct compare_projected<Compare, hpx::identity, hpx::identity>
     {
         template <typename Compare_>
diff --git a/libs/core/algorithms/include/hpx/parallel/util/detail/algorithm_result.hpp b/libs/core/algorithms/include/hpx/parallel/util/detail/algorithm_result.hpp
index cb69dded85db..5a933eab6426 100644
--- a/libs/core/algorithms/include/hpx/parallel/util/detail/algorithm_result.hpp
+++ b/libs/core/algorithms/include/hpx/parallel/util/detail/algorithm_result.hpp
@@ -28,7 +28,7 @@ namespace hpx::parallel::util::detail {
         typename Enable = void>
     struct algorithm_result_impl;
 
-    HPX_CXX_CORE_EXPORT template <typename ExPolicy, typename T>
+    template <typename ExPolicy, typename T>
     struct algorithm_result_impl<ExPolicy, T,
         std::enable_if_t<!hpx::is_async_execution_policy_v<ExPolicy> &&
             !hpx::execution_policy_has_scheduler_executor_v<ExPolicy>>>
@@ -56,7 +56,7 @@ namespace hpx::parallel::util::detail {
         }
     };
 
-    HPX_CXX_CORE_EXPORT template <typename ExPolicy>
+    template <typename ExPolicy>
     struct algorithm_result_impl<ExPolicy, void,
         std::enable_if_t<!hpx::is_async_execution_policy_v<ExPolicy> &&
             !hpx::execution_policy_has_scheduler_executor_v<ExPolicy>>>
@@ -81,7 +81,7 @@ namespace hpx::parallel::util::detail {
         }
     };
 
-    HPX_CXX_CORE_EXPORT template <typename ExPolicy, typename T>
+    template <typename ExPolicy, typename T>
     struct algorithm_result_impl<ExPolicy, T,
         std::enable_if_t<hpx::is_async_execution_policy_v<ExPolicy> &&
             !hpx::execution_policy_has_scheduler_executor_v<ExPolicy>>>
@@ -101,7 +101,7 @@ namespace hpx::parallel::util::detail {
         }
     };
 
-    HPX_CXX_CORE_EXPORT template <typename ExPolicy>
+    template <typename ExPolicy>
     struct algorithm_result_impl<ExPolicy, void,
         std::enable_if_t<hpx::is_async_execution_policy_v<ExPolicy> &&
             !hpx::execution_policy_has_scheduler_executor_v<ExPolicy>>>
@@ -132,7 +132,7 @@ namespace hpx::parallel::util::detail {
         }
     };
 
-    HPX_CXX_CORE_EXPORT template <typename ExPolicy, typename T>
+    template <typename ExPolicy, typename T>
     struct algorithm_result_impl<ExPolicy, T,
         std::enable_if_t<!hpx::is_async_execution_policy_v<ExPolicy> &&
             hpx::execution_policy_has_scheduler_executor_v<ExPolicy>>>
@@ -172,7 +172,7 @@ namespace hpx::parallel::util::detail {
         }
     };
 
-    HPX_CXX_CORE_EXPORT template <typename ExPolicy>
+    template <typename ExPolicy>
     struct algorithm_result_impl<ExPolicy, void,
         std::enable_if_t<!hpx::is_async_execution_policy_v<ExPolicy> &&
             hpx::execution_policy_has_scheduler_executor_v<ExPolicy>>>
@@ -194,7 +194,7 @@ namespace hpx::parallel::util::detail {
         }
     };
 
-    HPX_CXX_CORE_EXPORT template <typename ExPolicy, typename T>
+    template <typename ExPolicy, typename T>
     struct algorithm_result_impl<ExPolicy, T,
         std::enable_if_t<hpx::is_async_execution_policy_v<ExPolicy> &&
             hpx::execution_policy_has_scheduler_executor_v<ExPolicy>>>
@@ -218,7 +218,7 @@ namespace hpx::parallel::util::detail {
         }
     };
 
-    HPX_CXX_CORE_EXPORT template <typename ExPolicy>
+    template <typename ExPolicy>
     struct algorithm_result_impl<ExPolicy, void,
         std::enable_if_t<hpx::is_async_execution_policy_v<ExPolicy> &&
             hpx::execution_policy_has_scheduler_executor_v<ExPolicy>>>
diff --git a/libs/core/algorithms/include/hpx/parallel/util/detail/chunk_size_iterator.hpp b/libs/core/algorithms/include/hpx/parallel/util/detail/chunk_size_iterator.hpp
index d4053f655e92..c6ee30cc1a03 100644
--- a/libs/core/algorithms/include/hpx/parallel/util/detail/chunk_size_iterator.hpp
+++ b/libs/core/algorithms/include/hpx/parallel/util/detail/chunk_size_iterator.hpp
@@ -26,28 +26,28 @@ namespace hpx::parallel::util::detail {
     HPX_CXX_CORE_EXPORT template <typename IterOrR, typename Enable = void>
     struct chunk_size_iterator_category;
 
-    HPX_CXX_CORE_EXPORT template <typename IterOrR>
+    template <typename IterOrR>
     struct chunk_size_iterator_category<IterOrR,
         std::enable_if_t<std::is_integral_v<IterOrR>>>
     {
         using type = std::random_access_iterator_tag;
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Iterator>
+    template <typename Iterator>
     struct chunk_size_iterator_category<Iterator,
         std::enable_if_t<hpx::traits::is_iterator_v<Iterator>>>
     {
         using type = hpx::traits::iter_category_t<Iterator>;
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Range>
+    template <typename Range>
     struct chunk_size_iterator_category<Range,
         std::enable_if_t<std::ranges::range<Range>>>
     {
         using type = hpx::traits::range_category_t<Range>;
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Range>
+    template <typename Range>
     struct chunk_size_iterator_category<Range,
         std::enable_if_t<hpx::traits::is_range_generator_v<Range>>>
     {
@@ -61,7 +61,7 @@ namespace hpx::parallel::util::detail {
     HPX_CXX_CORE_EXPORT template <typename IterOrR, typename Enable = void>
     struct iterator_type;
 
-    HPX_CXX_CORE_EXPORT template <typename T>
+    template <typename T>
     struct iterator_type<T,
         std::enable_if_t<std::is_integral_v<T> ||
             hpx::traits::is_range_generator_v<T>>>
@@ -69,14 +69,14 @@ namespace hpx::parallel::util::detail {
         using type = T;
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Iterator>
+    template <typename Iterator>
     struct iterator_type<Iterator,
         std::enable_if_t<hpx::traits::is_iterator_v<Iterator>>>
     {
         using type = Iterator;
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Range>
+    template <typename Range>
     struct iterator_type<Range, std::enable_if_t<std::ranges::range<Range>>>
     {
         using type = std::ranges::iterator_t<Range>;
diff --git a/libs/core/algorithms/include/hpx/parallel/util/detail/handle_local_exceptions.hpp b/libs/core/algorithms/include/hpx/parallel/util/detail/handle_local_exceptions.hpp
index 4214ced46611..40c80e8ccce1 100644
--- a/libs/core/algorithms/include/hpx/parallel/util/detail/handle_local_exceptions.hpp
+++ b/libs/core/algorithms/include/hpx/parallel/util/detail/handle_local_exceptions.hpp
@@ -771,7 +771,7 @@ namespace hpx::parallel::util::detail {
     };
 
     // unseq et.al. need to terminate on exceptions
-    HPX_CXX_CORE_EXPORT template <typename ExPolicy>
+    template <typename ExPolicy>
     struct handle_local_exceptions<ExPolicy,
         std::enable_if_t<hpx::is_unsequenced_execution_policy_v<ExPolicy>>>
       : terminate_on_local_exceptions
diff --git a/libs/core/algorithms/include/hpx/parallel/util/detail/select_partitioner.hpp b/libs/core/algorithms/include/hpx/parallel/util/detail/select_partitioner.hpp
index 88d27f5d7162..58298dd04fdc 100644
--- a/libs/core/algorithms/include/hpx/parallel/util/detail/select_partitioner.hpp
+++ b/libs/core/algorithms/include/hpx/parallel/util/detail/select_partitioner.hpp
@@ -23,8 +23,7 @@ namespace hpx::parallel::util::detail {
         using apply = Partitioner<ExPolicy, Args...>;
     };
 
-    HPX_CXX_CORE_EXPORT template <typename ExPolicy,
-        template <typename...> class Partitioner,
+    template <typename ExPolicy, template <typename...> class Partitioner,
         template <typename...> class TaskPartitioner>
     struct select_partitioner<ExPolicy, Partitioner, TaskPartitioner,
         std::enable_if_t<hpx::is_async_execution_policy_v<ExPolicy> &&
diff --git a/libs/core/algorithms/include/hpx/parallel/util/detail/sender_util.hpp b/libs/core/algorithms/include/hpx/parallel/util/detail/sender_util.hpp
index 91613cd668ec..d5f7703a12f3 100644
--- a/libs/core/algorithms/include/hpx/parallel/util/detail/sender_util.hpp
+++ b/libs/core/algorithms/include/hpx/parallel/util/detail/sender_util.hpp
@@ -41,7 +41,7 @@ namespace hpx::detail {
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Tag, typename ExPolicy>
+    template <typename Tag, typename ExPolicy>
     struct is_bound_algorithm<bound_algorithm<Tag, ExPolicy>> : std::true_type
     {
     };
diff --git a/libs/core/algorithms/include/hpx/parallel/util/invoke_projected.hpp b/libs/core/algorithms/include/hpx/parallel/util/invoke_projected.hpp
index 1085b35c34b6..5fd136dab3d8 100644
--- a/libs/core/algorithms/include/hpx/parallel/util/invoke_projected.hpp
+++ b/libs/core/algorithms/include/hpx/parallel/util/invoke_projected.hpp
@@ -51,7 +51,7 @@ namespace hpx::parallel::util {
         }
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Pred>
+    template <typename Pred>
     struct invoke_projected<Pred, hpx::identity>
     {
         using pred_type = std::decay_t<Pred>;
@@ -107,7 +107,7 @@ namespace hpx::parallel::util {
         }
     };
 
-    HPX_CXX_CORE_EXPORT template <typename F>
+    template <typename F>
     struct invoke_projected_ind<F, hpx::identity>
     {
         using pred_type = std::decay_t<F>;
diff --git a/libs/core/algorithms/include/hpx/parallel/util/prefetching.hpp b/libs/core/algorithms/include/hpx/parallel/util/prefetching.hpp
index 9a8cf1045b10..023119690710 100644
--- a/libs/core/algorithms/include/hpx/parallel/util/prefetching.hpp
+++ b/libs/core/algorithms/include/hpx/parallel/util/prefetching.hpp
@@ -462,7 +462,7 @@ namespace hpx::parallel::util {
     namespace detail {
 
         ///////////////////////////////////////////////////////////////////////
-        HPX_CXX_CORE_EXPORT template <typename Itr, typename... Ts>
+        template <typename Itr, typename... Ts>
         struct loop<prefetching::prefetching_iterator<Itr, Ts...>>
         {
             using iterator_type = prefetching::prefetching_iterator<Itr, Ts...>;
@@ -522,7 +522,7 @@ namespace hpx::parallel::util {
         };
 
         ///////////////////////////////////////////////////////////////////////
-        HPX_CXX_CORE_EXPORT template <typename Itr, typename... Ts>
+        template <typename Itr, typename... Ts>
         struct loop_ind<prefetching::prefetching_iterator<Itr, Ts...>>
         {
             using iterator_type = prefetching::prefetching_iterator<Itr, Ts...>;
diff --git a/libs/core/algorithms/include/hpx/parallel/util/transfer.hpp b/libs/core/algorithms/include/hpx/parallel/util/transfer.hpp
index f3faec0c0d26..764f3762b6f9 100644
--- a/libs/core/algorithms/include/hpx/parallel/util/transfer.hpp
+++ b/libs/core/algorithms/include/hpx/parallel/util/transfer.hpp
@@ -138,7 +138,7 @@ namespace hpx::parallel::util {
             }
         };
 
-        HPX_CXX_CORE_EXPORT template <typename Dummy>
+        template <typename Dummy>
         struct copy_helper<hpx::traits::trivially_copyable_pointer_tag, Dummy>
         {
             template <typename InIter, typename Sent, typename OutIter>
@@ -201,7 +201,7 @@ namespace hpx::parallel::util {
             }
         };
 
-        HPX_CXX_CORE_EXPORT template <typename Dummy>
+        template <typename Dummy>
         struct copy_n_helper<hpx::traits::trivially_copyable_pointer_tag, Dummy>
         {
             template <typename InIter, typename OutIter>
@@ -293,7 +293,7 @@ namespace hpx::parallel::util {
             }
         };
 
-        HPX_CXX_CORE_EXPORT template <typename Dummy>
+        template <typename Dummy>
         struct move_helper<hpx::traits::trivially_copyable_pointer_tag, Dummy>
         {
             template <typename InIter, typename Sent, typename OutIter>
@@ -349,7 +349,7 @@ namespace hpx::parallel::util {
             }
         };
 
-        HPX_CXX_CORE_EXPORT template <typename Dummy>
+        template <typename Dummy>
         struct move_n_helper<hpx::traits::trivially_copyable_pointer_tag, Dummy>
         {
             template <typename InIter, typename OutIter>
@@ -394,7 +394,7 @@ namespace hpx::parallel::util {
             }
         };
 
-        HPX_CXX_CORE_EXPORT template <typename Dummy>
+        template <typename Dummy>
         struct uninit_copy_n_helper<hpx::traits::trivially_copyable_pointer_tag,
             Dummy>
         {
@@ -454,7 +454,7 @@ namespace hpx::parallel::util {
             }
         };
 
-        HPX_CXX_CORE_EXPORT template <typename Dummy>
+        template <typename Dummy>
         struct uninit_move_n_helper<hpx::traits::trivially_copyable_pointer_tag,
             Dummy>
         {
diff --git a/libs/core/allocator_support/include/hpx/allocator_support/traits/is_allocator.hpp b/libs/core/allocator_support/include/hpx/allocator_support/traits/is_allocator.hpp
index 53248115707e..c720ffa271bc 100644
--- a/libs/core/allocator_support/include/hpx/allocator_support/traits/is_allocator.hpp
+++ b/libs/core/allocator_support/include/hpx/allocator_support/traits/is_allocator.hpp
@@ -66,7 +66,7 @@ namespace hpx::traits {
                 std::declval<T>(), std::declval<pointer>()))::value;
         };
 
-        HPX_CXX_CORE_EXPORT template <typename T>
+        template <typename T>
         struct has_deallocate<T, false>
         {
             static constexpr bool value = false;
diff --git a/libs/core/async_base/include/hpx/async_base/scheduling_properties.hpp b/libs/core/async_base/include/hpx/async_base/scheduling_properties.hpp
index 1ffa3551898d..659702fdfc9a 100644
--- a/libs/core/async_base/include/hpx/async_base/scheduling_properties.hpp
+++ b/libs/core/async_base/include/hpx/async_base/scheduling_properties.hpp
@@ -52,7 +52,7 @@ namespace hpx::execution::experimental {
     }    // namespace detail
 
     ///////////////////////////////////////////////////////////////////////////
-    HPX_CXX_CORE_EXPORT template <typename Property>
+    template <typename Property>
     struct is_scheduling_property<Property,
         std::enable_if_t<
             std::is_base_of_v<detail::property_base<Property>, Property>>>
diff --git a/libs/core/compute_local/include/hpx/compute_local/detail/get_proxy_type.hpp b/libs/core/compute_local/include/hpx/compute_local/detail/get_proxy_type.hpp
index 954acde05f35..fca8dd88d17c 100644
--- a/libs/core/compute_local/include/hpx/compute_local/detail/get_proxy_type.hpp
+++ b/libs/core/compute_local/include/hpx/compute_local/detail/get_proxy_type.hpp
@@ -20,7 +20,7 @@ namespace hpx::compute::detail {
         using type = T;
     };
 
-    HPX_CXX_CORE_EXPORT template <typename T>
+    template <typename T>
     struct get_proxy_type_impl<T,
         std::void_t<typename std::decay_t<T>::proxy_type>>
     {
diff --git a/libs/core/compute_local/include/hpx/compute_local/host/block_executor.hpp b/libs/core/compute_local/include/hpx/compute_local/host/block_executor.hpp
index 4e71e108e284..0631d94fe1ff 100644
--- a/libs/core/compute_local/include/hpx/compute_local/host/block_executor.hpp
+++ b/libs/core/compute_local/include/hpx/compute_local/host/block_executor.hpp
@@ -342,38 +342,38 @@ namespace hpx::compute::host {
 
 namespace hpx::execution::experimental {
 
-    HPX_CXX_CORE_EXPORT template <typename Executor>
+    template <typename Executor>
     struct executor_execution_category<compute::host::block_executor<Executor>>
     {
         using type = hpx::execution::parallel_execution_tag;
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Executor>
+    template <typename Executor>
     struct is_never_blocking_one_way_executor<
         compute::host::block_executor<Executor>>
       : is_never_blocking_one_way_executor<Executor>
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Executor>
+    template <typename Executor>
     struct is_one_way_executor<compute::host::block_executor<Executor>>
       : is_one_way_executor<Executor>
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Executor>
+    template <typename Executor>
     struct is_two_way_executor<compute::host::block_executor<Executor>>
       : is_two_way_executor<Executor>
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Executor>
+    template <typename Executor>
     struct is_bulk_one_way_executor<compute::host::block_executor<Executor>>
       : is_bulk_one_way_executor<Executor>
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Executor>
+    template <typename Executor>
     struct is_bulk_two_way_executor<compute::host::block_executor<Executor>>
       : is_bulk_two_way_executor<Executor>
     {
diff --git a/libs/core/compute_local/include/hpx/compute_local/traits/allocator_traits.hpp b/libs/core/compute_local/include/hpx/compute_local/traits/allocator_traits.hpp
index 47bb0b475c64..f16cc06702c6 100644
--- a/libs/core/compute_local/include/hpx/compute_local/traits/allocator_traits.hpp
+++ b/libs/core/compute_local/include/hpx/compute_local/traits/allocator_traits.hpp
@@ -32,7 +32,7 @@ namespace hpx::compute::traits {
             using type = compute::traits::access_target<compute::host::target>;
         };
 
-        HPX_CXX_CORE_EXPORT template <typename Allocator>
+        template <typename Allocator>
         struct get_target_traits<Allocator,
             std::void_t<typename Allocator::target_type>>
         {
@@ -51,7 +51,7 @@ namespace hpx::compute::traits {
         };
 #endif
 
-        HPX_CXX_CORE_EXPORT template <typename Allocator>
+        template <typename Allocator>
         struct get_reference_type<Allocator,
             std::void_t<typename Allocator::reference>>
         {
@@ -70,7 +70,7 @@ namespace hpx::compute::traits {
         };
 #endif
 
-        HPX_CXX_CORE_EXPORT template <typename Allocator>
+        template <typename Allocator>
         struct get_const_reference_type<Allocator,
             std::void_t<typename Allocator::const_reference>>
         {
@@ -84,7 +84,7 @@ namespace hpx::compute::traits {
             using type = compute::host::target;
         };
 
-        HPX_CXX_CORE_EXPORT template <typename Allocator>
+        template <typename Allocator>
         struct target_helper_result<Allocator,
             std::void_t<typename Allocator::target_type>>
         {
diff --git a/libs/core/compute_local/include/hpx/compute_local/vector.hpp b/libs/core/compute_local/include/hpx/compute_local/vector.hpp
index a18c70b7c1c8..acea8c0443c6 100644
--- a/libs/core/compute_local/include/hpx/compute_local/vector.hpp
+++ b/libs/core/compute_local/include/hpx/compute_local/vector.hpp
@@ -526,8 +526,11 @@ namespace hpx::compute {
     }
 }    // namespace hpx::compute
 
-HPX_CXX_CORE_EXPORT template <typename T, typename Allocator>
-struct hpx::traits::is_contiguous_iterator<
-    hpx::compute::detail::iterator<T, Allocator>> : std::true_type
-{
-};
+namespace hpx::traits {
+
+    template <typename T, typename Allocator>
+    struct is_contiguous_iterator<hpx::compute::detail::iterator<T, Allocator>>
+      : std::true_type
+    {
+    };
+}    // namespace hpx::traits
diff --git a/libs/core/concepts/include/hpx/concepts/has_member_xxx.hpp b/libs/core/concepts/include/hpx/concepts/has_member_xxx.hpp
index 79a72e9d680c..d4867eeec0e2 100644
--- a/libs/core/concepts/include/hpx/concepts/has_member_xxx.hpp
+++ b/libs/core/concepts/include/hpx/concepts/has_member_xxx.hpp
@@ -43,7 +43,7 @@
         {                                                                      \
         };                                                                     \
                                                                                \
-        Prefix template <typename T>                                           \
+        template <typename T>                                                  \
         struct impl<T,                                                         \
             Member_function_holder<&helper_composed<std::decay_t<T>>::Member>> \
           : std::false_type                                                    \
@@ -57,7 +57,7 @@
     {                                                                          \
     };                                                                         \
                                                                                \
-    Prefix template <typename T>                                               \
+    template <typename T>                                                      \
     struct HPX_PP_CAT(has_, Member)<T, std::enable_if_t<std::is_class_v<T>>>   \
       : HPX_PP_CAT(HPX_PP_CAT(has_, Member), _detail)::impl<T>                 \
     {                                                                          \
diff --git a/libs/core/concepts/include/hpx/concepts/has_xxx.hpp b/libs/core/concepts/include/hpx/concepts/has_xxx.hpp
index a0c28599b402..093c9dd52bd1 100644
--- a/libs/core/concepts/include/hpx/concepts/has_xxx.hpp
+++ b/libs/core/concepts/include/hpx/concepts/has_xxx.hpp
@@ -23,7 +23,7 @@
     {                                                                          \
     };                                                                         \
                                                                                \
-    Prefix template <typename T>                                               \
+    template <typename T>                                                      \
     struct HPX_PP_CAT(has_, Name)<T, std::void_t<typename T::Name>>            \
       : std::true_type                                                         \
     {                                                                          \
diff --git a/libs/core/concurrency/include/hpx/concurrency/cache_line_data.hpp b/libs/core/concurrency/include/hpx/concurrency/cache_line_data.hpp
index 38fac827a133..8b502cd69fe8 100644
--- a/libs/core/concurrency/include/hpx/concurrency/cache_line_data.hpp
+++ b/libs/core/concurrency/include/hpx/concurrency/cache_line_data.hpp
@@ -84,7 +84,7 @@ namespace hpx::util {
             sizeof(Data))];
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Data>
+    template <typename Data>
     struct cache_aligned_data<Data, false>
     {
         constexpr cache_aligned_data() noexcept(
@@ -133,7 +133,7 @@ namespace hpx::util {
             sizeof(Data))];
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Data>
+    template <typename Data>
     struct cache_aligned_data_derived<Data, false> : Data
     {
         constexpr cache_aligned_data_derived() noexcept(
diff --git a/libs/core/datastructures/include/hpx/datastructures/any.hpp b/libs/core/datastructures/include/hpx/datastructures/any.hpp
index f910903092ad..c5ac3a9a55e8 100644
--- a/libs/core/datastructures/include/hpx/datastructures/any.hpp
+++ b/libs/core/datastructures/include/hpx/datastructures/any.hpp
@@ -130,7 +130,7 @@ namespace hpx::util::detail::any {
     };
 
     ////////////////////////////////////////////////////////////////////////
-    HPX_CXX_CORE_EXPORT template <typename Char, typename Copyable>
+    template <typename Char, typename Copyable>
     struct fxn_ptr_table<void, void, Char, Copyable>
       : fxn_ptr_table<void, void, void, Copyable>
     {
@@ -158,27 +158,28 @@ namespace hpx::util::detail::any {
         struct streaming_base;
 
     // no streaming support
-    HPX_CXX_CORE_EXPORT template <typename T>
+    template <typename T>
     struct streaming_base<T, std::true_type, void, std::true_type>
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename T>
+    template <typename T>
     struct streaming_base<T, std::true_type, void, std::false_type>
     {
     };
-    HPX_CXX_CORE_EXPORT template <typename T>
+
+    template <typename T>
     struct streaming_base<T, std::false_type, void, std::true_type>
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename T>
+    template <typename T>
     struct streaming_base<T, std::false_type, void, std::false_type>
     {
     };
 
     // streaming support is enabled
-    HPX_CXX_CORE_EXPORT template <typename T, typename Char>
+    template <typename T, typename Char>
     struct streaming_base<T, std::true_type, Char, std::true_type>
     {
         template <typename Char_>
@@ -198,7 +199,7 @@ namespace hpx::util::detail::any {
         }
     };
 
-    HPX_CXX_CORE_EXPORT template <typename T, typename Char>
+    template <typename T, typename Char>
     struct streaming_base<T, std::false_type, Char, std::true_type>
     {
         template <typename Char_>
@@ -218,7 +219,7 @@ namespace hpx::util::detail::any {
         }
     };
 
-    HPX_CXX_CORE_EXPORT template <typename T, typename Small, typename Char>
+    template <typename T, typename Small, typename Char>
     struct streaming_base<T, Small, Char, std::false_type>
     {
         template <typename Char_>
@@ -459,7 +460,7 @@ namespace hpx::util::detail::any {
         typename Vtable, typename Char, typename Copyable>
     struct fxn_ptr;
 
-    HPX_CXX_CORE_EXPORT template <typename Vtable>
+    template <typename Vtable>
     struct fxn_ptr<void, void, Vtable, void, std::true_type>
       : fxn_ptr_table<void, void, void, std::true_type>
     {
@@ -482,7 +483,7 @@ namespace hpx::util::detail::any {
         }
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Vtable, typename Char>
+    template <typename Vtable, typename Char>
     struct fxn_ptr<void, void, Vtable, Char, std::true_type>
       : fxn_ptr_table<void, void, Char, std::true_type>
     {
@@ -507,7 +508,7 @@ namespace hpx::util::detail::any {
         }
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Vtable>
+    template <typename Vtable>
     struct fxn_ptr<void, void, Vtable, void, std::false_type>
       : fxn_ptr_table<void, void, void, std::false_type>
     {
@@ -528,7 +529,7 @@ namespace hpx::util::detail::any {
         }
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Vtable, typename Char>
+    template <typename Vtable, typename Char>
     struct fxn_ptr<void, void, Vtable, Char, std::false_type>
       : fxn_ptr_table<void, void, Char, std::false_type>
     {
@@ -835,7 +836,7 @@ namespace hpx::util {
 
     ////////////////////////////////////////////////////////////////////////////
     // specialization for hpx::any supporting streaming
-    HPX_CXX_CORE_EXPORT template <typename Char>    // default is char
+    template <typename Char>    // default is char
     class basic_any<void, void, Char, std::true_type>
     {
     public:
@@ -1189,7 +1190,7 @@ namespace hpx::util {
     };
 
     // specialization for unique_any supporting streaming
-    HPX_CXX_CORE_EXPORT template <typename Char>    // default is char
+    template <typename Char>    // default is char
     class basic_any<void, void, Char, std::false_type>
     {
     public:
diff --git a/libs/core/datastructures/include/hpx/datastructures/detail/dynamic_bitset.hpp b/libs/core/datastructures/include/hpx/datastructures/detail/dynamic_bitset.hpp
index 0ba315d2bd13..0b440376185d 100644
--- a/libs/core/datastructures/include/hpx/datastructures/detail/dynamic_bitset.hpp
+++ b/libs/core/datastructures/include/hpx/datastructures/detail/dynamic_bitset.hpp
@@ -2013,7 +2013,7 @@ namespace hpx::detail {
 // std::hash support
 #include <functional>
 
-HPX_CXX_CORE_EXPORT template <typename Block, typename Allocator>
+template <typename Block, typename Allocator>
 struct std::hash<::hpx::detail::dynamic_bitset<Block, Allocator>>
 {
     using argument_type = hpx::detail::dynamic_bitset<Block, Allocator>;
diff --git a/libs/core/datastructures/include/hpx/datastructures/member_pack.hpp b/libs/core/datastructures/include/hpx/datastructures/member_pack.hpp
index f8f559e918d6..a83ba835903d 100644
--- a/libs/core/datastructures/include/hpx/datastructures/member_pack.hpp
+++ b/libs/core/datastructures/include/hpx/datastructures/member_pack.hpp
@@ -111,7 +111,7 @@ namespace hpx::util {
     HPX_CXX_CORE_EXPORT template <typename Is, typename... Ts>
     struct HPX_EMPTY_BASES member_pack;
 
-    HPX_CXX_CORE_EXPORT template <std::size_t... Is, typename... Ts>
+    template <std::size_t... Is, typename... Ts>
     struct HPX_EMPTY_BASES member_pack<util::index_pack<Is...>, Ts...>
       : detail::member_leaf<Is, Ts>...
     {
diff --git a/libs/core/datastructures/include/hpx/datastructures/serialization/serializable_any.hpp b/libs/core/datastructures/include/hpx/datastructures/serialization/serializable_any.hpp
index 6851d5b1b0c9..2dbe1c8a786b 100644
--- a/libs/core/datastructures/include/hpx/datastructures/serialization/serializable_any.hpp
+++ b/libs/core/datastructures/include/hpx/datastructures/serialization/serializable_any.hpp
@@ -45,7 +45,7 @@ namespace hpx::util::detail::any {
 
     ////////////////////////////////////////////////////////////////////////////
     // serializable function pointer table
-    HPX_CXX_CORE_EXPORT template <typename IArch, typename OArch, typename Char>
+    template <typename IArch, typename OArch, typename Char>
         requires(!std::is_void_v<IArch> && !std::is_void_v<OArch>)
     struct fxn_ptr_table<IArch, OArch, Char, std::true_type>
     {
@@ -83,8 +83,7 @@ namespace hpx::util::detail::any {
     };
 
     ////////////////////////////////////////////////////////////////////////////
-    HPX_CXX_CORE_EXPORT template <typename IArch, typename OArch,
-        typename Vtable, typename Char>
+    template <typename IArch, typename OArch, typename Vtable, typename Char>
     struct fxn_ptr<IArch, OArch, Vtable, Char, std::true_type>
       : fxn_ptr_table<IArch, OArch, Char, std::true_type>
     {
@@ -134,7 +133,7 @@ namespace hpx::util::detail::any {
 namespace hpx::util {
 
     ////////////////////////////////////////////////////////////////////////////
-    HPX_CXX_CORE_EXPORT template <typename IArch, typename OArch, typename Char>
+    template <typename IArch, typename OArch, typename Char>
     class basic_any<IArch, OArch, Char, std::true_type>
     {
     public:
@@ -422,12 +421,11 @@ namespace hpx::util {
     };
 
     // explicitly instantiate the operator()()
-    HPX_CXX_CORE_EXPORT extern template HPX_CORE_EXPORT std::size_t
-    hash_any::operator()(basic_any<serialization::input_archive,
-        serialization::output_archive, char, std::true_type> const& elem) const;
+    extern template HPX_CORE_EXPORT std::size_t hash_any::operator()(
+        basic_any<serialization::input_archive, serialization::output_archive,
+            char, std::true_type> const& elem) const;
 
-    HPX_CXX_CORE_EXPORT extern template HPX_CORE_EXPORT std::size_t
-    hash_any::operator()(
+    extern template HPX_CORE_EXPORT std::size_t hash_any::operator()(
         basic_any<serialization::input_archive, serialization::output_archive,
             wchar_t, std::true_type> const& elem) const;
 }    // namespace hpx::util
diff --git a/libs/core/datastructures/include/hpx/datastructures/serialization/tuple.hpp b/libs/core/datastructures/include/hpx/datastructures/serialization/tuple.hpp
index 8fe2fbf12316..3fa26d4cc436 100644
--- a/libs/core/datastructures/include/hpx/datastructures/serialization/tuple.hpp
+++ b/libs/core/datastructures/include/hpx/datastructures/serialization/tuple.hpp
@@ -20,14 +20,14 @@
 
 namespace hpx::traits {
 
-    HPX_CXX_CORE_EXPORT template <typename... Ts>
+    template <typename... Ts>
     struct is_bitwise_serializable<::hpx::tuple<Ts...>>
       : ::hpx::util::all_of<
             hpx::traits::is_bitwise_serializable<std::remove_const_t<Ts>>...>
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename... Ts>
+    template <typename... Ts>
     struct is_not_bitwise_serializable<::hpx::tuple<Ts...>>
       : std::integral_constant<bool,
             !is_bitwise_serializable_v<::hpx::tuple<Ts...>>>
@@ -46,8 +46,7 @@ namespace hpx::util::detail {
     HPX_CXX_CORE_EXPORT template <typename Archive, typename Is, typename... Ts>
     struct save_construct_data_with_index_pack;
 
-    HPX_CXX_CORE_EXPORT template <typename Archive, std::size_t... Is,
-        typename... Ts>
+    template <typename Archive, std::size_t... Is, typename... Ts>
     struct serialize_with_index_pack<Archive, hpx::util::index_pack<Is...>,
         Ts...>
     {
@@ -65,8 +64,7 @@ namespace hpx::util::detail {
         }
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Archive, std::size_t... Is,
-        typename... Ts>
+    template <typename Archive, std::size_t... Is, typename... Ts>
     struct load_construct_data_with_index_pack<Archive,
         hpx::util::index_pack<Is...>, Ts...>
     {
@@ -113,8 +111,7 @@ namespace hpx::util::detail {
         }
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Archive, std::size_t... Is,
-        typename... Ts>
+    template <typename Archive, std::size_t... Is, typename... Ts>
     struct save_construct_data_with_index_pack<Archive,
         hpx::util::index_pack<Is...>, Ts...>
     {
diff --git a/libs/core/datastructures/include/hpx/datastructures/traits/is_tuple_like.hpp b/libs/core/datastructures/include/hpx/datastructures/traits/is_tuple_like.hpp
index 52d83f497396..ba4b621d4fb2 100644
--- a/libs/core/datastructures/include/hpx/datastructures/traits/is_tuple_like.hpp
+++ b/libs/core/datastructures/include/hpx/datastructures/traits/is_tuple_like.hpp
@@ -19,7 +19,7 @@ namespace hpx::traits {
         {
         };
 
-        HPX_CXX_CORE_EXPORT template <typename T>
+        template <typename T>
         struct is_tuple_like_impl<T,
             std::void_t<decltype(hpx::tuple_size<T>::value)>> : std::true_type
         {
diff --git a/libs/core/datastructures/include/hpx/datastructures/traits/supports_streaming_with_any.hpp b/libs/core/datastructures/include/hpx/datastructures/traits/supports_streaming_with_any.hpp
index df41f6b5747d..fd30276b3366 100644
--- a/libs/core/datastructures/include/hpx/datastructures/traits/supports_streaming_with_any.hpp
+++ b/libs/core/datastructures/include/hpx/datastructures/traits/supports_streaming_with_any.hpp
@@ -23,7 +23,7 @@ namespace hpx::traits {
     ///////////////////////////////////////////////////////////////////////////
     // Customization point for streaming with util::any, we don't want
     // serialization::serialize_buffer to be streamable
-    HPX_CXX_CORE_EXPORT template <typename T, typename Allocator>
+    template <typename T, typename Allocator>
     struct supports_streaming_with_any<
         serialization::serialize_buffer<T, Allocator>> : std::false_type
     {
diff --git a/libs/core/datastructures/include/hpx/datastructures/tuple.hpp b/libs/core/datastructures/include/hpx/datastructures/tuple.hpp
index 63fd4827edd7..5d8637af60bd 100644
--- a/libs/core/datastructures/include/hpx/datastructures/tuple.hpp
+++ b/libs/core/datastructures/include/hpx/datastructures/tuple.hpp
@@ -197,12 +197,12 @@ namespace hpx {
 // Adapt hpx::tuple to be usable with structured binding contexts
 namespace std {
 
-    HPX_CXX_CORE_EXPORT template <typename... Ts>
+    template <typename... Ts>
     struct tuple_size<hpx::tuple<Ts...>> : hpx::tuple_size<hpx::tuple<Ts...>>
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <std::size_t I, typename... Ts>
+    template <std::size_t I, typename... Ts>
     struct tuple_element<I, hpx::tuple<Ts...>>
       : hpx::tuple_element<I, hpx::tuple<Ts...>>
     {
@@ -578,41 +578,41 @@ namespace hpx {
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename T>
+    template <typename T>
     struct tuple_size<T const> : tuple_size<T>
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename T>
+    template <typename T>
     struct tuple_size<T volatile> : tuple_size<T>
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename T>
+    template <typename T>
     struct tuple_size<T const volatile> : tuple_size<T>
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename... Ts>
+    template <typename... Ts>
     struct tuple_size<tuple<Ts...>>
       : std::integral_constant<std::size_t, sizeof...(Ts)>
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename T0, typename T1>
+    template <typename T0, typename T1>
     struct tuple_size<std::pair<T0, T1>>
       : std::integral_constant<std::size_t, 2>
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Type, std::size_t Size>
+    template <typename Type, std::size_t Size>
     struct tuple_size<std::array<Type, Size>>
       : std::integral_constant<std::size_t, Size>
     {
     };
 
 #if defined(HPX_DATASTRUCTURES_HAVE_ADAPT_STD_TUPLE)
-    HPX_CXX_CORE_EXPORT template <typename... Ts>
+    template <typename... Ts>
     struct tuple_size<std::tuple<Ts...>> : std::tuple_size<std::tuple<Ts...>>
     {
     };
@@ -628,28 +628,28 @@ namespace hpx {
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <std::size_t I, typename T>
+    template <std::size_t I, typename T>
     struct tuple_element<I, T const,
         std::void_t<typename tuple_element<I, T>::type>>
       : std::add_const<typename tuple_element<I, T>::type>
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <std::size_t I, typename T>
+    template <std::size_t I, typename T>
     struct tuple_element<I, T volatile,
         std::void_t<typename tuple_element<I, T>::type>>
       : std::add_volatile<typename tuple_element<I, T>::type>
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <std::size_t I, typename T>
+    template <std::size_t I, typename T>
     struct tuple_element<I, T const volatile,
         std::void_t<typename tuple_element<I, T>::type>>
       : std::add_cv<typename tuple_element<I, T>::type>
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <std::size_t I, typename... Ts>
+    template <std::size_t I, typename... Ts>
     struct tuple_element<I, tuple<Ts...>>
     {
         using type = typename util::at_index<I, Ts...>::type;
@@ -667,7 +667,7 @@ namespace hpx {
         }
     };
 
-    HPX_CXX_CORE_EXPORT template <typename T0, typename T1>
+    template <typename T0, typename T1>
     struct tuple_element<0, std::pair<T0, T1>>
     {
         using type = T0;
@@ -685,7 +685,7 @@ namespace hpx {
         }
     };
 
-    HPX_CXX_CORE_EXPORT template <typename T0, typename T1>
+    template <typename T0, typename T1>
     struct tuple_element<1, std::pair<T0, T1>>
     {
         using type = T1;
@@ -703,8 +703,7 @@ namespace hpx {
         }
     };
 
-    HPX_CXX_CORE_EXPORT template <std::size_t I, typename Type,
-        std::size_t Size>
+    template <std::size_t I, typename Type, std::size_t Size>
     struct tuple_element<I, std::array<Type, Size>>
     {
         using type = Type;
@@ -730,7 +729,7 @@ namespace hpx {
     };
 
 #if defined(HPX_DATASTRUCTURES_HAVE_ADAPT_STD_TUPLE)
-    HPX_CXX_CORE_EXPORT template <std::size_t I, typename... Ts>
+    template <std::size_t I, typename... Ts>
     struct tuple_element<I, std::tuple<Ts...>>
     {
         using type = std::tuple_element_t<I, std::tuple<Ts...>>;
diff --git a/libs/core/errors/include/hpx/errors/exception_fwd.hpp b/libs/core/errors/include/hpx/errors/exception_fwd.hpp
index 0b12aeac2e2f..5e44a352da22 100644
--- a/libs/core/errors/include/hpx/errors/exception_fwd.hpp
+++ b/libs/core/errors/include/hpx/errors/exception_fwd.hpp
@@ -95,9 +95,9 @@ namespace hpx {
         [[nodiscard]] HPX_CORE_EXPORT std::exception_ptr
         construct_lightweight_exception(Exception const& e);
 
-        HPX_CXX_CORE_EXPORT extern template HPX_CORE_EXPORT std::exception_ptr
+        extern template HPX_CORE_EXPORT std::exception_ptr
         construct_lightweight_exception(hpx::exception_list const&);
-        HPX_CXX_CORE_EXPORT extern template HPX_CORE_EXPORT std::exception_ptr
+        extern template HPX_CORE_EXPORT std::exception_ptr
         construct_lightweight_exception(hpx::thread_interrupted const&);
     }    // namespace detail
     /// \endcond
diff --git a/libs/core/errors/include/hpx/errors/throw_exception.hpp b/libs/core/errors/include/hpx/errors/throw_exception.hpp
index 2cf1207c712c..cc7f1825bf6f 100644
--- a/libs/core/errors/include/hpx/errors/throw_exception.hpp
+++ b/libs/core/errors/include/hpx/errors/throw_exception.hpp
@@ -38,44 +38,44 @@ namespace hpx::detail {
     [[noreturn]] HPX_CORE_EXPORT void throw_exception(Exception const& e,
         std::string const& func, std::string const& file, long line);
 
-    HPX_CXX_CORE_EXPORT extern template HPX_CORE_EXPORT void throw_exception(
+    extern template HPX_CORE_EXPORT void throw_exception(
         hpx::exception const&, std::string const&, std::string const&, long);
-    HPX_CXX_CORE_EXPORT extern template HPX_CORE_EXPORT void throw_exception(
+    extern template HPX_CORE_EXPORT void throw_exception(
         std::system_error const&, std::string const&, std::string const&, long);
-    HPX_CXX_CORE_EXPORT extern template HPX_CORE_EXPORT void throw_exception(
+    extern template HPX_CORE_EXPORT void throw_exception(
         std::exception const&, std::string const&, std::string const&, long);
-    HPX_CXX_CORE_EXPORT extern template HPX_CORE_EXPORT void throw_exception(
+    extern template HPX_CORE_EXPORT void throw_exception(
         hpx::detail::std_exception const&, std::string const&,
         std::string const&, long);
-    HPX_CXX_CORE_EXPORT extern template HPX_CORE_EXPORT void throw_exception(
+    extern template HPX_CORE_EXPORT void throw_exception(
         std::bad_exception const&, std::string const&, std::string const&,
         long);
-    HPX_CXX_CORE_EXPORT extern template HPX_CORE_EXPORT void throw_exception(
+    extern template HPX_CORE_EXPORT void throw_exception(
         hpx::detail::bad_exception const&, std::string const&,
         std::string const&, long);
-    HPX_CXX_CORE_EXPORT extern template HPX_CORE_EXPORT void throw_exception(
+    extern template HPX_CORE_EXPORT void throw_exception(
         std::bad_typeid const&, std::string const&, std::string const&, long);
-    HPX_CXX_CORE_EXPORT extern template HPX_CORE_EXPORT void throw_exception(
+    extern template HPX_CORE_EXPORT void throw_exception(
         hpx::detail::bad_typeid const&, std::string const&, std::string const&,
         long);
-    HPX_CXX_CORE_EXPORT extern template HPX_CORE_EXPORT void throw_exception(
+    extern template HPX_CORE_EXPORT void throw_exception(
         std::bad_cast const&, std::string const&, std::string const&, long);
-    HPX_CXX_CORE_EXPORT extern template HPX_CORE_EXPORT void throw_exception(
+    extern template HPX_CORE_EXPORT void throw_exception(
         hpx::detail::bad_cast const&, std::string const&, std::string const&,
         long);
-    HPX_CXX_CORE_EXPORT extern template HPX_CORE_EXPORT void throw_exception(
+    extern template HPX_CORE_EXPORT void throw_exception(
         std::bad_alloc const&, std::string const&, std::string const&, long);
-    HPX_CXX_CORE_EXPORT extern template HPX_CORE_EXPORT void throw_exception(
+    extern template HPX_CORE_EXPORT void throw_exception(
         hpx::detail::bad_alloc const&, std::string const&, std::string const&,
         long);
-    HPX_CXX_CORE_EXPORT extern template HPX_CORE_EXPORT void throw_exception(
+    extern template HPX_CORE_EXPORT void throw_exception(
         std::logic_error const&, std::string const&, std::string const&, long);
-    HPX_CXX_CORE_EXPORT extern template HPX_CORE_EXPORT void throw_exception(
+    extern template HPX_CORE_EXPORT void throw_exception(
         std::runtime_error const&, std::string const&, std::string const&,
         long);
-    HPX_CXX_CORE_EXPORT extern template HPX_CORE_EXPORT void throw_exception(
+    extern template HPX_CORE_EXPORT void throw_exception(
         std::out_of_range const&, std::string const&, std::string const&, long);
-    HPX_CXX_CORE_EXPORT extern template HPX_CORE_EXPORT void throw_exception(
+    extern template HPX_CORE_EXPORT void throw_exception(
         std::invalid_argument const&, std::string const&, std::string const&,
         long);
 
@@ -96,54 +96,54 @@ namespace hpx::detail {
         std::string const& file = "<unknown>", long line = -1,
         std::string const& auxinfo = "");
 
-    HPX_CXX_CORE_EXPORT extern template HPX_CORE_EXPORT std::exception_ptr
-    get_exception(hpx::exception const&, std::string const&, std::string const&,
-        long, std::string const&);
-    HPX_CXX_CORE_EXPORT extern template HPX_CORE_EXPORT std::exception_ptr
-    get_exception(std::system_error const&, std::string const&,
-        std::string const&, long, std::string const&);
-    HPX_CXX_CORE_EXPORT extern template HPX_CORE_EXPORT std::exception_ptr
-    get_exception(std::exception const&, std::string const&, std::string const&,
-        long, std::string const&);
-    HPX_CXX_CORE_EXPORT extern template HPX_CORE_EXPORT std::exception_ptr
-    get_exception(hpx::detail::std_exception const&, std::string const&,
-        std::string const&, long, std::string const&);
-    HPX_CXX_CORE_EXPORT extern template HPX_CORE_EXPORT std::exception_ptr
-    get_exception(std::bad_exception const&, std::string const&,
-        std::string const&, long, std::string const&);
-    HPX_CXX_CORE_EXPORT extern template HPX_CORE_EXPORT std::exception_ptr
-    get_exception(hpx::detail::bad_exception const&, std::string const&,
-        std::string const&, long, std::string const&);
-    HPX_CXX_CORE_EXPORT extern template HPX_CORE_EXPORT std::exception_ptr
-    get_exception(std::bad_typeid const&, std::string const&,
+    extern template HPX_CORE_EXPORT std::exception_ptr get_exception(
+        hpx::exception const&, std::string const&, std::string const&, long,
+        std::string const&);
+    extern template HPX_CORE_EXPORT std::exception_ptr get_exception(
+        std::system_error const&, std::string const&, std::string const&, long,
+        std::string const&);
+    extern template HPX_CORE_EXPORT std::exception_ptr get_exception(
+        std::exception const&, std::string const&, std::string const&, long,
+        std::string const&);
+    extern template HPX_CORE_EXPORT std::exception_ptr get_exception(
+        hpx::detail::std_exception const&, std::string const&,
         std::string const&, long, std::string const&);
-    HPX_CXX_CORE_EXPORT extern template HPX_CORE_EXPORT std::exception_ptr
-    get_exception(hpx::detail::bad_typeid const&, std::string const&,
+    extern template HPX_CORE_EXPORT std::exception_ptr get_exception(
+        std::bad_exception const&, std::string const&, std::string const&, long,
+        std::string const&);
+    extern template HPX_CORE_EXPORT std::exception_ptr get_exception(
+        hpx::detail::bad_exception const&, std::string const&,
         std::string const&, long, std::string const&);
-    HPX_CXX_CORE_EXPORT extern template HPX_CORE_EXPORT std::exception_ptr
-    get_exception(std::bad_cast const&, std::string const&, std::string const&,
+    extern template HPX_CORE_EXPORT std::exception_ptr get_exception(
+        std::bad_typeid const&, std::string const&, std::string const&, long,
+        std::string const&);
+    extern template HPX_CORE_EXPORT std::exception_ptr get_exception(
+        hpx::detail::bad_typeid const&, std::string const&, std::string const&,
         long, std::string const&);
-    HPX_CXX_CORE_EXPORT extern template HPX_CORE_EXPORT std::exception_ptr
-    get_exception(hpx::detail::bad_cast const&, std::string const&,
-        std::string const&, long, std::string const&);
-    HPX_CXX_CORE_EXPORT extern template HPX_CORE_EXPORT std::exception_ptr
-    get_exception(std::bad_alloc const&, std::string const&, std::string const&,
+    extern template HPX_CORE_EXPORT std::exception_ptr get_exception(
+        std::bad_cast const&, std::string const&, std::string const&, long,
+        std::string const&);
+    extern template HPX_CORE_EXPORT std::exception_ptr get_exception(
+        hpx::detail::bad_cast const&, std::string const&, std::string const&,
+        long, std::string const&);
+    extern template HPX_CORE_EXPORT std::exception_ptr get_exception(
+        std::bad_alloc const&, std::string const&, std::string const&, long,
+        std::string const&);
+    extern template HPX_CORE_EXPORT std::exception_ptr get_exception(
+        hpx::detail::bad_alloc const&, std::string const&, std::string const&,
+        long, std::string const&);
+    extern template HPX_CORE_EXPORT std::exception_ptr get_exception(
+        std::logic_error const&, std::string const&, std::string const&, long,
+        std::string const&);
+    extern template HPX_CORE_EXPORT std::exception_ptr get_exception(
+        std::runtime_error const&, std::string const&, std::string const&, long,
+        std::string const&);
+    extern template HPX_CORE_EXPORT std::exception_ptr get_exception(
+        std::out_of_range const&, std::string const&, std::string const&, long,
+        std::string const&);
+    extern template HPX_CORE_EXPORT std::exception_ptr get_exception(
+        std::invalid_argument const&, std::string const&, std::string const&,
         long, std::string const&);
-    HPX_CXX_CORE_EXPORT extern template HPX_CORE_EXPORT std::exception_ptr
-    get_exception(hpx::detail::bad_alloc const&, std::string const&,
-        std::string const&, long, std::string const&);
-    HPX_CXX_CORE_EXPORT extern template HPX_CORE_EXPORT std::exception_ptr
-    get_exception(std::logic_error const&, std::string const&,
-        std::string const&, long, std::string const&);
-    HPX_CXX_CORE_EXPORT extern template HPX_CORE_EXPORT std::exception_ptr
-    get_exception(std::runtime_error const&, std::string const&,
-        std::string const&, long, std::string const&);
-    HPX_CXX_CORE_EXPORT extern template HPX_CORE_EXPORT std::exception_ptr
-    get_exception(std::out_of_range const&, std::string const&,
-        std::string const&, long, std::string const&);
-    HPX_CXX_CORE_EXPORT extern template HPX_CORE_EXPORT std::exception_ptr
-    get_exception(std::invalid_argument const&, std::string const&,
-        std::string const&, long, std::string const&);
 
     HPX_CXX_CORE_EXPORT [[nodiscard]] HPX_CORE_EXPORT std::exception_ptr
     get_exception(hpx::error errcode, std::string const& msg, throwmode mode,
diff --git a/libs/core/execution/include/hpx/execution/algorithms/as_sender.hpp b/libs/core/execution/include/hpx/execution/algorithms/as_sender.hpp
index dc4422082090..c4d56ebb0bba 100644
--- a/libs/core/execution/include/hpx/execution/algorithms/as_sender.hpp
+++ b/libs/core/execution/include/hpx/execution/algorithms/as_sender.hpp
@@ -152,7 +152,7 @@ namespace hpx::execution::experimental {
         HPX_CXX_CORE_EXPORT template <typename Future>
         struct as_sender_sender;
 
-        HPX_CXX_CORE_EXPORT template <typename T>
+        template <typename T>
         struct as_sender_sender<hpx::future<T>>
           : public as_sender_sender_base<hpx::future<T>>
         {
@@ -187,7 +187,7 @@ namespace hpx::execution::experimental {
             }
         };
 
-        HPX_CXX_CORE_EXPORT template <typename T>
+        template <typename T>
         struct as_sender_sender<hpx::shared_future<T>>
           : as_sender_sender_base<hpx::shared_future<T>>
         {
diff --git a/libs/core/execution/include/hpx/execution/algorithms/detail/is_negative.hpp b/libs/core/execution/include/hpx/execution/algorithms/detail/is_negative.hpp
index 817ea5bba07b..3fadcea750a3 100644
--- a/libs/core/execution/include/hpx/execution/algorithms/detail/is_negative.hpp
+++ b/libs/core/execution/include/hpx/execution/algorithms/detail/is_negative.hpp
@@ -17,7 +17,7 @@ namespace hpx::parallel::detail {
     struct is_negative_helper;
 
     // signed integral values may be negative
-    HPX_CXX_CORE_EXPORT template <typename T>
+    template <typename T>
     struct is_negative_helper<T, std::enable_if_t<std::is_signed_v<T>>>
     {
         HPX_HOST_DEVICE HPX_FORCEINLINE static constexpr bool call(
@@ -39,7 +39,7 @@ namespace hpx::parallel::detail {
     };
 
     // unsigned integral values are never negative
-    HPX_CXX_CORE_EXPORT template <typename T>
+    template <typename T>
     struct is_negative_helper<T, std::enable_if_t<std::is_unsigned_v<T>>>
     {
         HPX_HOST_DEVICE HPX_FORCEINLINE static constexpr bool call(
diff --git a/libs/core/execution/include/hpx/execution/algorithms/detail/partial_algorithm.hpp b/libs/core/execution/include/hpx/execution/algorithms/detail/partial_algorithm.hpp
index 2701469f9b9a..64241d40af8a 100644
--- a/libs/core/execution/include/hpx/execution/algorithms/detail/partial_algorithm.hpp
+++ b/libs/core/execution/include/hpx/execution/algorithms/detail/partial_algorithm.hpp
@@ -21,8 +21,7 @@ namespace hpx::execution::experimental::detail {
     HPX_CXX_CORE_EXPORT template <typename Tag, typename IsPack, typename... Ts>
     struct partial_algorithm_base;
 
-    HPX_CXX_CORE_EXPORT template <typename Tag, std::size_t... Is,
-        typename... Ts>
+    template <typename Tag, std::size_t... Is, typename... Ts>
     struct partial_algorithm_base<Tag, hpx::util::index_pack<Is...>, Ts...>
     {
     private:
diff --git a/libs/core/execution/include/hpx/execution/algorithms/detail/predicates.hpp b/libs/core/execution/include/hpx/execution/algorithms/detail/predicates.hpp
index 0847de404ef8..12daa28800ab 100644
--- a/libs/core/execution/include/hpx/execution/algorithms/detail/predicates.hpp
+++ b/libs/core/execution/include/hpx/execution/algorithms/detail/predicates.hpp
@@ -82,7 +82,7 @@ namespace hpx::parallel::detail {
         }
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Iterable>
+    template <typename Iterable>
     struct calculate_distance<Iterable,
         std::enable_if_t<hpx::traits::is_iterator_v<Iterable>>>
     {
@@ -142,7 +142,7 @@ namespace hpx::parallel::detail {
         }
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Iterable>
+    template <typename Iterable>
     struct calculate_next<Iterable,
         std::enable_if_t<hpx::traits::is_iterator_v<Iterable> &&
             !std::bidirectional_iterator<Iterable>>>
@@ -179,7 +179,7 @@ namespace hpx::parallel::detail {
         }
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Iterable>
+    template <typename Iterable>
     struct calculate_next<Iterable,
         std::enable_if_t<std::bidirectional_iterator<Iterable>>>
     {
diff --git a/libs/core/execution/include/hpx/execution/algorithms/detail/single_result.hpp b/libs/core/execution/include/hpx/execution/algorithms/detail/single_result.hpp
index afe3bb36cfa7..db7c250199e8 100644
--- a/libs/core/execution/include/hpx/execution/algorithms/detail/single_result.hpp
+++ b/libs/core/execution/include/hpx/execution/algorithms/detail/single_result.hpp
@@ -36,13 +36,13 @@ namespace hpx::execution::experimental::detail {
         using type = void;
     };
 
-    HPX_CXX_CORE_EXPORT template <typename T>
+    template <typename T>
     struct single_result<meta::pack<meta::pack<T>>>
     {
         using type = T;
     };
 
-    HPX_CXX_CORE_EXPORT template <typename T, typename U, typename... Ts>
+    template <typename T, typename U, typename... Ts>
     struct single_result<meta::pack<meta::pack<T, U, Ts...>>>
     {
         static_assert(sizeof(T) == 0,
@@ -50,7 +50,7 @@ namespace hpx::execution::experimental::detail {
             "(single variant with two or more types given)");
     };
 
-    HPX_CXX_CORE_EXPORT template <typename T, typename U, typename... Ts>
+    template <typename T, typename U, typename... Ts>
     struct single_result<meta::pack<T, U, Ts...>>
     {
         static_assert(sizeof(T) == 0,
@@ -82,19 +82,19 @@ namespace hpx::execution::experimental::detail {
             "expected a single variant completion_signatures<>::value_types");
     };
 
-    HPX_CXX_CORE_EXPORT template <typename T>
+    template <typename T>
     struct single_variant<util::pack<T>>
     {
         using type = T;
     };
 
-    HPX_CXX_CORE_EXPORT template <typename T>
+    template <typename T>
     struct single_variant<meta::pack<T>>
     {
         using type = T;
     };
 
-    HPX_CXX_CORE_EXPORT template <typename T>
+    template <typename T>
     struct single_variant<hpx::variant<T>>
     {
         using type = T;
@@ -111,13 +111,13 @@ namespace hpx::execution::experimental::detail {
             "expected a single variant completion_signatures<>::value_types");
     };
 
-    HPX_CXX_CORE_EXPORT template <template <typename...> typename Variants>
+    template <template <typename...> typename Variants>
     struct single_variant_tuple_size<Variants<>>
     {
         static constexpr std::size_t size = 0;
     };
 
-    HPX_CXX_CORE_EXPORT template <template <typename...> typename Variants,
+    template <template <typename...> typename Variants,
         template <typename...> typename Tuple, typename... Ts>
     struct single_variant_tuple_size<Variants<Tuple<Ts...>>>
     {
diff --git a/libs/core/execution/include/hpx/execution/algorithms/keep_future.hpp b/libs/core/execution/include/hpx/execution/algorithms/keep_future.hpp
index ae55ac68eec4..164b25868a56 100644
--- a/libs/core/execution/include/hpx/execution/algorithms/keep_future.hpp
+++ b/libs/core/execution/include/hpx/execution/algorithms/keep_future.hpp
@@ -73,7 +73,7 @@ namespace hpx::execution::experimental {
         HPX_CXX_CORE_EXPORT template <typename Future>
         struct keep_future_sender;
 
-        HPX_CXX_CORE_EXPORT template <typename T>
+        template <typename T>
         struct keep_future_sender<hpx::future<T>>
           : public keep_future_sender_base<hpx::future<T>>
         {
@@ -108,7 +108,7 @@ namespace hpx::execution::experimental {
             }
         };
 
-        HPX_CXX_CORE_EXPORT template <typename T>
+        template <typename T>
         struct keep_future_sender<hpx::shared_future<T>>
           : keep_future_sender_base<hpx::shared_future<T>>
         {
diff --git a/libs/core/execution/include/hpx/execution/detail/async_launch_policy_dispatch.hpp b/libs/core/execution/include/hpx/execution/detail/async_launch_policy_dispatch.hpp
index 7f4e78cf4486..f11e32ca34c0 100644
--- a/libs/core/execution/include/hpx/execution/detail/async_launch_policy_dispatch.hpp
+++ b/libs/core/execution/include/hpx/execution/detail/async_launch_policy_dispatch.hpp
@@ -307,7 +307,7 @@ namespace hpx::detail {
         }
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Action>
+    template <typename Action>
     struct async_launch_policy_dispatch<Action,
         std::enable_if_t<!traits::is_action_v<Action>>>
     {
diff --git a/libs/core/execution/include/hpx/execution/detail/future_exec.hpp b/libs/core/execution/include/hpx/execution/detail/future_exec.hpp
index 4c03d4c9a0c5..3527372290e7 100644
--- a/libs/core/execution/include/hpx/execution/detail/future_exec.hpp
+++ b/libs/core/execution/include/hpx/execution/detail/future_exec.hpp
@@ -46,7 +46,7 @@ namespace hpx::lcos::detail {
 
     ///////////////////////////////////////////////////////////////////////////
     // launch
-    HPX_CXX_CORE_EXPORT template <typename Future, typename Policy>
+    template <typename Future, typename Policy>
     struct future_then_dispatch<Future, Policy,
         std::enable_if_t<traits::is_launch_policy_v<Policy>>>
     {
@@ -97,7 +97,7 @@ namespace hpx::lcos::detail {
     //
     // parallel executors v2
     // threads::executor
-    HPX_CXX_CORE_EXPORT template <typename Future, typename Executor>
+    template <typename Future, typename Executor>
     struct future_then_dispatch<Future, Executor,
         std::enable_if_t<traits::is_one_way_executor_v<Executor> ||
             traits::is_two_way_executor_v<Executor>>>
@@ -123,7 +123,7 @@ namespace hpx::lcos::detail {
     };
 
     // plain function, or function object
-    HPX_CXX_CORE_EXPORT template <typename Future, typename FD>
+    template <typename Future, typename FD>
     struct future_then_dispatch<Future, FD,
         std::enable_if_t<!traits::is_launch_policy_v<FD> &&
             !(traits::is_one_way_executor_v<FD> ||
diff --git a/libs/core/execution/include/hpx/execution/detail/sync_launch_policy_dispatch.hpp b/libs/core/execution/include/hpx/execution/detail/sync_launch_policy_dispatch.hpp
index f7760b6addc0..13561cfb1a3a 100644
--- a/libs/core/execution/include/hpx/execution/detail/sync_launch_policy_dispatch.hpp
+++ b/libs/core/execution/include/hpx/execution/detail/sync_launch_policy_dispatch.hpp
@@ -67,7 +67,7 @@ namespace hpx::detail {
         }
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Action>
+    template <typename Action>
     struct sync_launch_policy_dispatch<Action,
         std::enable_if_t<!traits::is_action_v<Action>>>
     {
diff --git a/libs/core/execution/include/hpx/execution/executors/execution_parameters.hpp b/libs/core/execution/include/hpx/execution/executors/execution_parameters.hpp
index de9e93bec0a3..9a8c832a16a3 100644
--- a/libs/core/execution/include/hpx/execution/executors/execution_parameters.hpp
+++ b/libs/core/execution/include/hpx/execution/executors/execution_parameters.hpp
@@ -996,7 +996,7 @@ namespace hpx::execution::experimental {
 
     ///////////////////////////////////////////////////////////////////////////
     // specialize trait for the type-combiner
-    HPX_CXX_CORE_EXPORT template <typename... Parameters>
+    template <typename... Parameters>
     struct is_executor_parameters<detail::executor_parameters<Parameters...>>
       : hpx::util::all_of<hpx::traits::is_executor_parameters<Parameters>...>
     {
@@ -1018,7 +1018,7 @@ namespace hpx::execution::experimental {
     }
 
     ///////////////////////////////////////////////////////////////////////////
-    HPX_CXX_CORE_EXPORT template <typename Param>
+    template <typename Param>
     struct executor_parameters_join<Param>
     {
         using type = Param;
diff --git a/libs/core/execution/include/hpx/execution/executors/polymorphic_executor.hpp b/libs/core/execution/include/hpx/execution/executors/polymorphic_executor.hpp
index 2a8f66d72a9e..bcabc3e53f99 100644
--- a/libs/core/execution/include/hpx/execution/executors/polymorphic_executor.hpp
+++ b/libs/core/execution/include/hpx/execution/executors/polymorphic_executor.hpp
@@ -693,7 +693,7 @@ namespace hpx::parallel::execution {
     HPX_CXX_CORE_EXPORT template <typename Sig>
     class polymorphic_executor;
 
-    HPX_CXX_CORE_EXPORT template <typename R, typename... Ts>
+    template <typename R, typename... Ts>
     class polymorphic_executor<R(Ts...)> : detail::polymorphic_executor_base
     {
         using base_type = detail::polymorphic_executor_base;
@@ -936,31 +936,31 @@ namespace hpx::parallel::execution {
 namespace hpx::execution::experimental {
 
     /// \cond NOINTERNAL
-    HPX_CXX_CORE_EXPORT template <typename Sig>
+    template <typename Sig>
     struct is_never_blocking_one_way_executor<
         parallel::execution::polymorphic_executor<Sig>> : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Sig>
+    template <typename Sig>
     struct is_one_way_executor<parallel::execution::polymorphic_executor<Sig>>
       : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Sig>
+    template <typename Sig>
     struct is_two_way_executor<parallel::execution::polymorphic_executor<Sig>>
       : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Sig>
+    template <typename Sig>
     struct is_bulk_one_way_executor<
         parallel::execution::polymorphic_executor<Sig>> : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Sig>
+    template <typename Sig>
     struct is_bulk_two_way_executor<
         parallel::execution::polymorphic_executor<Sig>> : std::true_type
     {
diff --git a/libs/core/execution/include/hpx/execution/executors/rebind_executor_parameters.hpp b/libs/core/execution/include/hpx/execution/executors/rebind_executor_parameters.hpp
index dc9b05ad1bff..aae23cf4a572 100644
--- a/libs/core/execution/include/hpx/execution/executors/rebind_executor_parameters.hpp
+++ b/libs/core/execution/include/hpx/execution/executors/rebind_executor_parameters.hpp
@@ -682,7 +682,7 @@ namespace hpx::execution::experimental {
         Wrapping wrapping;
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Wrapped, typename Wrapping>
+    template <typename Wrapped, typename Wrapping>
     struct is_executor_parameters<wrapped_params<Wrapped, Wrapping>>
       : std::true_type
     {
diff --git a/libs/core/execution/include/hpx/execution/traits/detail/simd/vector_pack_alignment_size.hpp b/libs/core/execution/include/hpx/execution/traits/detail/simd/vector_pack_alignment_size.hpp
index 66e61e9069d9..740493bd3cc9 100644
--- a/libs/core/execution/include/hpx/execution/traits/detail/simd/vector_pack_alignment_size.hpp
+++ b/libs/core/execution/include/hpx/execution/traits/detail/simd/vector_pack_alignment_size.hpp
@@ -20,25 +20,25 @@
 namespace hpx::parallel::traits {
 
     ///////////////////////////////////////////////////////////////////////////
-    HPX_CXX_CORE_EXPORT template <typename T>
+    template <typename T>
     struct is_vector_pack<datapar::experimental::native_simd<T>>
       : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename T>
+    template <typename T>
     struct is_vector_pack<T> : std::false_type
     {
     };
 
     ///////////////////////////////////////////////////////////////////////////
-    HPX_CXX_CORE_EXPORT template <typename T>
+    template <typename T>
     struct is_scalar_vector_pack<datapar::experimental::native_simd<T>>
       : std::false_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename T>
+    template <typename T>
     struct is_scalar_vector_pack<T> : std::true_type
     {
     };
@@ -50,7 +50,7 @@ namespace hpx::parallel::traits {
         static constexpr std::size_t const value = sizeof(T);
     };
 
-    HPX_CXX_CORE_EXPORT template <typename T, typename Abi>
+    template <typename T, typename Abi>
     struct vector_pack_alignment<datapar::experimental::simd<T, Abi>>
     {
         static constexpr std::size_t const value =
@@ -65,7 +65,7 @@ namespace hpx::parallel::traits {
         static constexpr std::size_t const value = 1;
     };
 
-    HPX_CXX_CORE_EXPORT template <typename T, typename Abi>
+    template <typename T, typename Abi>
     struct vector_pack_size<datapar::experimental::simd<T, Abi>>
     {
         static constexpr std::size_t const value =
diff --git a/libs/core/execution/include/hpx/execution/traits/detail/simd/vector_pack_type.hpp b/libs/core/execution/include/hpx/execution/traits/detail/simd/vector_pack_type.hpp
index 6a1ddb375f57..d740cf5a6a33 100644
--- a/libs/core/execution/include/hpx/execution/traits/detail/simd/vector_pack_type.hpp
+++ b/libs/core/execution/include/hpx/execution/traits/detail/simd/vector_pack_type.hpp
@@ -51,7 +51,7 @@ namespace hpx::parallel::traits {
     };
 
     ////////////////////////////////////////////////////////////////////
-    HPX_CXX_CORE_EXPORT template <typename T>
+    template <typename T>
     struct vector_pack_mask_type<T,
         std::enable_if_t<datapar::experimental::is_simd_v<T>>>
     {
diff --git a/libs/core/execution/include/hpx/execution/traits/executor_traits.hpp b/libs/core/execution/include/hpx/execution/traits/executor_traits.hpp
index 9ad6f76278b5..66348224530e 100644
--- a/libs/core/execution/include/hpx/execution/traits/executor_traits.hpp
+++ b/libs/core/execution/include/hpx/execution/traits/executor_traits.hpp
@@ -174,15 +174,14 @@ namespace hpx::execution::experimental {
         {
         };
 
-        HPX_CXX_CORE_EXPORT template <typename Executor, typename T>
+        template <typename Executor, typename T>
         struct exposes_future_type<Executor, T,
             std::void_t<typename Executor::template future_type<T>>>
           : std::true_type
         {
         };
 
-        HPX_CXX_CORE_EXPORT template <typename Executor, typename T,
-            typename... Ts>
+        template <typename Executor, typename T, typename... Ts>
         struct executor_future<Executor, T, hpx::util::pack<Ts...>,
             std::enable_if_t<hpx::traits::is_two_way_executor_v<Executor> &&
                 exposes_future_type<Executor, T>::value>>
@@ -190,8 +189,7 @@ namespace hpx::execution::experimental {
             using type = typename Executor::template future_type<T>;
         };
 
-        HPX_CXX_CORE_EXPORT template <typename Executor, typename T,
-            typename... Ts>
+        template <typename Executor, typename T, typename... Ts>
         struct executor_future<Executor, T, hpx::util::pack<Ts...>,
             std::enable_if_t<hpx::traits::is_two_way_executor_v<Executor> &&
                 has_async_execute_member<Executor>::value &&
@@ -201,8 +199,7 @@ namespace hpx::execution::experimental {
                 std::declval<T (*)(Ts...)>(), std::declval<Ts>()...));
         };
 
-        HPX_CXX_CORE_EXPORT template <typename Executor, typename T,
-            typename... Ts>
+        template <typename Executor, typename T, typename... Ts>
         struct executor_future<Executor, T, hpx::util::pack<Ts...>,
             std::enable_if_t<hpx::traits::is_two_way_executor_v<Executor> &&
                 !has_async_execute_member<Executor>::value &&
@@ -213,8 +210,7 @@ namespace hpx::execution::experimental {
                 T (*)(Ts...), Ts...>;
         };
 
-        HPX_CXX_CORE_EXPORT template <typename Executor, typename T,
-            typename Ts>
+        template <typename Executor, typename T, typename Ts>
         struct executor_future<Executor, T, Ts,
             std::enable_if_t<!hpx::traits::is_two_way_executor_v<Executor>>>
         {
diff --git a/libs/core/execution/include/hpx/execution/traits/future_then_result_exec.hpp b/libs/core/execution/include/hpx/execution/traits/future_then_result_exec.hpp
index bf8fabc434d5..2f70db99c67d 100644
--- a/libs/core/execution/include/hpx/execution/traits/future_then_result_exec.hpp
+++ b/libs/core/execution/include/hpx/execution/traits/future_then_result_exec.hpp
@@ -30,8 +30,7 @@ namespace hpx::traits {
             using type = typename continuation_not_callable<Future, F>::type;
         };
 
-        HPX_CXX_CORE_EXPORT template <typename Executor, typename Future,
-            typename F>
+        template <typename Executor, typename Future, typename F>
         struct future_then_executor_result<Executor, Future, F,
             std::void_t<hpx::util::invoke_result_t<F&, Future>>>
         {
diff --git a/libs/core/execution/include/hpx/execution/traits/is_execution_policy.hpp b/libs/core/execution/include/hpx/execution/traits/is_execution_policy.hpp
index b0a32ef51000..2320491bfcd9 100644
--- a/libs/core/execution/include/hpx/execution/traits/is_execution_policy.hpp
+++ b/libs/core/execution/include/hpx/execution/traits/is_execution_policy.hpp
@@ -193,7 +193,7 @@ namespace hpx {
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename T>
+    template <typename T>
     struct execution_policy_has_scheduler_executor<T,
         std::void_t<typename std::decay_t<T>::executor_type>>
       : hpx::traits::is_scheduler_executor<
diff --git a/libs/core/execution/include/hpx/execution/traits/vector_pack_alignment_size.hpp b/libs/core/execution/include/hpx/execution/traits/vector_pack_alignment_size.hpp
index 89da1de007ad..72048cd56838 100644
--- a/libs/core/execution/include/hpx/execution/traits/vector_pack_alignment_size.hpp
+++ b/libs/core/execution/include/hpx/execution/traits/vector_pack_alignment_size.hpp
@@ -55,7 +55,7 @@ namespace hpx::parallel::traits {
     HPX_CXX_CORE_EXPORT template <typename T, typename Enable = void>
     struct vector_pack_alignment;
 
-    HPX_CXX_CORE_EXPORT template <typename... Vector>
+    template <typename... Vector>
     struct vector_pack_alignment<hpx::tuple<Vector...>,
         std::enable_if_t<hpx::util::all_of_v<is_vector_pack_t<Vector>...>>>
     {
@@ -74,7 +74,7 @@ namespace hpx::parallel::traits {
     HPX_CXX_CORE_EXPORT template <typename T, typename Enable = void>
     struct vector_pack_size;
 
-    HPX_CXX_CORE_EXPORT template <typename... Vector>
+    template <typename... Vector>
     struct vector_pack_size<hpx::tuple<Vector...>,
         std::enable_if_t<hpx::util::all_of_v<is_vector_pack_t<Vector>...>>>
     {
diff --git a/libs/core/execution/include/hpx/execution/traits/vector_pack_type.hpp b/libs/core/execution/include/hpx/execution/traits/vector_pack_type.hpp
index 2a780a95be63..8b714da78bb9 100644
--- a/libs/core/execution/include/hpx/execution/traits/vector_pack_type.hpp
+++ b/libs/core/execution/include/hpx/execution/traits/vector_pack_type.hpp
@@ -27,7 +27,7 @@ namespace hpx::parallel::traits {
     using vector_pack_type_t = typename vector_pack_type<T, N, Abi>::type;
 
     // handle tuple<> transformations
-    HPX_CXX_CORE_EXPORT template <typename... T, std::size_t N, typename Abi>
+    template <typename... T, std::size_t N, typename Abi>
     struct vector_pack_type<hpx::tuple<T...>, N, Abi>
     {
         using type = hpx::tuple<vector_pack_type_t<T, N, Abi>...>;
diff --git a/libs/core/execution/include/hpx/experimental/emulate_simd.hpp b/libs/core/execution/include/hpx/experimental/emulate_simd.hpp
index e64f375214ba..262a8415d1a6 100644
--- a/libs/core/execution/include/hpx/experimental/emulate_simd.hpp
+++ b/libs/core/execution/include/hpx/experimental/emulate_simd.hpp
@@ -153,7 +153,7 @@ namespace hpx::datapar::experimental {
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename T, typename Abi>
+    template <typename T, typename Abi>
     struct is_simd<simd<T, Abi>> : std::true_type
     {
     };
@@ -163,7 +163,7 @@ namespace hpx::datapar::experimental {
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename T, typename Abi>
+    template <typename T, typename Abi>
     struct is_simd_mask<simd_mask<T, Abi>> : std::true_type
     {
     };
diff --git a/libs/core/execution_base/include/hpx/execution_base/any_sender.hpp b/libs/core/execution_base/include/hpx/execution_base/any_sender.hpp
index ecca93d36da8..18b006df3daf 100644
--- a/libs/core/execution_base/include/hpx/execution_base/any_sender.hpp
+++ b/libs/core/execution_base/include/hpx/execution_base/any_sender.hpp
@@ -432,7 +432,7 @@ namespace hpx::execution::experimental::detail {
     };
 }    // namespace hpx::execution::experimental::detail
 
-HPX_CXX_CORE_EXPORT template <typename... Ts>
+template <typename... Ts>
 struct hpx::detail::empty_vtable_type<
     hpx::execution::experimental::detail::any_receiver_base<Ts...>>
 {
diff --git a/libs/core/execution_base/include/hpx/execution_base/traits/coroutine_traits.hpp b/libs/core/execution_base/include/hpx/execution_base/traits/coroutine_traits.hpp
index 762139d4d3b4..5e93b475ad15 100644
--- a/libs/core/execution_base/include/hpx/execution_base/traits/coroutine_traits.hpp
+++ b/libs/core/execution_base/include/hpx/execution_base/traits/coroutine_traits.hpp
@@ -23,8 +23,7 @@ namespace hpx::execution::experimental {
         HPX_CXX_CORE_EXPORT template <typename, template <typename...> typename>
         inline constexpr bool is_instance_of_ = false;
 
-        HPX_CXX_CORE_EXPORT template <typename... As,
-            template <typename...> typename T>
+        template <typename... As, template <typename...> typename T>
         inline constexpr bool is_instance_of_<T<As...>, T> = true;
 
         HPX_CXX_CORE_EXPORT template <typename T,
@@ -41,7 +40,7 @@ namespace hpx::execution::experimental {
         inline constexpr bool has_await_ready_contextually_convertible_to_bool =
             false;
 
-        HPX_CXX_CORE_EXPORT template <typename T>
+        template <typename T>
         inline constexpr bool has_await_ready_contextually_convertible_to_bool<
             T, std::void_t<decltype(std::declval<T>().await_ready() ? 0 : 1)>> =
             true;
@@ -49,14 +48,14 @@ namespace hpx::execution::experimental {
         HPX_CXX_CORE_EXPORT template <typename, typename = void>
         inline constexpr bool has_await_ready = false;
 
-        HPX_CXX_CORE_EXPORT template <typename T>
+        template <typename T>
         inline constexpr bool has_await_ready<T,
             std::void_t<decltype(std::declval<T>().await_ready())>> = true;
 
         HPX_CXX_CORE_EXPORT template <typename, typename = void>
         inline constexpr bool has_await_resume = false;
 
-        HPX_CXX_CORE_EXPORT template <typename T>
+        template <typename T>
         inline constexpr bool has_await_resume<T,
             std::void_t<decltype(std::declval<T>().await_resume())>> = true;
 
@@ -77,18 +76,19 @@ namespace hpx::execution::experimental {
             typename = void>
         inline constexpr bool is_with_await_suspend_v = false;
 
-        HPX_CXX_CORE_EXPORT template <typename Awaiter, typename Promise>
+        template <typename Awaiter, typename Promise>
         inline constexpr bool is_with_await_suspend_v<Awaiter, Promise,
             std::enable_if_t<has_await_suspend_v<Awaiter> &&
                 (!std::is_same_v<Promise, void>)>> =
             is_await_suspend_result_v<Awaiter, Promise>;
 
-        HPX_CXX_CORE_EXPORT template <typename Awaiter, typename Promise>
+        template <typename Awaiter, typename Promise>
         inline constexpr bool is_with_await_suspend_v<Awaiter, Promise,
             std::enable_if_t<std::is_same_v<Promise, void>>> = true;
+
         // In P2300R8 "T is bool" is a sufficient condition for T to be an
         // await suspend result type.
-        HPX_CXX_CORE_EXPORT template <typename Awaiter, typename Promise>
+        template <typename Awaiter, typename Promise>
         inline constexpr bool is_with_await_suspend_v<Awaiter, Promise,
             std::enable_if_t<std::is_same_v<Promise, bool>>> = true;
 
@@ -127,7 +127,7 @@ namespace hpx::execution::experimental {
 
         // different versions of clang-format disagree
         // clang-format off
-        HPX_CXX_CORE_EXPORT template <typename Awaitable>
+         template <typename Awaitable>
         inline constexpr bool has_member_operator_co_await_v<Awaitable,
             std::void_t<
                 decltype(std::declval<Awaitable>().operator co_await())>> =
@@ -137,7 +137,7 @@ namespace hpx::execution::experimental {
         HPX_CXX_CORE_EXPORT template <typename Awaitable, typename = void>
         inline constexpr bool has_free_operator_co_await_v = false;
 
-        HPX_CXX_CORE_EXPORT template <typename Awaitable>
+        template <typename Awaitable>
         inline constexpr bool has_free_operator_co_await_v<Awaitable,
             std::void_t<decltype(operator co_await(
                 std::declval<Awaitable>()))>> = true;
diff --git a/libs/core/execution_base/include/hpx/execution_base/traits/is_executor_parameters.hpp b/libs/core/execution_base/include/hpx/execution_base/traits/is_executor_parameters.hpp
index fe88a1598457..ac5d80704750 100644
--- a/libs/core/execution_base/include/hpx/execution_base/traits/is_executor_parameters.hpp
+++ b/libs/core/execution_base/include/hpx/execution_base/traits/is_executor_parameters.hpp
@@ -36,7 +36,7 @@ namespace hpx::execution::experimental {
         using type = sequential_executor_parameters;
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Executor>
+    template <typename Executor>
     struct extract_executor_parameters<Executor,
         std::void_t<typename Executor::executor_parameters_type>>
     {
@@ -57,14 +57,14 @@ namespace hpx::execution::experimental {
         // by default, assume equally sized chunks
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Parameters>
+    template <typename Parameters>
     struct extract_has_variable_chunk_size<Parameters,
         std::void_t<typename Parameters::has_variable_chunk_size>>
       : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Parameters>
+    template <typename Parameters>
     struct extract_has_variable_chunk_size<::std::reference_wrapper<Parameters>>
       : extract_has_variable_chunk_size<Parameters>
     {
@@ -86,7 +86,7 @@ namespace hpx::execution::experimental {
 
 #if !defined(DOXYGEN)
     // doxygen gets confused by the following construct
-    HPX_CXX_CORE_EXPORT template <typename Parameters>
+    template <typename Parameters>
     struct extract_invokes_testing_function<Parameters,
         std::void_t<typename Parameters::invokes_testing_function>>
       : std::true_type
@@ -94,7 +94,7 @@ namespace hpx::execution::experimental {
     };
 #endif
 
-    HPX_CXX_CORE_EXPORT template <typename Parameters>
+    template <typename Parameters>
     struct extract_invokes_testing_function<
         ::std::reference_wrapper<Parameters>>
       : extract_invokes_testing_function<Parameters>
diff --git a/libs/core/executors/include/hpx/executors/annotating_executor.hpp b/libs/core/executors/include/hpx/executors/annotating_executor.hpp
index 2b1f238eb44c..7eac229d06eb 100644
--- a/libs/core/executors/include/hpx/executors/annotating_executor.hpp
+++ b/libs/core/executors/include/hpx/executors/annotating_executor.hpp
@@ -265,42 +265,42 @@ namespace hpx::execution::experimental {
     // underlying (wrapped) executor.
 
     /// \cond NOINTERNAL
-    HPX_CXX_CORE_EXPORT template <typename BaseExecutor>
+    template <typename BaseExecutor>
     struct is_one_way_executor<
         hpx::execution::experimental::annotating_executor<BaseExecutor>>
       : is_one_way_executor<BaseExecutor>
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename BaseExecutor>
+    template <typename BaseExecutor>
     struct is_never_blocking_one_way_executor<
         hpx::execution::experimental::annotating_executor<BaseExecutor>>
       : is_never_blocking_one_way_executor<BaseExecutor>
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename BaseExecutor>
+    template <typename BaseExecutor>
     struct is_bulk_one_way_executor<
         hpx::execution::experimental::annotating_executor<BaseExecutor>>
       : is_bulk_one_way_executor<BaseExecutor>
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename BaseExecutor>
+    template <typename BaseExecutor>
     struct is_two_way_executor<
         hpx::execution::experimental::annotating_executor<BaseExecutor>>
       : is_two_way_executor<BaseExecutor>
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename BaseExecutor>
+    template <typename BaseExecutor>
     struct is_bulk_two_way_executor<
         hpx::execution::experimental::annotating_executor<BaseExecutor>>
       : is_bulk_two_way_executor<BaseExecutor>
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename BaseExecutor>
+    template <typename BaseExecutor>
     struct is_scheduler_executor<
         hpx::execution::experimental::annotating_executor<BaseExecutor>>
       : is_scheduler_executor<BaseExecutor>
diff --git a/libs/core/executors/include/hpx/executors/async.hpp b/libs/core/executors/include/hpx/executors/async.hpp
index 7b72ab6ad6d7..35bf8df63083 100644
--- a/libs/core/executors/include/hpx/executors/async.hpp
+++ b/libs/core/executors/include/hpx/executors/async.hpp
@@ -21,7 +21,7 @@ namespace hpx::detail {
     HPX_CXX_CORE_EXPORT template <typename Func, typename Enable = void>
     struct async_dispatch_launch_policy_helper;
 
-    HPX_CXX_CORE_EXPORT template <typename Func>
+    template <typename Func>
     struct async_dispatch_launch_policy_helper<Func,
         std::enable_if_t<!traits::is_action_v<Func>>>
     {
@@ -38,7 +38,7 @@ namespace hpx::detail {
         }
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Policy>
+    template <typename Policy>
     struct async_dispatch<Policy,
         std::enable_if_t<traits::is_launch_policy_v<Policy>>>
     {
@@ -80,7 +80,7 @@ namespace hpx::detail {
     //
     // parallel::execution::executor
     // threads::executor
-    HPX_CXX_CORE_EXPORT template <typename Executor>
+    template <typename Executor>
     struct async_dispatch<Executor,
         std::enable_if_t<traits::is_one_way_executor_v<Executor> ||
             traits::is_two_way_executor_v<Executor>>>
diff --git a/libs/core/executors/include/hpx/executors/dataflow.hpp b/libs/core/executors/include/hpx/executors/dataflow.hpp
index d889c7ce530a..91e57b957577 100644
--- a/libs/core/executors/include/hpx/executors/dataflow.hpp
+++ b/libs/core/executors/include/hpx/executors/dataflow.hpp
@@ -98,7 +98,7 @@ namespace hpx::lcos::detail {
         using type = typename dataflow_not_callable<F, Args>::type;
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Policy, typename F, typename Args>
+    template <typename Policy, typename F, typename Args>
     struct dataflow_return_impl<false, Policy, F, Args,
         std::enable_if_t<traits::is_launch_policy_v<Policy>>>
     {
@@ -108,7 +108,7 @@ namespace hpx::lcos::detail {
     HPX_CXX_CORE_EXPORT template <typename Executor, typename F, typename Args>
     struct dataflow_return_impl_executor;
 
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename F, typename... Ts>
+    template <typename Executor, typename F, typename... Ts>
     struct dataflow_return_impl_executor<Executor, F, hpx::tuple<Ts...>>
     {
         // clang-format off
@@ -118,7 +118,7 @@ namespace hpx::lcos::detail {
         // clang-format on
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Policy, typename F, typename Args>
+    template <typename Policy, typename F, typename Args>
     struct dataflow_return_impl<false, Policy, F, Args,
         std::enable_if_t<traits::is_one_way_executor_v<Policy> ||
             traits::is_two_way_executor_v<Policy>>>
@@ -143,13 +143,14 @@ namespace hpx::lcos::detail {
     };
 
     // clang-format off
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Frame, typename Func,
+    template <typename Executor, typename Frame, typename Func,
         typename Futures>
     struct has_dataflow_finalize<Executor, Frame, Func, Futures,
         std::void_t<decltype(
-            std::declval<Executor>().dataflow_finalize(std::declval<Frame>(),
-                std::declval<Func>(), std::declval<Futures>()))>>
-      : std::true_type
+            std::declval<Executor>().dataflow_finalize(
+            std::declval<Frame>(), std::declval<Func>(),
+            std::declval<Futures>())
+        )>> : std::true_type
     {
     };
     // clang-format on
@@ -424,7 +425,7 @@ namespace hpx::lcos::detail {
     struct dataflow_dispatch_impl;
 
     // launch
-    HPX_CXX_CORE_EXPORT template <typename Policy>
+    template <typename Policy>
     struct dataflow_dispatch_impl<false, Policy,
         std::enable_if_t<traits::is_launch_policy_v<Policy>>>
     {
@@ -440,7 +441,7 @@ namespace hpx::lcos::detail {
     };
 
     // any action, plain function, or function object
-    HPX_CXX_CORE_EXPORT template <typename FD>
+    template <typename FD>
     struct dataflow_dispatch_impl<false, FD,
         std::enable_if_t<!traits::is_launch_policy_v<FD> &&
             !traits::is_one_way_executor_v<FD> &&
diff --git a/libs/core/executors/include/hpx/executors/datapar/execution_policy.hpp b/libs/core/executors/include/hpx/executors/datapar/execution_policy.hpp
index 8a342e3185bf..9dbc7fced08c 100644
--- a/libs/core/executors/include/hpx/executors/datapar/execution_policy.hpp
+++ b/libs/core/executors/include/hpx/executors/datapar/execution_policy.hpp
@@ -483,28 +483,28 @@ namespace hpx::detail {
     // extensions
 
     /// \cond NOINTERNAL
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_execution_policy<
         hpx::execution::detail::simd_policy_shim<Executor, Parameters>>
       : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_execution_policy<
         hpx::execution::detail::simd_task_policy_shim<Executor, Parameters>>
       : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_execution_policy<
         hpx::execution::detail::par_simd_policy_shim<Executor, Parameters>>
       : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_execution_policy<
         hpx::execution::detail::par_simd_task_policy_shim<Executor, Parameters>>
       : std::true_type
@@ -514,14 +514,14 @@ namespace hpx::detail {
 
     ///////////////////////////////////////////////////////////////////////////
     /// \cond NOINTERNAL
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_sequenced_execution_policy<
         hpx::execution::detail::simd_policy_shim<Executor, Parameters>>
       : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_sequenced_execution_policy<
         hpx::execution::detail::simd_task_policy_shim<Executor, Parameters>>
       : std::true_type
@@ -531,14 +531,14 @@ namespace hpx::detail {
 
     ///////////////////////////////////////////////////////////////////////////
     /// \cond NOINTERNAL
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_async_execution_policy<
         hpx::execution::detail::simd_task_policy_shim<Executor, Parameters>>
       : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_async_execution_policy<
         hpx::execution::detail::par_simd_task_policy_shim<Executor, Parameters>>
       : std::true_type
@@ -548,14 +548,14 @@ namespace hpx::detail {
 
     ///////////////////////////////////////////////////////////////////////////
     /// \cond NOINTERNAL
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_parallel_execution_policy<
         hpx::execution::detail::par_simd_policy_shim<Executor, Parameters>>
       : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_parallel_execution_policy<
         hpx::execution::detail::par_simd_task_policy_shim<Executor, Parameters>>
       : std::true_type
@@ -565,28 +565,28 @@ namespace hpx::detail {
 
     ///////////////////////////////////////////////////////////////////////////
     /// \cond NOINTERNAL
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_vectorpack_execution_policy<
         hpx::execution::detail::simd_policy_shim<Executor, Parameters>>
       : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_vectorpack_execution_policy<
         hpx::execution::detail::simd_task_policy_shim<Executor, Parameters>>
       : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_vectorpack_execution_policy<
         hpx::execution::detail::par_simd_policy_shim<Executor, Parameters>>
       : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_vectorpack_execution_policy<
         hpx::execution::detail::par_simd_task_policy_shim<Executor, Parameters>>
       : std::true_type
diff --git a/libs/core/executors/include/hpx/executors/exception_list.hpp b/libs/core/executors/include/hpx/executors/exception_list.hpp
index 6ec0e13673ba..30a2673b8f72 100644
--- a/libs/core/executors/include/hpx/executors/exception_list.hpp
+++ b/libs/core/executors/include/hpx/executors/exception_list.hpp
@@ -28,7 +28,7 @@ namespace hpx::parallel {
             typename Enable = void>
         struct handle_exception_impl;
 
-        HPX_CXX_CORE_EXPORT template <typename ExPolicy, typename Result>
+        template <typename ExPolicy, typename Result>
         struct handle_exception_impl<ExPolicy, Result,
             std::enable_if_t<!hpx::is_async_execution_policy_v<ExPolicy> &&
                 !hpx::execution_policy_has_scheduler_executor_v<ExPolicy> &&
@@ -84,7 +84,7 @@ namespace hpx::parallel {
         };
 
         ///////////////////////////////////////////////////////////////////////
-        HPX_CXX_CORE_EXPORT template <typename ExPolicy, typename Result>
+        template <typename ExPolicy, typename Result>
         struct handle_exception_impl<ExPolicy, Result,
             std::enable_if_t<hpx::is_async_execution_policy_v<ExPolicy> &&
                 !hpx::execution_policy_has_scheduler_executor_v<ExPolicy> &&
@@ -160,7 +160,7 @@ namespace hpx::parallel {
         ///////////////////////////////////////////////////////////////////////
         // any exceptions thrown by algorithms executed with an unsequenced
         // policy are to call terminate.
-        HPX_CXX_CORE_EXPORT template <typename ExPolicy, typename Result>
+        template <typename ExPolicy, typename Result>
         struct handle_exception_impl<ExPolicy, Result,
             std::enable_if_t<!hpx::is_async_execution_policy_v<ExPolicy> &&
                 !hpx::execution_policy_has_scheduler_executor_v<ExPolicy> &&
@@ -185,7 +185,7 @@ namespace hpx::parallel {
             }
         };
 
-        HPX_CXX_CORE_EXPORT template <typename ExPolicy, typename Result>
+        template <typename ExPolicy, typename Result>
         struct handle_exception_impl<ExPolicy, Result,
             std::enable_if_t<hpx::is_async_execution_policy_v<ExPolicy> &&
                 !hpx::execution_policy_has_scheduler_executor_v<ExPolicy> &&
@@ -210,7 +210,7 @@ namespace hpx::parallel {
         };
 
         ///////////////////////////////////////////////////////////////////////
-        HPX_CXX_CORE_EXPORT template <typename ExPolicy, typename Result>
+        template <typename ExPolicy, typename Result>
         struct handle_exception_impl<ExPolicy, Result,
             std::enable_if_t<
                 hpx::execution_policy_has_scheduler_executor_v<ExPolicy>>>
diff --git a/libs/core/executors/include/hpx/executors/execute_on.hpp b/libs/core/executors/include/hpx/executors/execute_on.hpp
index c8e50146136c..2959db0a01b3 100644
--- a/libs/core/executors/include/hpx/executors/execute_on.hpp
+++ b/libs/core/executors/include/hpx/executors/execute_on.hpp
@@ -25,7 +25,7 @@ namespace hpx::execution::experimental {
         {
         };
 
-        HPX_CXX_CORE_EXPORT template <typename Scheduler>
+        template <typename Scheduler>
         struct exposes_policy_aware_scheduler_types<Scheduler,
             std::void_t<typename Scheduler::policy_type,
                 typename Scheduler::base_scheduler_type>> : std::true_type
@@ -39,7 +39,7 @@ namespace hpx::execution::experimental {
         };
 
         // clang-format off
-        HPX_CXX_CORE_EXPORT template <typename Scheduler>
+        template <typename Scheduler>
         struct exposes_get_policy<Scheduler,
             std::enable_if_t<hpx::is_execution_policy_v<
                 decltype(std::declval<Scheduler>().get_policy())>>>
@@ -150,7 +150,7 @@ namespace hpx::execution::experimental {
         {
         };
 
-        HPX_CXX_CORE_EXPORT template <typename Scheduler>
+        template <typename Scheduler>
         struct is_policy_aware_scheduler<Scheduler,
             std::enable_if_t<is_scheduler_v<Scheduler> &&
                 detail::exposes_policy_aware_scheduler_types<
diff --git a/libs/core/executors/include/hpx/executors/execution_policy.hpp b/libs/core/executors/include/hpx/executors/execution_policy.hpp
index d8ed25a2269b..282dee5e564c 100644
--- a/libs/core/executors/include/hpx/executors/execution_policy.hpp
+++ b/libs/core/executors/include/hpx/executors/execution_policy.hpp
@@ -86,7 +86,7 @@ namespace hpx::execution {
         {
         };
 
-        HPX_CXX_CORE_EXPORT template <typename T>
+        template <typename T>
         struct has_async_execution_policy<T,
             std::void_t<decltype(std::declval<std::decay_t<T>>()(task))>>
           : std::true_type
@@ -1095,54 +1095,54 @@ namespace hpx::detail {
     // rebind operation. This information can be used to inhibit the
     // construction of a generic execution_policy from any of the rebound
     // policies.
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_rebound_execution_policy<
         hpx::execution::detail::sequenced_policy_shim<Executor, Parameters>>
       : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_rebound_execution_policy<hpx::execution::detail::
             sequenced_task_policy_shim<Executor, Parameters>> : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_rebound_execution_policy<
         hpx::execution::detail::parallel_policy_shim<Executor, Parameters>>
       : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_rebound_execution_policy<
         hpx::execution::detail::parallel_task_policy_shim<Executor, Parameters>>
       : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_rebound_execution_policy<
         hpx::execution::detail::unsequenced_policy_shim<Executor, Parameters>>
       : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_rebound_execution_policy<hpx::execution::detail::
             unsequenced_task_policy_shim<Executor, Parameters>> : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_rebound_execution_policy<hpx::execution::detail::
             parallel_unsequenced_policy_shim<Executor, Parameters>>
       : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_rebound_execution_policy<hpx::execution::detail::
             parallel_unsequenced_task_policy_shim<Executor, Parameters>>
       : std::true_type
@@ -1151,28 +1151,28 @@ namespace hpx::detail {
 
     ////////////////////////////////////////////////////////////////////////
     /// \cond NOINTERNAL
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_execution_policy<
         hpx::execution::detail::parallel_policy_shim<Executor, Parameters>>
       : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_execution_policy<hpx::execution::detail::
             parallel_unsequenced_policy_shim<Executor, Parameters>>
       : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_execution_policy<
         hpx::execution::detail::unsequenced_policy_shim<Executor, Parameters>>
       : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_execution_policy<
         hpx::execution::detail::sequenced_policy_shim<Executor, Parameters>>
       : std::true_type
@@ -1180,26 +1180,26 @@ namespace hpx::detail {
     };
 
     // extension
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_execution_policy<hpx::execution::detail::
             sequenced_task_policy_shim<Executor, Parameters>> : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_execution_policy<
         hpx::execution::detail::parallel_task_policy_shim<Executor, Parameters>>
       : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_execution_policy<hpx::execution::detail::
             unsequenced_task_policy_shim<Executor, Parameters>> : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_execution_policy<hpx::execution::detail::
             parallel_unsequenced_task_policy_shim<Executor, Parameters>>
       : std::true_type
@@ -1209,28 +1209,28 @@ namespace hpx::detail {
 
     ///////////////////////////////////////////////////////////////////////////
     /// \cond NOINTERNAL
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_parallel_execution_policy<
         hpx::execution::detail::parallel_policy_shim<Executor, Parameters>>
       : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_parallel_execution_policy<hpx::execution::detail::
             parallel_unsequenced_policy_shim<Executor, Parameters>>
       : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_parallel_execution_policy<
         hpx::execution::detail::parallel_task_policy_shim<Executor, Parameters>>
       : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_parallel_execution_policy<hpx::execution::detail::
             parallel_unsequenced_task_policy_shim<Executor, Parameters>>
       : std::true_type
@@ -1240,27 +1240,27 @@ namespace hpx::detail {
 
     ///////////////////////////////////////////////////////////////////////////
     /// \cond NOINTERNAL
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_sequenced_execution_policy<hpx::execution::detail::
             sequenced_task_policy_shim<Executor, Parameters>> : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_sequenced_execution_policy<
         hpx::execution::detail::sequenced_policy_shim<Executor, Parameters>>
       : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_sequenced_execution_policy<
         hpx::execution::detail::unsequenced_policy_shim<Executor, Parameters>>
       : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_sequenced_execution_policy<hpx::execution::detail::
             unsequenced_task_policy_shim<Executor, Parameters>> : std::true_type
     {
@@ -1269,26 +1269,26 @@ namespace hpx::detail {
 
     ///////////////////////////////////////////////////////////////////////////
     /// \cond NOINTERNAL
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_async_execution_policy<hpx::execution::detail::
             sequenced_task_policy_shim<Executor, Parameters>> : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_async_execution_policy<
         hpx::execution::detail::parallel_task_policy_shim<Executor, Parameters>>
       : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_async_execution_policy<hpx::execution::detail::
             unsequenced_task_policy_shim<Executor, Parameters>> : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_async_execution_policy<hpx::execution::detail::
             parallel_unsequenced_task_policy_shim<Executor, Parameters>>
       : std::true_type
@@ -1298,27 +1298,27 @@ namespace hpx::detail {
 
     ///////////////////////////////////////////////////////////////////////////
     /// \cond NOINTERNAL
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_unsequenced_execution_policy<
         hpx::execution::detail::unsequenced_policy_shim<Executor, Parameters>>
       : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_unsequenced_execution_policy<hpx::execution::detail::
             parallel_unsequenced_policy_shim<Executor, Parameters>>
       : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_unsequenced_execution_policy<hpx::execution::detail::
             unsequenced_task_policy_shim<Executor, Parameters>> : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Executor, typename Parameters>
+    template <typename Executor, typename Parameters>
     struct is_unsequenced_execution_policy<hpx::execution::detail::
             parallel_unsequenced_task_policy_shim<Executor, Parameters>>
       : std::true_type
diff --git a/libs/core/executors/include/hpx/executors/explicit_scheduler_executor.hpp b/libs/core/executors/include/hpx/executors/explicit_scheduler_executor.hpp
index b343840ef664..27d6385c6f9d 100644
--- a/libs/core/executors/include/hpx/executors/explicit_scheduler_executor.hpp
+++ b/libs/core/executors/include/hpx/executors/explicit_scheduler_executor.hpp
@@ -378,37 +378,37 @@ namespace hpx::execution::experimental {
 namespace hpx::execution::experimental {
 
     /// \cond NOINTERNAL
-    HPX_CXX_CORE_EXPORT template <typename BaseScheduler>
+    template <typename BaseScheduler>
     struct is_one_way_executor<hpx::execution::experimental::
             explicit_scheduler_executor<BaseScheduler>> : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename BaseScheduler>
+    template <typename BaseScheduler>
     struct is_never_blocking_one_way_executor<hpx::execution::experimental::
             explicit_scheduler_executor<BaseScheduler>> : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename BaseScheduler>
+    template <typename BaseScheduler>
     struct is_bulk_one_way_executor<hpx::execution::experimental::
             explicit_scheduler_executor<BaseScheduler>> : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename BaseScheduler>
+    template <typename BaseScheduler>
     struct is_two_way_executor<hpx::execution::experimental::
             explicit_scheduler_executor<BaseScheduler>> : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename BaseScheduler>
+    template <typename BaseScheduler>
     struct is_bulk_two_way_executor<hpx::execution::experimental::
             explicit_scheduler_executor<BaseScheduler>> : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename BaseScheduler>
+    template <typename BaseScheduler>
     struct is_scheduler_executor<hpx::execution::experimental::
             explicit_scheduler_executor<BaseScheduler>> : std::true_type
     {
diff --git a/libs/core/executors/include/hpx/executors/guided_pool_executor.hpp b/libs/core/executors/include/hpx/executors/guided_pool_executor.hpp
index 82627d7c3644..4caa4fa96f5d 100644
--- a/libs/core/executors/include/hpx/executors/guided_pool_executor.hpp
+++ b/libs/core/executors/include/hpx/executors/guided_pool_executor.hpp
@@ -258,7 +258,7 @@ namespace hpx::execution::experimental {
     // the args should be the same as those that would be called
     // for an async function or continuation. This makes it possible to
     // guide a lambda rather than a full function.
-    HPX_CXX_CORE_EXPORT template <typename Tag>
+    template <typename Tag>
     struct guided_pool_executor<pool_numa_hint<Tag>>
     {
         template <typename Executor, typename NumaFunction>
@@ -629,25 +629,25 @@ namespace hpx::execution::experimental {
         guided_pool_executor<H> guided_exec_;
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Hint>
+    template <typename Hint>
     struct executor_execution_category<guided_pool_executor<Hint>>
     {
         using type = hpx::execution::parallel_execution_tag;
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Hint>
+    template <typename Hint>
     struct is_two_way_executor<guided_pool_executor<Hint>> : std::true_type
     {
     };
 
     // ----------------------------
-    HPX_CXX_CORE_EXPORT template <typename Hint>
+    template <typename Hint>
     struct executor_execution_category<guided_pool_executor_shim<Hint>>
     {
         using type = hpx::execution::parallel_execution_tag;
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Hint>
+    template <typename Hint>
     struct is_two_way_executor<guided_pool_executor_shim<Hint>> : std::true_type
     {
     };
diff --git a/libs/core/executors/include/hpx/executors/limiting_executor.hpp b/libs/core/executors/include/hpx/executors/limiting_executor.hpp
index d8fb5153affa..a849b6e40fc0 100644
--- a/libs/core/executors/include/hpx/executors/limiting_executor.hpp
+++ b/libs/core/executors/include/hpx/executors/limiting_executor.hpp
@@ -342,42 +342,42 @@ namespace hpx::execution::experimental {
     // --------------------------------------------------------------------
     // simple forwarding implementations of executor traits
     // --------------------------------------------------------------------
-    HPX_CXX_CORE_EXPORT template <typename BaseExecutor>
+    template <typename BaseExecutor>
     struct is_one_way_executor<
         hpx::execution::experimental::limiting_executor<BaseExecutor>>
       : is_one_way_executor<std::decay_t<BaseExecutor>>
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename BaseExecutor>
+    template <typename BaseExecutor>
     struct is_never_blocking_one_way_executor<
         hpx::execution::experimental::limiting_executor<BaseExecutor>>
       : is_never_blocking_one_way_executor<std::decay_t<BaseExecutor>>
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename BaseExecutor>
+    template <typename BaseExecutor>
     struct is_two_way_executor<
         hpx::execution::experimental::limiting_executor<BaseExecutor>>
       : is_two_way_executor<std::decay_t<BaseExecutor>>
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename BaseExecutor>
+    template <typename BaseExecutor>
     struct is_bulk_one_way_executor<
         hpx::execution::experimental::limiting_executor<BaseExecutor>>
       : is_bulk_one_way_executor<std::decay_t<BaseExecutor>>
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename BaseExecutor>
+    template <typename BaseExecutor>
     struct is_bulk_two_way_executor<
         hpx::execution::experimental::limiting_executor<BaseExecutor>>
       : is_bulk_two_way_executor<std::decay_t<BaseExecutor>>
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename BaseExecutor>
+    template <typename BaseExecutor>
     struct is_scheduler_executor<
         hpx::execution::experimental::limiting_executor<BaseExecutor>>
       : is_scheduler_executor<std::decay_t<BaseExecutor>>
diff --git a/libs/core/executors/include/hpx/executors/parallel_executor.hpp b/libs/core/executors/include/hpx/executors/parallel_executor.hpp
index 59dc73a3d172..2c8820ba093f 100644
--- a/libs/core/executors/include/hpx/executors/parallel_executor.hpp
+++ b/libs/core/executors/include/hpx/executors/parallel_executor.hpp
@@ -710,7 +710,7 @@ namespace hpx::execution {
 
     ////////////////////////////////////////////////////////////////////////////
     // parallel executor that spawns threads hierarchically
-    HPX_CXX_CORE_EXPORT template <typename Policy>
+    template <typename Policy>
     struct parallel_policy_executor<Policy, true>
       : parallel_policy_executor_base<Policy>
     {
@@ -1156,35 +1156,35 @@ namespace hpx::execution {
 namespace hpx::execution::experimental {
 
     /// \cond NOINTERNAL
-    HPX_CXX_CORE_EXPORT template <typename Policy, bool HierarchicalSpawning>
+    template <typename Policy, bool HierarchicalSpawning>
     struct is_one_way_executor<
         hpx::execution::parallel_policy_executor<Policy, HierarchicalSpawning>>
       : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Policy, bool HierarchicalSpawning>
+    template <typename Policy, bool HierarchicalSpawning>
     struct is_never_blocking_one_way_executor<
         hpx::execution::parallel_policy_executor<Policy, HierarchicalSpawning>>
       : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Policy, bool HierarchicalSpawning>
+    template <typename Policy, bool HierarchicalSpawning>
     struct is_two_way_executor<
         hpx::execution::parallel_policy_executor<Policy, HierarchicalSpawning>>
       : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Policy, bool HierarchicalSpawning>
+    template <typename Policy, bool HierarchicalSpawning>
     struct is_bulk_one_way_executor<
         hpx::execution::parallel_policy_executor<Policy, HierarchicalSpawning>>
       : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Policy, bool HierarchicalSpawning>
+    template <typename Policy, bool HierarchicalSpawning>
     struct is_bulk_two_way_executor<
         hpx::execution::parallel_policy_executor<Policy, HierarchicalSpawning>>
       : std::true_type
diff --git a/libs/core/executors/include/hpx/executors/post.hpp b/libs/core/executors/include/hpx/executors/post.hpp
index 1e4510dcbd06..afe16d3fe8fb 100644
--- a/libs/core/executors/include/hpx/executors/post.hpp
+++ b/libs/core/executors/include/hpx/executors/post.hpp
@@ -41,7 +41,7 @@ namespace hpx::detail {
 
     // The overload for hpx::post taking an executor simply forwards to the
     // corresponding executor customization point.
-    HPX_CXX_CORE_EXPORT template <typename Executor>
+    template <typename Executor>
     struct post_dispatch<Executor,
         std::enable_if_t<traits::is_one_way_executor_v<Executor> ||
             traits::is_two_way_executor_v<Executor>>>
diff --git a/libs/core/executors/include/hpx/executors/restricted_thread_pool_executor.hpp b/libs/core/executors/include/hpx/executors/restricted_thread_pool_executor.hpp
index 75e9430bfe00..377c22b66d6f 100644
--- a/libs/core/executors/include/hpx/executors/restricted_thread_pool_executor.hpp
+++ b/libs/core/executors/include/hpx/executors/restricted_thread_pool_executor.hpp
@@ -241,7 +241,7 @@ namespace hpx::execution::experimental {
 
     ///////////////////////////////////////////////////////////////////////////
     /// \cond NOINTERNAL
-    HPX_CXX_CORE_EXPORT template <typename Policy>
+    template <typename Policy>
     struct is_never_blocking_one_way_executor<
         restricted_policy_executor<Policy>>
       : is_never_blocking_one_way_executor<
@@ -249,20 +249,20 @@ namespace hpx::execution::experimental {
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Policy>
+    template <typename Policy>
     struct is_two_way_executor<restricted_policy_executor<Policy>>
       : is_two_way_executor<hpx::execution::parallel_policy_executor<Policy>>
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Policy>
+    template <typename Policy>
     struct is_bulk_two_way_executor<restricted_policy_executor<Policy>>
       : is_bulk_two_way_executor<
             hpx::execution::parallel_policy_executor<Policy>>
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Policy>
+    template <typename Policy>
     struct is_scheduler_executor<restricted_policy_executor<Policy>>
       : is_scheduler_executor<hpx::execution::parallel_policy_executor<Policy>>
     {
diff --git a/libs/core/executors/include/hpx/executors/scheduler_executor.hpp b/libs/core/executors/include/hpx/executors/scheduler_executor.hpp
index 1ad158f4439b..cc84cf09a176 100644
--- a/libs/core/executors/include/hpx/executors/scheduler_executor.hpp
+++ b/libs/core/executors/include/hpx/executors/scheduler_executor.hpp
@@ -335,35 +335,35 @@ namespace hpx::execution::experimental {
     }
 
     /// \cond NOINTERNAL
-    HPX_CXX_CORE_EXPORT template <typename BaseScheduler>
+    template <typename BaseScheduler>
     struct is_one_way_executor<
         hpx::execution::experimental::scheduler_executor<BaseScheduler>>
       : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename BaseScheduler>
+    template <typename BaseScheduler>
     struct is_never_blocking_one_way_executor<
         hpx::execution::experimental::scheduler_executor<BaseScheduler>>
       : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename BaseScheduler>
+    template <typename BaseScheduler>
     struct is_bulk_one_way_executor<
         hpx::execution::experimental::scheduler_executor<BaseScheduler>>
       : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename BaseScheduler>
+    template <typename BaseScheduler>
     struct is_two_way_executor<
         hpx::execution::experimental::scheduler_executor<BaseScheduler>>
       : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename BaseScheduler>
+    template <typename BaseScheduler>
     struct is_bulk_two_way_executor<
         hpx::execution::experimental::scheduler_executor<BaseScheduler>>
       : std::true_type
diff --git a/libs/core/executors/include/hpx/executors/sync.hpp b/libs/core/executors/include/hpx/executors/sync.hpp
index 028fd329bc72..38501f18751b 100644
--- a/libs/core/executors/include/hpx/executors/sync.hpp
+++ b/libs/core/executors/include/hpx/executors/sync.hpp
@@ -21,7 +21,7 @@ namespace hpx::detail {
     HPX_CXX_CORE_EXPORT template <typename Func, typename Enable = void>
     struct sync_dispatch_launch_policy_helper;
 
-    HPX_CXX_CORE_EXPORT template <typename Func>
+    template <typename Func>
     struct sync_dispatch_launch_policy_helper<Func,
         std::enable_if_t<!traits::is_action_v<Func>>>
     {
@@ -38,7 +38,7 @@ namespace hpx::detail {
         }
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Policy>
+    template <typename Policy>
     struct sync_dispatch<Policy,
         std::enable_if_t<traits::is_launch_policy_v<Policy>>>
     {
@@ -78,7 +78,7 @@ namespace hpx::detail {
 
     // The overload for hpx::sync taking an executor simply forwards to the
     // corresponding executor customization point.
-    HPX_CXX_CORE_EXPORT template <typename Executor>
+    template <typename Executor>
     struct sync_dispatch<Executor,
         std::enable_if_t<traits::is_one_way_executor_v<Executor> ||
             traits::is_two_way_executor_v<Executor>>>
diff --git a/libs/core/functional/include/hpx/functional/bind.hpp b/libs/core/functional/include/hpx/functional/bind.hpp
index 56877943b456..dcae1cff39ab 100644
--- a/libs/core/functional/include/hpx/functional/bind.hpp
+++ b/libs/core/functional/include/hpx/functional/bind.hpp
@@ -96,8 +96,7 @@ namespace hpx {
             }
         };
 
-        HPX_CXX_CORE_EXPORT template <typename T, std::size_t NumUs,
-            typename TD>
+        template <typename T, std::size_t NumUs, typename TD>
         struct bind_eval<T, NumUs, TD,
             std::enable_if_t<hpx::is_placeholder_v<TD> != 0 &&
                 (hpx::is_placeholder_v<TD> <= NumUs)>>
@@ -106,8 +105,7 @@ namespace hpx {
         {
         };
 
-        HPX_CXX_CORE_EXPORT template <typename T, std::size_t NumUs,
-            typename TD>
+        template <typename T, std::size_t NumUs, typename TD>
         struct bind_eval<T, NumUs, TD,
             std::enable_if_t<hpx::is_bind_expression_v<TD>>>
         {
@@ -123,8 +121,7 @@ namespace hpx {
         HPX_CXX_CORE_EXPORT template <typename F, typename Ts, typename... Us>
         struct invoke_bound_result;
 
-        HPX_CXX_CORE_EXPORT template <typename F, typename... Ts,
-            typename... Us>
+        template <typename F, typename... Ts, typename... Us>
         struct invoke_bound_result<F, util::pack<Ts...>, Us...>
           : util::invoke_result<F,
                 decltype(bind_eval<Ts, sizeof...(Us)>::call(
@@ -140,8 +137,7 @@ namespace hpx {
         HPX_CXX_CORE_EXPORT template <typename F, typename Is, typename... Ts>
         class bound;
 
-        HPX_CXX_CORE_EXPORT template <typename F, std::size_t... Is,
-            typename... Ts>
+        template <typename F, std::size_t... Is, typename... Ts>
         class bound<F, util::index_pack<Is...>, Ts...>
         {
         public:
@@ -304,13 +300,13 @@ namespace hpx {
 namespace hpx {
 
     ///////////////////////////////////////////////////////////////////////////
-    HPX_CXX_CORE_EXPORT template <typename F, typename... Ts>
+    template <typename F, typename... Ts>
     struct is_bind_expression<hpx::detail::bound<F, Ts...>> : std::true_type
     {
     };
 
     ///////////////////////////////////////////////////////////////////////////
-    HPX_CXX_CORE_EXPORT template <std::size_t I>
+    template <std::size_t I>
     struct is_placeholder<hpx::detail::placeholder<I>>
       : std::integral_constant<int, I>
     {
diff --git a/libs/core/functional/include/hpx/functional/detail/vtable/function_vtable.hpp b/libs/core/functional/include/hpx/functional/detail/vtable/function_vtable.hpp
index d4560b3535dc..8375a717832d 100644
--- a/libs/core/functional/include/hpx/functional/detail/vtable/function_vtable.hpp
+++ b/libs/core/functional/include/hpx/functional/detail/vtable/function_vtable.hpp
@@ -45,7 +45,7 @@ namespace hpx::util::detail {
     HPX_CXX_CORE_EXPORT template <typename Sig, bool Copyable = true>
     struct function_vtable;
 
-    HPX_CXX_CORE_EXPORT template <typename Sig>
+    template <typename Sig>
     struct function_vtable<Sig, /*Copyable*/ false>
       : function_base_vtable
       , callable_vtable<Sig>
@@ -67,7 +67,7 @@ namespace hpx::util::detail {
         }
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Sig>
+    template <typename Sig>
     struct function_vtable<Sig, /*Copyable*/ true> : function_vtable<Sig, false>
     {
         using copyable_tag = std::integral_constant<bool, true>;
diff --git a/libs/core/functional/include/hpx/functional/first_argument.hpp b/libs/core/functional/include/hpx/functional/first_argument.hpp
index 7f2d132fb3e1..0f7f1ef9d1d5 100644
--- a/libs/core/functional/include/hpx/functional/first_argument.hpp
+++ b/libs/core/functional/include/hpx/functional/first_argument.hpp
@@ -72,14 +72,14 @@ namespace hpx::util {
     };
 
     // Specialization for actions
-    HPX_CXX_CORE_EXPORT template <typename F>
+    template <typename F>
     struct first_argument<F, std::enable_if_t<hpx::traits::is_action_v<F>>>
       : detail::tuple_first_argument<typename F::arguments_type>
     {
     };
 
     // Specialization for functions
-    HPX_CXX_CORE_EXPORT template <typename F>
+    template <typename F>
     struct first_argument<F,
         std::enable_if_t<!hpx::traits::is_action_v<F> &&
             std::is_function_v<std::remove_pointer_t<F>>>>
@@ -88,7 +88,7 @@ namespace hpx::util {
     };
 
     // Specialization for lambdas
-    HPX_CXX_CORE_EXPORT template <typename F>
+    template <typename F>
     struct first_argument<F,
         std::enable_if_t<!hpx::traits::is_action_v<F> &&
             !std::is_function_v<std::remove_pointer_t<F>>>>
diff --git a/libs/core/functional/include/hpx/functional/function.hpp b/libs/core/functional/include/hpx/functional/function.hpp
index 58d5ab505d9e..b26ab39da68e 100644
--- a/libs/core/functional/include/hpx/functional/function.hpp
+++ b/libs/core/functional/include/hpx/functional/function.hpp
@@ -39,7 +39,7 @@ namespace hpx {
     HPX_CXX_CORE_EXPORT template <typename Sig, bool Serializable = false>
     class function;
 
-    HPX_CXX_CORE_EXPORT template <typename R, typename... Ts, bool Serializable>
+    template <typename R, typename... Ts, bool Serializable>
     class function<R(Ts...), Serializable>
       : public util::detail::basic_function<R(Ts...), true, Serializable>
     {
diff --git a/libs/core/functional/include/hpx/functional/function_ref.hpp b/libs/core/functional/include/hpx/functional/function_ref.hpp
index d45b98b5af2f..058795dcb600 100644
--- a/libs/core/functional/include/hpx/functional/function_ref.hpp
+++ b/libs/core/functional/include/hpx/functional/function_ref.hpp
@@ -89,7 +89,7 @@ namespace hpx {
     }    // namespace util::detail
 
     ///////////////////////////////////////////////////////////////////////////
-    HPX_CXX_CORE_EXPORT template <typename R, typename... Ts>
+    template <typename R, typename... Ts>
     class function_ref<R(Ts...)>
     {
         using VTable = util::detail::function_ref_vtable<R(Ts...)>;
diff --git a/libs/core/functional/include/hpx/functional/move_only_function.hpp b/libs/core/functional/include/hpx/functional/move_only_function.hpp
index f9fc542f5c28..465c5aff11e3 100644
--- a/libs/core/functional/include/hpx/functional/move_only_function.hpp
+++ b/libs/core/functional/include/hpx/functional/move_only_function.hpp
@@ -47,7 +47,7 @@ namespace hpx {
     HPX_CXX_CORE_EXPORT template <typename Sig, bool Serializable = false>
     class move_only_function;
 
-    HPX_CXX_CORE_EXPORT template <typename R, typename... Ts, bool Serializable>
+    template <typename R, typename... Ts, bool Serializable>
     class move_only_function<R(Ts...), Serializable>
       : public util::detail::basic_function<R(Ts...), false, Serializable>
     {
diff --git a/libs/core/functional/include/hpx/functional/reference_wrapper.hpp b/libs/core/functional/include/hpx/functional/reference_wrapper.hpp
index 8786f5ece4d7..571bf9466ba6 100644
--- a/libs/core/functional/include/hpx/functional/reference_wrapper.hpp
+++ b/libs/core/functional/include/hpx/functional/reference_wrapper.hpp
@@ -71,7 +71,7 @@ namespace hpx {
         {
         };
 
-        HPX_CXX_CORE_EXPORT template <typename T>
+        template <typename T>
         struct needs_reference_semantics<T const> : needs_reference_semantics<T>
         {
         };
@@ -81,7 +81,7 @@ namespace hpx {
             needs_reference_semantics<T>::value;
     }    // namespace traits
 
-    HPX_CXX_CORE_EXPORT template <typename T>
+    template <typename T>
     struct reference_wrapper<T,
         std::enable_if_t<traits::needs_reference_semantics_v<T>>>
     {
diff --git a/libs/core/functional/include/hpx/functional/traits/get_function_address.hpp b/libs/core/functional/include/hpx/functional/traits/get_function_address.hpp
index 41f01adf08e2..e34516e2818a 100644
--- a/libs/core/functional/include/hpx/functional/traits/get_function_address.hpp
+++ b/libs/core/functional/include/hpx/functional/traits/get_function_address.hpp
@@ -25,7 +25,7 @@ namespace hpx::traits {
     };
 
     // For global (and static) functions we return the function address itself
-    HPX_CXX_CORE_EXPORT template <typename R, typename... Ts>
+    template <typename R, typename... Ts>
     struct get_function_address<R (*)(Ts...)>
     {
         static std::size_t call(R (*f)(Ts...)) noexcept
@@ -50,7 +50,7 @@ namespace hpx::traits {
     //         corresponding to the function.
     //
     // clang-format off
-    HPX_CXX_CORE_EXPORT template <typename R, typename Obj, typename... Ts>
+    template <typename R, typename Obj, typename... Ts>
     struct get_function_address<R (Obj::*)(Ts...)>
     {
         static std::size_t call(R (Obj::*f)(Ts...)) noexcept
@@ -83,7 +83,7 @@ namespace hpx::traits {
         }
     };
 
-    HPX_CXX_CORE_EXPORT template <typename R, typename Obj, typename... Ts>
+    template <typename R, typename Obj, typename... Ts>
     struct get_function_address<R (Obj::*)(Ts...) const>
     {
         static std::size_t call(R (Obj::*f)(Ts...) const) noexcept
diff --git a/libs/core/functional/include/hpx/functional/traits/is_action.hpp b/libs/core/functional/include/hpx/functional/traits/is_action.hpp
index 9cd1580cb18a..ad095fa27ccb 100644
--- a/libs/core/functional/include/hpx/functional/traits/is_action.hpp
+++ b/libs/core/functional/include/hpx/functional/traits/is_action.hpp
@@ -19,7 +19,7 @@ namespace hpx::traits {
         {
         };
 
-        HPX_CXX_CORE_EXPORT template <typename Action>
+        template <typename Action>
         struct is_action_impl<Action, std::void_t<typename Action::action_tag>>
           : std::true_type
         {
diff --git a/libs/core/functional/include/hpx/functional/traits/is_bind_expression.hpp b/libs/core/functional/include/hpx/functional/traits/is_bind_expression.hpp
index 96ea25594b85..725c7ff078bd 100644
--- a/libs/core/functional/include/hpx/functional/traits/is_bind_expression.hpp
+++ b/libs/core/functional/include/hpx/functional/traits/is_bind_expression.hpp
@@ -33,7 +33,7 @@ namespace hpx {
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename T>
+    template <typename T>
     struct is_bind_expression<T const> : is_bind_expression<T>
     {
     };
diff --git a/libs/core/functional/include/hpx/functional/traits/is_placeholder.hpp b/libs/core/functional/include/hpx/functional/traits/is_placeholder.hpp
index 979b9086c373..e09579f43e51 100644
--- a/libs/core/functional/include/hpx/functional/traits/is_placeholder.hpp
+++ b/libs/core/functional/include/hpx/functional/traits/is_placeholder.hpp
@@ -54,7 +54,7 @@ namespace hpx {
     };
 #endif
 
-    HPX_CXX_CORE_EXPORT template <typename T>
+    template <typename T>
     struct is_placeholder<T const> : is_placeholder<T>
     {
     };
diff --git a/libs/core/futures/include/hpx/futures/detail/future_data.hpp b/libs/core/futures/include/hpx/futures/detail/future_data.hpp
index 6d963ab0536a..f4c43613edd1 100644
--- a/libs/core/futures/include/hpx/futures/detail/future_data.hpp
+++ b/libs/core/futures/include/hpx/futures/detail/future_data.hpp
@@ -1125,7 +1125,7 @@ namespace hpx::lcos::detail {
     };
 }    // namespace hpx::lcos::detail
 
-HPX_CXX_CORE_EXPORT template <typename R, typename Allocator>
+template <typename R, typename Allocator>
 struct hpx::traits::detail::shared_state_allocator<
     hpx::lcos::detail::future_data<R>, Allocator>
 {
diff --git a/libs/core/futures/include/hpx/futures/future.hpp b/libs/core/futures/include/hpx/futures/future.hpp
index 6c777b0e3574..70d9e7d7d234 100644
--- a/libs/core/futures/include/hpx/futures/future.hpp
+++ b/libs/core/futures/include/hpx/futures/future.hpp
@@ -53,14 +53,14 @@ namespace hpx::lcos::detail {
     HPX_CXX_CORE_EXPORT template <typename Future, typename Enable = void>
     struct future_unwrap_result;
 
-    HPX_CXX_CORE_EXPORT template <template <typename> class Future, typename R>
+    template <template <typename> class Future, typename R>
     struct future_unwrap_result<Future<Future<R>>>
     {
         using type = R;
         using wrapped_type = Future<type>;
     };
 
-    HPX_CXX_CORE_EXPORT template <typename R>
+    template <typename R>
     struct future_unwrap_result<hpx::future<hpx::shared_future<R>>>
     {
         using type = R;
@@ -86,7 +86,7 @@ namespace hpx::lcos::detail {
         }
     };
 
-    HPX_CXX_CORE_EXPORT template <typename T>
+    template <typename T>
     struct future_value<T&> : future_data_result<T&>
     {
         HPX_FORCEINLINE static T& get(T* u) noexcept
@@ -150,7 +150,7 @@ namespace hpx::lcos::detail {
     using continuation_result_t =
         typename continuation_result<ContResult>::type;
 
-    HPX_CXX_CORE_EXPORT template <typename ContResult>
+    template <typename ContResult>
     struct continuation_result<hpx::future<ContResult>>
     {
         using type = ContResult;
diff --git a/libs/core/futures/include/hpx/futures/futures_factory.hpp b/libs/core/futures/include/hpx/futures/futures_factory.hpp
index dee90d02ce59..e7c622e9c60b 100644
--- a/libs/core/futures/include/hpx/futures/futures_factory.hpp
+++ b/libs/core/futures/include/hpx/futures/futures_factory.hpp
@@ -495,8 +495,7 @@ namespace hpx::lcos::local {
 
 namespace hpx::traits::detail {
 
-    HPX_CXX_CORE_EXPORT template <typename Result, typename F, typename Base,
-        typename Allocator>
+    template <typename Result, typename F, typename Base, typename Allocator>
     struct shared_state_allocator<
         lcos::local::detail::task_object<Result, F, void, Base>, Allocator>
     {
@@ -504,8 +503,7 @@ namespace hpx::traits::detail {
             Result, F, Base>;
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Result, typename F,
-        typename Allocator>
+    template <typename Result, typename F, typename Allocator>
     struct shared_state_allocator<
         lcos::local::detail::cancelable_task_object<Result, F, void>, Allocator>
     {
@@ -735,7 +733,7 @@ namespace hpx::lcos::local {
         };
     }    // namespace detail
 
-    HPX_CXX_CORE_EXPORT template <typename Result, bool Cancelable>
+    template <typename Result, bool Cancelable>
     class futures_factory<Result(), Cancelable>
     {
     protected:
diff --git a/libs/core/futures/include/hpx/futures/packaged_continuation.hpp b/libs/core/futures/include/hpx/futures/packaged_continuation.hpp
index a431e57989a0..cb686cad232e 100644
--- a/libs/core/futures/include/hpx/futures/packaged_continuation.hpp
+++ b/libs/core/futures/include/hpx/futures/packaged_continuation.hpp
@@ -385,8 +385,7 @@ namespace hpx::lcos::detail {
     };
 }    // namespace hpx::lcos::detail
 
-HPX_CXX_CORE_EXPORT template <typename Future, typename F, typename ContResult,
-    typename Allocator>
+template <typename Future, typename F, typename ContResult, typename Allocator>
 struct hpx::traits::detail::shared_state_allocator<
     hpx::lcos::detail::continuation<Future, F, ContResult>, Allocator>
 {
@@ -526,7 +525,7 @@ namespace hpx::lcos::detail {
     };
 }    // namespace hpx::lcos::detail
 
-HPX_CXX_CORE_EXPORT template <typename ContResult, typename Allocator>
+template <typename ContResult, typename Allocator>
 struct hpx::traits::detail::shared_state_allocator<
     hpx::lcos::detail::unwrap_continuation<ContResult>, Allocator>
 {
diff --git a/libs/core/futures/include/hpx/futures/packaged_task.hpp b/libs/core/futures/include/hpx/futures/packaged_task.hpp
index 505623788783..f1d83260a9d2 100644
--- a/libs/core/futures/include/hpx/futures/packaged_task.hpp
+++ b/libs/core/futures/include/hpx/futures/packaged_task.hpp
@@ -37,7 +37,7 @@ namespace hpx {
     HPX_CXX_CORE_EXPORT template <typename Sig>
     class packaged_task;
 
-    HPX_CXX_CORE_EXPORT template <typename R, typename... Ts>
+    template <typename R, typename... Ts>
     class packaged_task<R(Ts...)>
     {
         using function_type = hpx::move_only_function<R(Ts...)>;
@@ -151,7 +151,7 @@ namespace hpx {
 namespace std {    //-V1061
 
     // Requires: Allocator shall be an allocator (17.6.3.5)
-    HPX_CXX_CORE_EXPORT template <typename Sig, typename Allocator>
+    template <typename Sig, typename Allocator>
     struct uses_allocator<hpx::packaged_task<Sig>, Allocator> : std::true_type
     {
     };
diff --git a/libs/core/futures/include/hpx/futures/promise.hpp b/libs/core/futures/include/hpx/futures/promise.hpp
index ec54affab7ac..e40d1910cf4e 100644
--- a/libs/core/futures/include/hpx/futures/promise.hpp
+++ b/libs/core/futures/include/hpx/futures/promise.hpp
@@ -389,7 +389,7 @@ namespace hpx {
         using base_type::set_exception;
     };
 
-    HPX_CXX_CORE_EXPORT template <typename R>
+    template <typename R>
     class promise<R&> : public detail::promise_base<R&>
     {
         using base_type = detail::promise_base<R&>;
@@ -587,7 +587,7 @@ namespace hpx {
 namespace std {
 
     // Requires: Allocator shall be an allocator (17.6.3.5)
-    HPX_CXX_CORE_EXPORT template <typename R, typename Allocator>
+    template <typename R, typename Allocator>
     struct uses_allocator<hpx::promise<R>, Allocator> : std::true_type
     {
     };
diff --git a/libs/core/futures/include/hpx/futures/traits/acquire_future.hpp b/libs/core/futures/include/hpx/futures/traits/acquire_future.hpp
index 47c1a0009515..c7481732acd7 100644
--- a/libs/core/futures/include/hpx/futures/traits/acquire_future.hpp
+++ b/libs/core/futures/include/hpx/futures/traits/acquire_future.hpp
@@ -67,7 +67,7 @@ namespace hpx::traits {
         };
 
         ///////////////////////////////////////////////////////////////////////
-        HPX_CXX_CORE_EXPORT template <typename R>
+        template <typename R>
         struct acquire_future_impl<hpx::future<R>>
         {
             using type = hpx::future<R>;
@@ -85,7 +85,7 @@ namespace hpx::traits {
             }
         };
 
-        HPX_CXX_CORE_EXPORT template <typename R>
+        template <typename R>
         struct acquire_future_impl<hpx::shared_future<R>>
         {
             using type = hpx::shared_future<R>;
@@ -107,7 +107,7 @@ namespace hpx::traits {
         HPX_HAS_MEMBER_XXX_TRAIT_DEF(push_back)
 
         ///////////////////////////////////////////////////////////////////////
-        HPX_CXX_CORE_EXPORT template <typename Range>
+        template <typename Range>
         struct acquire_future_impl<Range,
             std::enable_if_t<hpx::traits::is_future_range_v<Range>>>
         {
diff --git a/libs/core/futures/include/hpx/futures/traits/future_access.hpp b/libs/core/futures/include/hpx/futures/traits/future_access.hpp
index 386813eaadfc..a5d51684ee0f 100644
--- a/libs/core/futures/include/hpx/futures/traits/future_access.hpp
+++ b/libs/core/futures/include/hpx/futures/traits/future_access.hpp
@@ -34,7 +34,7 @@ namespace hpx::traits {
             using type = Result;
         };
 
-        HPX_CXX_CORE_EXPORT template <typename Result>
+        template <typename Result>
         struct shared_state_ptr_result<Result&>
         {
             using type = Result&;
@@ -70,24 +70,24 @@ namespace hpx::traits {
         {
         };
 
-        HPX_CXX_CORE_EXPORT template <typename Future>
+        template <typename Future>
         struct shared_state_ptr_for<Future&> : shared_state_ptr_for<Future>
         {
         };
 
-        HPX_CXX_CORE_EXPORT template <typename Future>
+        template <typename Future>
         struct shared_state_ptr_for<Future&&> : shared_state_ptr_for<Future>
         {
         };
 
-        HPX_CXX_CORE_EXPORT template <typename Future>
+        template <typename Future>
         struct shared_state_ptr_for<std::vector<Future>>
         {
             using type =
                 std::vector<typename shared_state_ptr_for<Future>::type>;
         };
 
-        HPX_CXX_CORE_EXPORT template <typename Future, std::size_t N>
+        template <typename Future, std::size_t N>
         struct shared_state_ptr_for<std::array<Future, N>>
         {
             using type =
@@ -109,7 +109,7 @@ namespace hpx::traits {
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename R>
+    template <typename R>
     struct is_shared_state<
         hpx::intrusive_ptr<lcos::detail::future_data_base<R>>> : std::true_type
     {
@@ -130,7 +130,7 @@ namespace hpx::traits {
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename R>
+    template <typename R>
     struct future_access<hpx::future<R>>
     {
         template <typename SharedState>
@@ -200,7 +200,7 @@ namespace hpx::traits {
         }
     };
 
-    HPX_CXX_CORE_EXPORT template <typename R>
+    template <typename R>
     struct future_access<hpx::shared_future<R>>
     {
         template <typename SharedState>
diff --git a/libs/core/futures/include/hpx/futures/traits/future_traits.hpp b/libs/core/futures/include/hpx/futures/traits/future_traits.hpp
index 1e53ffb4c3e0..71085654fa28 100644
--- a/libs/core/futures/include/hpx/futures/traits/future_traits.hpp
+++ b/libs/core/futures/include/hpx/futures/traits/future_traits.hpp
@@ -28,29 +28,29 @@ namespace hpx::traits {
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Future>
+    template <typename Future>
     struct future_traits<Future const> : future_traits<Future>
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Future>
+    template <typename Future>
     struct future_traits<Future&> : future_traits<Future>
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Future>
+    template <typename Future>
     struct future_traits<Future const&> : future_traits<Future>
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename R>
+    template <typename R>
     struct future_traits<hpx::future<R>>
     {
         using type = R;
         using result_type = R;
     };
 
-    HPX_CXX_CORE_EXPORT template <typename R>
+    template <typename R>
     struct future_traits<hpx::shared_future<R>>
     {
         using type = R;
@@ -73,7 +73,7 @@ namespace hpx::traits {
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Future>
+    template <typename Future>
     struct is_future_void<Future, std::enable_if_t<is_future_v<Future>>>
       : std::is_void<future_traits_t<Future>>
     {
diff --git a/libs/core/futures/include/hpx/futures/traits/get_remote_result.hpp b/libs/core/futures/include/hpx/futures/traits/get_remote_result.hpp
index 9b2057c5c28f..033bd60c8465 100644
--- a/libs/core/futures/include/hpx/futures/traits/get_remote_result.hpp
+++ b/libs/core/futures/include/hpx/futures/traits/get_remote_result.hpp
@@ -27,7 +27,7 @@ namespace hpx::traits {
         }
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Result>
+    template <typename Result>
     struct get_remote_result<Result, Result>
     {
         static constexpr Result const& call(Result const& rhs) noexcept
diff --git a/libs/core/futures/include/hpx/futures/traits/is_future.hpp b/libs/core/futures/include/hpx/futures/traits/is_future.hpp
index 0668798f6871..391eb01b134b 100644
--- a/libs/core/futures/include/hpx/futures/traits/is_future.hpp
+++ b/libs/core/futures/include/hpx/futures/traits/is_future.hpp
@@ -22,7 +22,7 @@ namespace hpx::traits {
         {
         };
 
-        HPX_CXX_CORE_EXPORT template <typename R>
+        template <typename R>
         struct is_unique_future<hpx::future<R>> : std::true_type
         {
         };
@@ -35,12 +35,12 @@ namespace hpx::traits {
         {
         };
 
-        HPX_CXX_CORE_EXPORT template <typename R>
+        template <typename R>
         struct is_future_customization_point<hpx::future<R>> : std::true_type
         {
         };
 
-        HPX_CXX_CORE_EXPORT template <typename R>
+        template <typename R>
         struct is_future_customization_point<hpx::shared_future<R>>
           : std::true_type
         {
@@ -69,7 +69,7 @@ namespace hpx::traits {
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Future>
+    template <typename Future>
     struct is_ref_wrapped_future<std::reference_wrapper<Future>>
       : is_future<Future>
     {
diff --git a/libs/core/futures/include/hpx/futures/traits/is_future_range.hpp b/libs/core/futures/include/hpx/futures/traits/is_future_range.hpp
index 681ef4c1af45..413d567fd892 100644
--- a/libs/core/futures/include/hpx/futures/traits/is_future_range.hpp
+++ b/libs/core/futures/include/hpx/futures/traits/is_future_range.hpp
@@ -21,7 +21,7 @@ namespace hpx::traits {
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename R>
+    template <typename R>
     struct is_future_range<R, std::enable_if_t<std::ranges::range<R>>>
       : is_future<typename range_traits<R>::value_type>
     {
@@ -38,7 +38,7 @@ namespace hpx::traits {
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename R>
+    template <typename R>
     struct is_ref_wrapped_future_range<::std::reference_wrapper<R>>
       : is_future_range<R>
     {
@@ -59,7 +59,7 @@ namespace hpx::traits {
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename R>
+    template <typename R>
     struct future_range_traits<R, true>
     {
         using future_type = typename range_traits<R>::value_type;
diff --git a/libs/core/futures/include/hpx/futures/traits/is_future_tuple.hpp b/libs/core/futures/include/hpx/futures/traits/is_future_tuple.hpp
index 076875a5a998..51b28f79a7c2 100644
--- a/libs/core/futures/include/hpx/futures/traits/is_future_tuple.hpp
+++ b/libs/core/futures/include/hpx/futures/traits/is_future_tuple.hpp
@@ -19,7 +19,7 @@ namespace hpx::traits {
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename... Ts>
+    template <typename... Ts>
     struct is_future_tuple<hpx::tuple<Ts...>> : util::all_of<is_future<Ts>...>
     {
     };
diff --git a/libs/core/iostream/include/hpx/iostream/traits.hpp b/libs/core/iostream/include/hpx/iostream/traits.hpp
index 2fa8ebb39fb2..4c5ec26e2e2b 100644
--- a/libs/core/iostream/include/hpx/iostream/traits.hpp
+++ b/libs/core/iostream/include/hpx/iostream/traits.hpp
@@ -47,7 +47,7 @@ namespace hpx::iostream {
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Iter>
+    template <typename Iter>
     struct char_type_of<util::iterator_range<Iter>>
     {
         using type = typename std::iterator_traits<Iter>::value_type;
diff --git a/libs/core/iterator_support/include/hpx/iterator_support/counting_iterator.hpp b/libs/core/iterator_support/include/hpx/iterator_support/counting_iterator.hpp
index 51e51a15306e..8d607de67780 100644
--- a/libs/core/iterator_support/include/hpx/iterator_support/counting_iterator.hpp
+++ b/libs/core/iterator_support/include/hpx/iterator_support/counting_iterator.hpp
@@ -121,8 +121,8 @@ namespace hpx::util {
         }
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Incrementable,
-        typename CategoryOrTraversal, typename Difference>
+    template <typename Incrementable, typename CategoryOrTraversal,
+        typename Difference>
     class counting_iterator<Incrementable, CategoryOrTraversal, Difference,
         std::enable_if_t<std::is_integral_v<Incrementable>>>
       : public detail::counting_iterator_base<Incrementable,
diff --git a/libs/core/iterator_support/include/hpx/iterator_support/range.hpp b/libs/core/iterator_support/include/hpx/iterator_support/range.hpp
index 02ca4af94e56..06322015f7f1 100644
--- a/libs/core/iterator_support/include/hpx/iterator_support/range.hpp
+++ b/libs/core/iterator_support/include/hpx/iterator_support/range.hpp
@@ -182,7 +182,7 @@ namespace hpx::util {
         HPX_CXX_CORE_EXPORT template <typename T, typename Enable = void>
         inline constexpr bool has_size_v = false;
 
-        HPX_CXX_CORE_EXPORT template <typename T>
+        template <typename T>
         inline constexpr bool has_size_v<T,
             std::void_t<decltype(size(std::declval<T const&>()))>> = true;
 
@@ -203,7 +203,7 @@ namespace hpx::util {
         HPX_CXX_CORE_EXPORT template <typename T, typename Enable = void>
         inline constexpr bool has_empty_v = false;
 
-        HPX_CXX_CORE_EXPORT template <typename T>
+        template <typename T>
         inline constexpr bool has_empty_v<T,
             std::void_t<decltype(empty(std::declval<T const&>()))>> = true;
 
@@ -235,7 +235,7 @@ namespace hpx::util {
             using type = Iter;
         };
 
-        HPX_CXX_CORE_EXPORT template <typename T>
+        template <typename T>
         struct iterator<T, range_impl::fallback>
         {
         };
@@ -254,7 +254,7 @@ namespace hpx::util {
             using type = Iter;
         };
 
-        HPX_CXX_CORE_EXPORT template <typename T>
+        template <typename T>
         struct sentinel<T, range_impl::fallback>
         {
         };
@@ -275,7 +275,7 @@ namespace hpx::util {
             using type = R;
         };
 
-        HPX_CXX_CORE_EXPORT template <typename T>
+        template <typename T>
         struct subrange<T, range_impl::fallback>
         {
         };
@@ -294,7 +294,7 @@ namespace hpx::util {
             using type = R;
         };
 
-        HPX_CXX_CORE_EXPORT template <typename T>
+        template <typename T>
         struct iterate<T, range_impl::fallback>
         {
         };
@@ -388,8 +388,10 @@ namespace hpx::util {
     }    // namespace range_adl
 
     HPX_CXX_CORE_EXPORT using namespace range_adl;
+
     namespace detail {
-        HPX_CXX_CORE_EXPORT template <typename T>
+
+        template <typename T>
         struct is_range_generator<T,
             std::enable_if_t<std::ranges::range<decltype(hpx::util::iterate(
                 std::declval<T&>()))>>> : std::true_type
diff --git a/libs/core/iterator_support/include/hpx/iterator_support/traits/is_iterator.hpp b/libs/core/iterator_support/include/hpx/iterator_support/traits/is_iterator.hpp
index 24905aec1524..26e6e9ddc909 100644
--- a/libs/core/iterator_support/include/hpx/iterator_support/traits/is_iterator.hpp
+++ b/libs/core/iterator_support/include/hpx/iterator_support/traits/is_iterator.hpp
@@ -132,19 +132,19 @@ namespace hpx::traits {
         // robust concept checking). Here we provide a specialization to capture
         // this case, such that, bidirectional and random access iterators will
         // be properly recognized as satisfying the ForwardIterator concept.
-        HPX_CXX_CORE_EXPORT template <typename Iter>
+        template <typename Iter>
         struct satisfy_traversal_concept<Iter, hpx::forward_traversal_tag>
           : std::bool_constant<std::bidirectional_iterator<Iter>>
         {
         };
 
-        HPX_CXX_CORE_EXPORT template <typename Iter>
+        template <typename Iter>
         struct satisfy_traversal_concept<Iter, hpx::bidirectional_traversal_tag>
           : std::bool_constant<std::bidirectional_iterator<Iter>>
         {
         };
 
-        HPX_CXX_CORE_EXPORT template <typename Iter>
+        template <typename Iter>
         struct satisfy_traversal_concept<Iter, hpx::random_access_traversal_tag>
           : std::bool_constant<std::random_access_iterator<Iter>>
         {
@@ -176,7 +176,7 @@ namespace hpx::traits {
         {
         };
 
-        HPX_CXX_CORE_EXPORT template <typename Iter, typename Cat>
+        template <typename Iter, typename Cat>
         struct belongs_to_iterator_category<Iter, Cat,
             std::enable_if_t<is_iterator_v<Iter>>>
           : std::is_base_of<Cat, iter_category_t<Iter>>
@@ -194,7 +194,7 @@ namespace hpx::traits {
         {
         };
 
-        HPX_CXX_CORE_EXPORT template <typename Iter, typename Traversal>
+        template <typename Iter, typename Traversal>
         struct belongs_to_iterator_traversal<Iter, Traversal,
             std::enable_if_t<is_iterator_v<Iter>>>
           : std::integral_constant<bool,
@@ -215,7 +215,7 @@ namespace hpx::traits {
         {
         };
 
-        HPX_CXX_CORE_EXPORT template <typename Iter, typename Cat>
+        template <typename Iter, typename Cat>
         struct has_category<Iter, Cat, std::enable_if_t<is_iterator_v<Iter>>>
           : std::is_same<Cat, iter_category_t<Iter>>
         {
@@ -240,14 +240,14 @@ namespace hpx::traits {
         {
         };
 
-        HPX_CXX_CORE_EXPORT template <typename Iter, typename Traversal>
+        template <typename Iter, typename Traversal>
         struct has_traversal<Iter, Traversal,
             std::enable_if_t<is_iterator_v<Iter>>>
           : std::is_same<Traversal, hpx::traits::iterator_traversal_t<Iter>>
         {
         };
 
-        HPX_CXX_CORE_EXPORT template <typename Iter>
+        template <typename Iter>
         struct has_traversal<Iter, hpx::bidirectional_traversal_tag,
             std::enable_if_t<is_iterator_v<Iter>>>
           : std::integral_constant<bool,
@@ -260,7 +260,7 @@ namespace hpx::traits {
         {
         };
 
-        HPX_CXX_CORE_EXPORT template <typename Iter>
+        template <typename Iter>
         struct has_traversal<Iter, hpx::random_access_traversal_tag,
             std::enable_if_t<is_iterator_v<Iter>>>
           : std::integral_constant<bool,
diff --git a/libs/core/iterator_support/include/hpx/iterator_support/traits/is_range.hpp b/libs/core/iterator_support/include/hpx/iterator_support/traits/is_range.hpp
index ad16e6d5b0c6..5e93dfbbcc3e 100644
--- a/libs/core/iterator_support/include/hpx/iterator_support/traits/is_range.hpp
+++ b/libs/core/iterator_support/include/hpx/iterator_support/traits/is_range.hpp
@@ -37,7 +37,7 @@ namespace hpx::traits {
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename R>
+    template <typename R>
     struct range_traits<R, true>
       : std::iterator_traits<typename util::detail::iterator<R>::type>
     {
diff --git a/libs/core/iterator_support/include/hpx/iterator_support/zip_iterator.hpp b/libs/core/iterator_support/include/hpx/iterator_support/zip_iterator.hpp
index 8649894b8703..57857ff996d6 100644
--- a/libs/core/iterator_support/include/hpx/iterator_support/zip_iterator.hpp
+++ b/libs/core/iterator_support/include/hpx/iterator_support/zip_iterator.hpp
@@ -41,7 +41,7 @@ namespace hpx::util {
             using type = hpx::util::unused_type;
         };
 
-        HPX_CXX_CORE_EXPORT template <typename... Ts>
+        template <typename... Ts>
         struct zip_iterator_value<hpx::tuple<Ts...>>
         {
             using type =
@@ -64,7 +64,7 @@ namespace hpx::util {
             using type = hpx::util::unused_type;
         };
 
-        HPX_CXX_CORE_EXPORT template <typename... Ts>
+        template <typename... Ts>
         struct zip_iterator_reference<hpx::tuple<Ts...>>
         {
             using type =
@@ -88,14 +88,14 @@ namespace hpx::util {
             using type = std::random_access_iterator_tag;
         };
 
-        HPX_CXX_CORE_EXPORT template <typename T>
+        template <typename T>
         struct zip_iterator_category<hpx::tuple<T>,
             std::enable_if_t<hpx::tuple_size<hpx::tuple<T>>::value == 1>>
         {
             using type = typename zip_iterator_element_category<T>::type;
         };
 
-        HPX_CXX_CORE_EXPORT template <typename T, typename U>
+        template <typename T, typename U>
         struct zip_iterator_category<hpx::tuple<T, U>,
             std::enable_if_t<hpx::tuple_size<hpx::tuple<T, U>>::value == 2>>
           : minimum_category<typename zip_iterator_element_category<T>::type,
@@ -103,7 +103,7 @@ namespace hpx::util {
         {
         };
 
-        HPX_CXX_CORE_EXPORT template <typename T, typename U, typename... Tail>
+        template <typename T, typename U, typename... Tail>
         struct zip_iterator_category<hpx::tuple<T, U, Tail...>,
             std::enable_if_t<(
                 hpx::tuple_size<hpx::tuple<T, U, Tail...>>::value > 2)>>
@@ -119,7 +119,7 @@ namespace hpx::util {
         HPX_CXX_CORE_EXPORT template <typename IteratorTuple>
         struct dereference_iterator;
 
-        HPX_CXX_CORE_EXPORT template <typename... Ts>
+        template <typename... Ts>
         struct dereference_iterator<hpx::tuple<Ts...>>
         {
             template <std::size_t... Is>
@@ -176,7 +176,7 @@ namespace hpx::util {
         {
         };
 
-        HPX_CXX_CORE_EXPORT template <typename... Ts>
+        template <typename... Ts>
         struct has_default_sentinel<hpx::tuple<Ts...>>
           : util::any_of<has_default_sentinel<Ts>...>
         {
@@ -199,7 +199,7 @@ namespace hpx::util {
             }
         };
 
-        HPX_CXX_CORE_EXPORT template <std::size_t I, std::size_t Size>
+        template <std::size_t I, std::size_t Size>
         struct one_tuple_element_equal_to<I, Size,
             std::enable_if_t<I + 1 == Size>>
         {
@@ -443,7 +443,7 @@ namespace hpx::util {
     }
 
     ///////////////////////////////////////////////////////////////////////////
-    HPX_CXX_CORE_EXPORT template <typename... Ts>
+    template <typename... Ts>
     class zip_iterator<hpx::tuple<Ts...>>
       : public detail::zip_iterator_base<hpx::tuple<Ts...>,
             zip_iterator<hpx::tuple<Ts...>>>
@@ -526,7 +526,7 @@ namespace hpx::traits {
         HPX_CXX_CORE_EXPORT template <typename F, typename Iter>
         struct lift_zipped_iterators;
 
-        HPX_CXX_CORE_EXPORT template <typename F, typename... Ts>
+        template <typename F, typename... Ts>
         struct lift_zipped_iterators<F, util::zip_iterator<Ts...>>
         {
             using tuple_type =
@@ -553,7 +553,7 @@ namespace hpx::traits {
     }    // namespace functional
 
     ///////////////////////////////////////////////////////////////////////////
-    HPX_CXX_CORE_EXPORT template <typename... Iter>
+    template <typename... Iter>
     struct is_zip_iterator<hpx::util::zip_iterator<Iter...>> : std::true_type
     {
     };
diff --git a/libs/core/lcos_local/include/hpx/lcos_local/detail/preprocess_future.hpp b/libs/core/lcos_local/include/hpx/lcos_local/detail/preprocess_future.hpp
index 6057a834f469..caf1055771a6 100644
--- a/libs/core/lcos_local/include/hpx/lcos_local/detail/preprocess_future.hpp
+++ b/libs/core/lcos_local/include/hpx/lcos_local/detail/preprocess_future.hpp
@@ -195,15 +195,17 @@ namespace hpx::serialization::detail {
     };
 }    // namespace hpx::serialization::detail
 
-// This is explicitly instantiated to ensure that the id is stable across
-// shared libraries.
-template <>
-struct hpx::util::extra_data_helper<
-    hpx::serialization::detail::preprocess_futures>
-{
-    HPX_CORE_EXPORT static hpx::util::extra_data_id_type id() noexcept;
-    static constexpr void reset(
-        hpx::serialization::detail::preprocess_futures*) noexcept
+namespace hpx::util {
+
+    // This is explicitly instantiated to ensure that the id is stable across
+    // shared libraries.
+    template <>
+    struct extra_data_helper<hpx::serialization::detail::preprocess_futures>
     {
-    }
-};
+        HPX_CORE_EXPORT static hpx::util::extra_data_id_type id() noexcept;
+        static constexpr void reset(
+            hpx::serialization::detail::preprocess_futures*) noexcept
+        {
+        }
+    };
+}    // namespace hpx::util
diff --git a/libs/core/lcos_local/include/hpx/lcos_local/receive_buffer.hpp b/libs/core/lcos_local/include/hpx/lcos_local/receive_buffer.hpp
index 66745bba4b84..57b36d80742d 100644
--- a/libs/core/lcos_local/include/hpx/lcos_local/receive_buffer.hpp
+++ b/libs/core/lcos_local/include/hpx/lcos_local/receive_buffer.hpp
@@ -243,7 +243,7 @@ namespace hpx::lcos::local {
     };
 
     ///////////////////////////////////////////////////////////////////////////
-    HPX_CXX_CORE_EXPORT template <typename Mutex>
+    template <typename Mutex>
     struct receive_buffer<void, Mutex>
     {
     protected:
diff --git a/libs/core/memory/include/hpx/memory/intrusive_ptr.hpp b/libs/core/memory/include/hpx/memory/intrusive_ptr.hpp
index 4d932841b8bb..68b8e6d02634 100644
--- a/libs/core/memory/include/hpx/memory/intrusive_ptr.hpp
+++ b/libs/core/memory/include/hpx/memory/intrusive_ptr.hpp
@@ -351,7 +351,7 @@ namespace hpx {
 }    // namespace hpx
 
 // support hashing
-HPX_CXX_CORE_EXPORT template <typename T>
+template <typename T>
 struct std::hash<::hpx::intrusive_ptr<T>>
 {
     using result_type = std::size_t;
diff --git a/libs/core/pack_traversal/include/hpx/pack_traversal/detail/pack_traversal_async_impl.hpp b/libs/core/pack_traversal/include/hpx/pack_traversal/detail/pack_traversal_async_impl.hpp
index 0dba128c1a5a..5018a81eb73e 100644
--- a/libs/core/pack_traversal/include/hpx/pack_traversal/detail/pack_traversal_async_impl.hpp
+++ b/libs/core/pack_traversal/include/hpx/pack_traversal/detail/pack_traversal_async_impl.hpp
@@ -229,8 +229,7 @@ namespace hpx::util::detail {
 
 namespace hpx::traits::detail {
 
-    HPX_CXX_CORE_EXPORT template <typename Visitor, typename... Args,
-        typename Allocator>
+    template <typename Visitor, typename... Args, typename Allocator>
     struct shared_state_allocator<
         util::detail::async_traversal_frame<Visitor, Args...>, Allocator>
     {
diff --git a/libs/core/pack_traversal/include/hpx/pack_traversal/detail/pack_traversal_impl.hpp b/libs/core/pack_traversal/include/hpx/pack_traversal/detail/pack_traversal_impl.hpp
index c439e0d5560f..d12261799d78 100644
--- a/libs/core/pack_traversal/include/hpx/pack_traversal/detail/pack_traversal_impl.hpp
+++ b/libs/core/pack_traversal/include/hpx/pack_traversal/detail/pack_traversal_impl.hpp
@@ -340,7 +340,7 @@ namespace hpx::util::detail {
         {
         };
 
-        HPX_CXX_CORE_EXPORT template <typename T, typename E>
+        template <typename T, typename E>
         struct has_push_back<T, E,
             std::void_t<decltype(std::declval<T>().push_back(
                 std::declval<E>()))>> : std::true_type
diff --git a/libs/core/pack_traversal/include/hpx/pack_traversal/traits/pack_traversal_rebind_container.hpp b/libs/core/pack_traversal/include/hpx/pack_traversal/traits/pack_traversal_rebind_container.hpp
index f132e65f13af..4acc32c83282 100644
--- a/libs/core/pack_traversal/include/hpx/pack_traversal/traits/pack_traversal_rebind_container.hpp
+++ b/libs/core/pack_traversal/include/hpx/pack_traversal/traits/pack_traversal_rebind_container.hpp
@@ -77,8 +77,7 @@ namespace hpx::traits {
     // gcc reports an ambiguity for any standard container that has a defaulted
     // allocator template argument as it believes both specializations above are
     // viable. This works around by explicitly specializing the trait.
-    HPX_CXX_CORE_EXPORT template <typename NewType, typename OldType,
-        typename OldAllocator>
+    template <typename NewType, typename OldType, typename OldAllocator>
     struct pack_traversal_rebind_container<NewType,
         std::vector<OldType, OldAllocator>>
     {
@@ -95,8 +94,7 @@ namespace hpx::traits {
         }
     };
 
-    HPX_CXX_CORE_EXPORT template <typename NewType, typename OldType,
-        typename OldAllocator>
+    template <typename NewType, typename OldType, typename OldAllocator>
     struct pack_traversal_rebind_container<NewType,
         std::list<OldType, OldAllocator>>
     {
@@ -113,8 +111,7 @@ namespace hpx::traits {
         }
     };
 
-    HPX_CXX_CORE_EXPORT template <typename NewType, typename OldType,
-        std::size_t N>
+    template <typename NewType, typename OldType, std::size_t N>
     struct pack_traversal_rebind_container<NewType, std::array<OldType, N>>
     {
         static std::array<NewType, N> call(
diff --git a/libs/core/plugin/include/hpx/plugin/abstract_factory.hpp b/libs/core/plugin/include/hpx/plugin/abstract_factory.hpp
index 800e7371f23f..aee93e11c000 100644
--- a/libs/core/plugin/include/hpx/plugin/abstract_factory.hpp
+++ b/libs/core/plugin/include/hpx/plugin/abstract_factory.hpp
@@ -29,8 +29,7 @@ namespace hpx::util::plugin {
             typename Parameter>
         struct HPX_PLUGIN_EXPORT_API abstract_factory_item;
 
-        HPX_CXX_CORE_EXPORT template <typename BasePlugin, typename Base,
-            typename... Parameters>
+        template <typename BasePlugin, typename Base, typename... Parameters>
         struct HPX_PLUGIN_EXPORT_API abstract_factory_item<BasePlugin, Base,
             hpx::util::pack<Parameters...>> : public Base
         {
diff --git a/libs/core/plugin/include/hpx/plugin/concrete_factory.hpp b/libs/core/plugin/include/hpx/plugin/concrete_factory.hpp
index ff1db19ce3df..204458c30a71 100644
--- a/libs/core/plugin/include/hpx/plugin/concrete_factory.hpp
+++ b/libs/core/plugin/include/hpx/plugin/concrete_factory.hpp
@@ -21,8 +21,8 @@ namespace hpx::util::plugin {
             typename Base, typename Parameter>
         struct HPX_PLUGIN_EXPORT_API concrete_factory_item;
 
-        HPX_CXX_CORE_EXPORT template <typename BasePlugin, typename Concrete,
-            typename Base, typename... Parameters>
+        template <typename BasePlugin, typename Concrete, typename Base,
+            typename... Parameters>
         struct HPX_PLUGIN_EXPORT_API concrete_factory_item<BasePlugin, Concrete,
             Base, hpx::util::pack<Parameters...>> : public Base
         {
diff --git a/libs/core/plugin/include/hpx/plugin/plugin_factory.hpp b/libs/core/plugin/include/hpx/plugin/plugin_factory.hpp
index 8a732c46afa6..bf2eca4360a2 100644
--- a/libs/core/plugin/include/hpx/plugin/plugin_factory.hpp
+++ b/libs/core/plugin/include/hpx/plugin/plugin_factory.hpp
@@ -188,8 +188,7 @@ namespace hpx::util::plugin {
             typename Parameters>
         struct HPX_PLUGIN_EXPORT_API plugin_factory_item;
 
-        HPX_CXX_CORE_EXPORT template <typename BasePlugin, typename Base,
-            typename... Parameters>
+        template <typename BasePlugin, typename Base, typename... Parameters>
         struct HPX_PLUGIN_EXPORT_API plugin_factory_item<BasePlugin, Base,
             hpx::util::pack<Parameters...>> : public Base
         {
@@ -256,8 +255,7 @@ namespace hpx::util::plugin {
             typename Parameters>
         struct HPX_PLUGIN_EXPORT_API static_plugin_factory_item;
 
-        HPX_CXX_CORE_EXPORT template <typename BasePlugin, typename Base,
-            typename... Parameters>
+        template <typename BasePlugin, typename Base, typename... Parameters>
         struct HPX_PLUGIN_EXPORT_API static_plugin_factory_item<BasePlugin,
             Base, hpx::util::pack<Parameters...>> : public Base
         {
diff --git a/libs/core/resiliency/include/hpx/resiliency/async_replay_executor.hpp b/libs/core/resiliency/include/hpx/resiliency/async_replay_executor.hpp
index 17db6f64fd6d..20870d5a8312 100644
--- a/libs/core/resiliency/include/hpx/resiliency/async_replay_executor.hpp
+++ b/libs/core/resiliency/include/hpx/resiliency/async_replay_executor.hpp
@@ -127,7 +127,7 @@ namespace hpx::resiliency::experimental {
         };
 
         ///////////////////////////////////////////////////////////////////////
-        HPX_CXX_CORE_EXPORT template <typename Pred, typename F, typename Tuple>
+        template <typename Pred, typename F, typename Tuple>
         struct async_replay_executor_helper<void, Pred, F, Tuple>
           : std::enable_shared_from_this<
                 async_replay_executor_helper<void, Pred, F, Tuple>>
diff --git a/libs/core/resiliency/include/hpx/resiliency/replay_executor.hpp b/libs/core/resiliency/include/hpx/resiliency/replay_executor.hpp
index f7794bcd8dbe..c0e758ce71e9 100644
--- a/libs/core/resiliency/include/hpx/resiliency/replay_executor.hpp
+++ b/libs/core/resiliency/include/hpx/resiliency/replay_executor.hpp
@@ -223,14 +223,14 @@ namespace hpx::resiliency::experimental {
 
 namespace hpx::execution::experimental {
 
-    HPX_CXX_CORE_EXPORT template <typename BaseExecutor, typename Validator>
+    template <typename BaseExecutor, typename Validator>
     struct is_two_way_executor<
         hpx::resiliency::experimental::replay_executor<BaseExecutor, Validator>>
       : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename BaseExecutor, typename Validator>
+    template <typename BaseExecutor, typename Validator>
     struct is_bulk_two_way_executor<
         hpx::resiliency::experimental::replay_executor<BaseExecutor, Validator>>
       : std::true_type
diff --git a/libs/core/resiliency/include/hpx/resiliency/replicate_executor.hpp b/libs/core/resiliency/include/hpx/resiliency/replicate_executor.hpp
index 28e5be684eec..7228ed8260c8 100644
--- a/libs/core/resiliency/include/hpx/resiliency/replicate_executor.hpp
+++ b/libs/core/resiliency/include/hpx/resiliency/replicate_executor.hpp
@@ -251,15 +251,13 @@ namespace hpx::resiliency::experimental {
 
 namespace hpx::execution::experimental {
 
-    HPX_CXX_CORE_EXPORT template <typename BaseExecutor, typename Voter,
-        typename Validator>
+    template <typename BaseExecutor, typename Voter, typename Validator>
     struct is_two_way_executor<hpx::resiliency::experimental::
             replicate_executor<BaseExecutor, Voter, Validator>> : std::true_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename BaseExecutor, typename Voter,
-        typename Validator>
+    template <typename BaseExecutor, typename Voter, typename Validator>
     struct is_bulk_two_way_executor<hpx::resiliency::experimental::
             replicate_executor<BaseExecutor, Voter, Validator>> : std::true_type
     {
diff --git a/libs/core/serialization/include/hpx/serialization/base_object.hpp b/libs/core/serialization/include/hpx/serialization/base_object.hpp
index 11a2c2cd1e70..84374bfd25c1 100644
--- a/libs/core/serialization/include/hpx/serialization/base_object.hpp
+++ b/libs/core/serialization/include/hpx/serialization/base_object.hpp
@@ -88,7 +88,7 @@ namespace hpx::serialization {
 
     // we need another specialization to explicitly specify non-virtual calls of
     // virtual functions in intrusively serialized base classes.
-    HPX_CXX_CORE_EXPORT template <typename Derived, typename Base>
+    template <typename Derived, typename Base>
     struct base_object_type<Derived, Base,
         std::enable_if_t<hpx::traits::is_intrusive_polymorphic_v<Derived>>>
     {
diff --git a/libs/core/serialization/include/hpx/serialization/complex.hpp b/libs/core/serialization/include/hpx/serialization/complex.hpp
index 85665c770685..79e88b55893f 100644
--- a/libs/core/serialization/include/hpx/serialization/complex.hpp
+++ b/libs/core/serialization/include/hpx/serialization/complex.hpp
@@ -35,13 +35,13 @@ namespace hpx::serialization {
 
 namespace hpx::traits {
 
-    HPX_CXX_CORE_EXPORT template <typename T>
+    template <typename T>
     struct is_bitwise_serializable<std::complex<T>>
       : is_bitwise_serializable<std::remove_const_t<T>>
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename T>
+    template <typename T>
     struct is_not_bitwise_serializable<std::complex<T>>
       : std::integral_constant<bool,
             !is_bitwise_serializable_v<std::complex<T>>>
diff --git a/libs/core/serialization/include/hpx/serialization/detail/polymorphic_id_factory.hpp b/libs/core/serialization/include/hpx/serialization/detail/polymorphic_id_factory.hpp
index 37a7ceae1312..75b1b208e72a 100644
--- a/libs/core/serialization/include/hpx/serialization/detail/polymorphic_id_factory.hpp
+++ b/libs/core/serialization/include/hpx/serialization/detail/polymorphic_id_factory.hpp
@@ -126,7 +126,7 @@ namespace hpx::serialization::detail {
         friend struct hpx::util::static_<polymorphic_id_factory>;
     };
 
-    HPX_CXX_CORE_EXPORT template <typename T>
+    template <typename T>
     struct register_class_name<T,
         std::enable_if_t<traits::is_serialized_with_id_v<T>>>
     {
diff --git a/libs/core/serialization/include/hpx/serialization/map.hpp b/libs/core/serialization/include/hpx/serialization/map.hpp
index 6190c639463f..ef405ece9706 100644
--- a/libs/core/serialization/include/hpx/serialization/map.hpp
+++ b/libs/core/serialization/include/hpx/serialization/map.hpp
@@ -23,7 +23,7 @@
 
 namespace hpx::traits {
 
-    HPX_CXX_CORE_EXPORT template <typename Key, typename Value>
+    template <typename Key, typename Value>
     struct is_bitwise_serializable<std::pair<Key, Value>>
       : std::integral_constant<bool,
             is_bitwise_serializable_v<std::remove_const_t<Key>> &&
@@ -31,7 +31,7 @@ namespace hpx::traits {
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Key, typename Value>
+    template <typename Key, typename Value>
     struct is_not_bitwise_serializable<std::pair<Key, Value>>
       : std::integral_constant<bool,
             !is_bitwise_serializable_v<std::pair<Key, Value>>>
diff --git a/libs/core/serialization/include/hpx/serialization/serialize_buffer.hpp b/libs/core/serialization/include/hpx/serialization/serialize_buffer.hpp
index aa6a80ece935..5a18a1dbba54 100644
--- a/libs/core/serialization/include/hpx/serialization/serialize_buffer.hpp
+++ b/libs/core/serialization/include/hpx/serialization/serialize_buffer.hpp
@@ -33,7 +33,7 @@ namespace hpx::serialization {
             }
         };
 
-        HPX_CXX_CORE_EXPORT template <typename T>
+        template <typename T>
         struct array_allocator<std::allocator<T>>
         {
             T* operator()(std::allocator<T>, std::size_t size) const
@@ -54,7 +54,7 @@ namespace hpx::serialization {
             }
         };
 
-        HPX_CXX_CORE_EXPORT template <typename T>
+        template <typename T>
         struct array_deleter<std::allocator<T>>
         {
             void operator()(
diff --git a/libs/core/serialization/include/hpx/serialization/std_tuple.hpp b/libs/core/serialization/include/hpx/serialization/std_tuple.hpp
index d8b19818685f..fb358f3a50bf 100644
--- a/libs/core/serialization/include/hpx/serialization/std_tuple.hpp
+++ b/libs/core/serialization/include/hpx/serialization/std_tuple.hpp
@@ -20,14 +20,14 @@
 
 namespace hpx::traits {
 
-    HPX_CXX_CORE_EXPORT template <typename... Ts>
+    template <typename... Ts>
     struct is_bitwise_serializable<std::tuple<Ts...>>
       : ::hpx::util::all_of<
             hpx::traits::is_bitwise_serializable<std::remove_const_t<Ts>>...>
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename... Ts>
+    template <typename... Ts>
     struct is_not_bitwise_serializable<std::tuple<Ts...>>
       : std::integral_constant<bool,
             !is_bitwise_serializable_v<std::tuple<Ts...>>>
@@ -43,8 +43,7 @@ namespace hpx::serialization {
             typename... Ts>
         struct std_serialize_with_index_pack;
 
-        HPX_CXX_CORE_EXPORT template <typename Archive, std::size_t... Is,
-            typename... Ts>
+        template <typename Archive, std::size_t... Is, typename... Ts>
         struct std_serialize_with_index_pack<Archive,
             hpx::util::index_pack<Is...>, Ts...>
         {
diff --git a/libs/core/serialization/include/hpx/serialization/traits/serialization_access_data.hpp b/libs/core/serialization/include/hpx/serialization/traits/serialization_access_data.hpp
index 31f35600e79b..e1c819a9c674 100644
--- a/libs/core/serialization/include/hpx/serialization/traits/serialization_access_data.hpp
+++ b/libs/core/serialization/include/hpx/serialization/traits/serialization_access_data.hpp
@@ -157,7 +157,7 @@ namespace hpx::traits {
         }
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Container>
+    template <typename Container>
     struct serialization_access_data<Container const>
       : serialization_access_data<Container>
     {
diff --git a/libs/core/serialization/include/hpx/serialization/variant.hpp b/libs/core/serialization/include/hpx/serialization/variant.hpp
index 098bc7017737..44f067b452f3 100644
--- a/libs/core/serialization/include/hpx/serialization/variant.hpp
+++ b/libs/core/serialization/include/hpx/serialization/variant.hpp
@@ -48,7 +48,7 @@ namespace hpx::serialization {
         HPX_CXX_CORE_EXPORT template <typename... Ts>
         struct std_variant_impl;
 
-        HPX_CXX_CORE_EXPORT template <typename T, typename... Ts>
+        template <typename T, typename... Ts>
         struct std_variant_impl<T, Ts...>
         {
             template <typename V>
diff --git a/libs/core/string_util/include/hpx/string_util/token_functions.hpp b/libs/core/string_util/include/hpx/string_util/token_functions.hpp
index a11c43e3bc95..801498701b51 100644
--- a/libs/core/string_util/include/hpx/string_util/token_functions.hpp
+++ b/libs/core/string_util/include/hpx/string_util/token_functions.hpp
@@ -237,7 +237,7 @@ namespace hpx::string_util {
             }
         };
 
-        HPX_CXX_CORE_EXPORT template <typename Traits>
+        template <typename Traits>
         struct traits_extension_details<Traits, 1> : public Traits
         {
             using char_type = typename Traits::char_type;
diff --git a/libs/core/synchronization/include/hpx/synchronization/async_rw_mutex.hpp b/libs/core/synchronization/include/hpx/synchronization/async_rw_mutex.hpp
index 4268e7cb17b8..b52c1d601a03 100644
--- a/libs/core/synchronization/include/hpx/synchronization/async_rw_mutex.hpp
+++ b/libs/core/synchronization/include/hpx/synchronization/async_rw_mutex.hpp
@@ -158,7 +158,7 @@ namespace hpx::experimental {
             async_rw_mutex_access_type AccessType>
         struct async_rw_mutex_access_wrapper;
 
-        HPX_CXX_CORE_EXPORT template <typename ReadWriteT, typename ReadT>
+        template <typename ReadWriteT, typename ReadT>
         struct async_rw_mutex_access_wrapper<ReadWriteT, ReadT,
             async_rw_mutex_access_type::read>
         {
@@ -197,7 +197,7 @@ namespace hpx::experimental {
             }
         };
 
-        HPX_CXX_CORE_EXPORT template <typename ReadWriteT, typename ReadT>
+        template <typename ReadWriteT, typename ReadT>
         struct async_rw_mutex_access_wrapper<ReadWriteT, ReadT,
             async_rw_mutex_access_type::readwrite>
         {
@@ -357,7 +357,7 @@ namespace hpx::experimental {
     // The protected value is moved from state to state and is released when the
     // last shared state is destroyed.
 
-    HPX_CXX_CORE_EXPORT template <typename Allocator>
+    template <typename Allocator>
     class async_rw_mutex<void, void, Allocator>
     {
     private:
diff --git a/libs/core/synchronization/include/hpx/synchronization/channel_mpsc.hpp b/libs/core/synchronization/include/hpx/synchronization/channel_mpsc.hpp
index f427b57e05f9..cbbece6a2a64 100644
--- a/libs/core/synchronization/include/hpx/synchronization/channel_mpsc.hpp
+++ b/libs/core/synchronization/include/hpx/synchronization/channel_mpsc.hpp
@@ -233,7 +233,7 @@ namespace hpx::lcos::local {
         std::atomic<bool> closed_;
     };
 
-    HPX_CXX_CORE_EXPORT template <typename T, typename Mutex>
+    template <typename T, typename Mutex>
     class base_channel_mpsc<T, Mutex, channel_mode::dont_support_close>
     {
     private:
diff --git a/libs/core/synchronization/include/hpx/synchronization/channel_spsc.hpp b/libs/core/synchronization/include/hpx/synchronization/channel_spsc.hpp
index 87db30fc1f63..451cae34979a 100644
--- a/libs/core/synchronization/include/hpx/synchronization/channel_spsc.hpp
+++ b/libs/core/synchronization/include/hpx/synchronization/channel_spsc.hpp
@@ -245,7 +245,7 @@ namespace hpx::lcos::local {
     // Same as above, except that the channel doesn't support close(). This is
     // an optimization that can be applied in use cases where the surrounding
     // code ensures that the channel is always in proper state.
-    HPX_CXX_CORE_EXPORT template <typename T>
+    template <typename T>
     class channel_spsc<T, channel_mode::dont_support_close>
     {
     private:
diff --git a/libs/core/tag_invoke/include/hpx/functional/detail/tag_fallback_invoke.hpp b/libs/core/tag_invoke/include/hpx/functional/detail/tag_fallback_invoke.hpp
index be1114fc0c95..1d80c299dfd5 100644
--- a/libs/core/tag_invoke/include/hpx/functional/detail/tag_fallback_invoke.hpp
+++ b/libs/core/tag_invoke/include/hpx/functional/detail/tag_fallback_invoke.hpp
@@ -173,12 +173,12 @@ namespace hpx::functional::detail {
     HPX_CXX_CORE_EXPORT template <typename Sig, bool Invocable>
     struct is_nothrow_tag_fallback_invocable_impl;
 
-    HPX_CXX_CORE_EXPORT template <typename Sig>
+    template <typename Sig>
     struct is_nothrow_tag_fallback_invocable_impl<Sig, false> : std::false_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Tag, typename... Args>
+    template <typename Tag, typename... Args>
     struct is_nothrow_tag_fallback_invocable_impl<
         decltype(tag_fallback_invoke_ns::tag_fallback_invoke)(Tag, Args...),
         true>
diff --git a/libs/core/tag_invoke/include/hpx/functional/detail/tag_priority_invoke.hpp b/libs/core/tag_invoke/include/hpx/functional/detail/tag_priority_invoke.hpp
index f166573525f6..bfd647edcc7f 100644
--- a/libs/core/tag_invoke/include/hpx/functional/detail/tag_priority_invoke.hpp
+++ b/libs/core/tag_invoke/include/hpx/functional/detail/tag_priority_invoke.hpp
@@ -175,12 +175,12 @@ namespace hpx::functional::detail {
     HPX_CXX_CORE_EXPORT template <typename Sig, bool Invocable>
     struct is_nothrow_tag_override_invocable_impl;
 
-    HPX_CXX_CORE_EXPORT template <typename Sig>
+    template <typename Sig>
     struct is_nothrow_tag_override_invocable_impl<Sig, false> : std::false_type
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename Tag, typename... Args>
+    template <typename Tag, typename... Args>
     struct is_nothrow_tag_override_invocable_impl<
         decltype(tag_override_invoke_ns::tag_override_invoke)(Tag, Args...),
         true>
diff --git a/libs/core/tag_invoke/include/hpx/functional/tag_invoke.hpp b/libs/core/tag_invoke/include/hpx/functional/tag_invoke.hpp
index bf0af342482b..013c328488c8 100644
--- a/libs/core/tag_invoke/include/hpx/functional/tag_invoke.hpp
+++ b/libs/core/tag_invoke/include/hpx/functional/tag_invoke.hpp
@@ -172,12 +172,12 @@ namespace hpx::functional {
         HPX_CXX_CORE_EXPORT template <typename Sig, bool Invocable>
         struct is_nothrow_tag_invocable_impl;
 
-        HPX_CXX_CORE_EXPORT template <typename Sig>
+        template <typename Sig>
         struct is_nothrow_tag_invocable_impl<Sig, false> : std::false_type
         {
         };
 
-        HPX_CXX_CORE_EXPORT template <typename Tag, typename... Args>
+        template <typename Tag, typename... Args>
         struct is_nothrow_tag_invocable_impl<
             decltype(tag_invoke_ns::tag_invoke)(Tag, Args...), true>
           : std::integral_constant<bool,
diff --git a/libs/core/tag_invoke/include/hpx/functional/traits/is_invocable.hpp b/libs/core/tag_invoke/include/hpx/functional/traits/is_invocable.hpp
index d6a057324d41..9035a00ffcc4 100644
--- a/libs/core/tag_invoke/include/hpx/functional/traits/is_invocable.hpp
+++ b/libs/core/tag_invoke/include/hpx/functional/traits/is_invocable.hpp
@@ -108,7 +108,7 @@ namespace hpx {
         {
         };
 
-        HPX_CXX_CORE_EXPORT template <typename F, typename... Ts>
+        template <typename F, typename... Ts>
         struct is_nothrow_invocable_impl<F(Ts...), true>
           : std::integral_constant<bool,
                 noexcept(std::declval<F>()(std::declval<Ts>()...))>
diff --git a/libs/core/threading_base/include/hpx/threading_base/register_thread.hpp b/libs/core/threading_base/include/hpx/threading_base/register_thread.hpp
index f149f7a45124..a17011c8c880 100644
--- a/libs/core/threading_base/include/hpx/threading_base/register_thread.hpp
+++ b/libs/core/threading_base/include/hpx/threading_base/register_thread.hpp
@@ -52,8 +52,7 @@ namespace hpx::threads {
             typename Is = util::index_pack<>, typename... Ts>
         struct thread_function_nullary;
 
-        HPX_CXX_CORE_EXPORT template <typename F, std::size_t... Is,
-            typename... Ts>
+        template <typename F, std::size_t... Is, typename... Ts>
         struct thread_function_nullary<F, util::index_pack<Is...>, Ts...>
         {
             HPX_NO_UNIQUE_ADDRESS F f;
diff --git a/libs/core/timed_execution/include/hpx/timed_execution/timed_executors.hpp b/libs/core/timed_execution/include/hpx/timed_execution/timed_executors.hpp
index 8cb8d0812fb4..987e39e62385 100644
--- a/libs/core/timed_execution/include/hpx/timed_execution/timed_executors.hpp
+++ b/libs/core/timed_execution/include/hpx/timed_execution/timed_executors.hpp
@@ -563,21 +563,21 @@ namespace hpx::execution::experimental {
     /// \cond NOINTERNAL
 
     ///////////////////////////////////////////////////////////////////////////
-    HPX_CXX_CORE_EXPORT template <typename BaseExecutor>
+    template <typename BaseExecutor>
     struct is_one_way_executor<
         parallel::execution::timed_executor<BaseExecutor>>
       : is_one_way_executor<std::decay_t<BaseExecutor>>
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename BaseExecutor>
+    template <typename BaseExecutor>
     struct is_two_way_executor<
         parallel::execution::timed_executor<BaseExecutor>>
       : is_two_way_executor<std::decay_t<BaseExecutor>>
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename BaseExecutor>
+    template <typename BaseExecutor>
     struct is_never_blocking_one_way_executor<
         parallel::execution::timed_executor<BaseExecutor>>
       : is_never_blocking_one_way_executor<std::decay_t<BaseExecutor>>
diff --git a/libs/core/type_support/include/hpx/type_support/base_from_member.hpp b/libs/core/type_support/include/hpx/type_support/base_from_member.hpp
index 965f9d715082..e360f9ee0737 100644
--- a/libs/core/type_support/include/hpx/type_support/base_from_member.hpp
+++ b/libs/core/type_support/include/hpx/type_support/base_from_member.hpp
@@ -42,7 +42,7 @@ namespace hpx::util {
         {
         };
 
-        HPX_CXX_EXPORT template <typename T, typename U, typename... U2>
+        template <typename T, typename U, typename... U2>
         struct is_unrelated<T, U, U2...> : std::negation<is_related<T, U>>
         {
         };
@@ -64,16 +64,18 @@ namespace hpx::util {
         MemberType member;
 
         // no std::is_nothrow_constructible nor std::forward needed
+        // clang-format off
         template <typename... T>
             requires(detail::is_unrelated<base_from_member, T...>::value)
         explicit constexpr base_from_member(T&&... x) noexcept(
-            noexcept(::new(nullptr) MemberType(static_cast<T&&>(x)...)))
+            noexcept(::new (nullptr) MemberType(static_cast<T&&>(x)...)))
           : member(static_cast<T&&>(x)...)
         {
         }
+        // clang-format on
     };
 
-    HPX_CXX_EXPORT template <typename MemberType, int UniqueId>
+    template <typename MemberType, int UniqueId>
     class base_from_member<MemberType&, UniqueId>
     {
     protected:
diff --git a/libs/core/type_support/include/hpx/type_support/decay.hpp b/libs/core/type_support/include/hpx/type_support/decay.hpp
index 06b8ea232b34..7ed652ccbe3c 100644
--- a/libs/core/type_support/include/hpx/type_support/decay.hpp
+++ b/libs/core/type_support/include/hpx/type_support/decay.hpp
@@ -30,7 +30,7 @@ namespace hpx::util {
             }
         };
 
-        HPX_CXX_CORE_EXPORT template <typename X>
+        template <typename X>
         struct decay_unwrap_impl<::std::reference_wrapper<X>>
         {
             using type = X&;
diff --git a/libs/core/type_support/include/hpx/type_support/equality.hpp b/libs/core/type_support/include/hpx/type_support/equality.hpp
index 31580e7d44f1..26c7c00032a2 100644
--- a/libs/core/type_support/include/hpx/type_support/equality.hpp
+++ b/libs/core/type_support/include/hpx/type_support/equality.hpp
@@ -25,7 +25,7 @@ namespace hpx::traits {
 
         // different versions of clang-format disagree
         // clang-format off
-        HPX_CXX_CORE_EXPORT template <typename T, typename U>
+        template <typename T, typename U>
         struct equality_result<T, U,
             std::void_t<decltype(
                 std::declval<T const&>() == std::declval<U const&>())>>
@@ -47,7 +47,7 @@ namespace hpx::traits {
 
         // different versions of clang-format disagree
         // clang-format off
-        HPX_CXX_CORE_EXPORT template <typename T, typename U>
+        template <typename T, typename U>
         struct inequality_result<T, U,
             std::void_t<decltype(
                 std::declval<T const&>() != std::declval<U const&>())>>
@@ -67,7 +67,7 @@ namespace hpx::traits {
         {
         };
 
-        HPX_CXX_CORE_EXPORT template <typename T, typename U>
+        template <typename T, typename U>
         struct is_weakly_equality_comparable_with<T, U,
             std::void_t<detail::equality_result_t<T, U>,
                 detail::equality_result_t<U, T>,
diff --git a/libs/core/type_support/include/hpx/type_support/is_trivially_relocatable.hpp b/libs/core/type_support/include/hpx/type_support/is_trivially_relocatable.hpp
index d5847c623a50..f2fbdca786ea 100644
--- a/libs/core/type_support/include/hpx/type_support/is_trivially_relocatable.hpp
+++ b/libs/core/type_support/include/hpx/type_support/is_trivially_relocatable.hpp
@@ -17,7 +17,7 @@ namespace hpx::experimental {
 // trait std::is_trivially_relocatable, see
 // https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2786r13.html#language-feature-test-macros
 #if defined(__cpp_trivial_relocatability)
-    template <typename T>
+    HPX_CXX_CORE_EXPORT template <typename T>
     struct is_trivially_relocatable : std::is_trivially_relocatable<T>
     {
     };
@@ -31,55 +31,55 @@ namespace hpx::experimental {
     };
 
     // References are not trivially relocatable
-    HPX_CXX_CORE_EXPORT template <typename T>
+    template <typename T>
     struct is_trivially_relocatable<T&> : std::false_type
     {
     };
 
     // Temporary objects are not trivially relocatable
-    HPX_CXX_CORE_EXPORT template <typename T>
+    template <typename T>
     struct is_trivially_relocatable<T&&> : std::false_type
     {
     };
 
     // Constness, Volatility, Arrays are ignored
-    HPX_CXX_CORE_EXPORT template <typename T>
+    template <typename T>
     struct is_trivially_relocatable<T const> : is_trivially_relocatable<T>
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename T>
+    template <typename T>
     struct is_trivially_relocatable<T volatile> : is_trivially_relocatable<T>
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename T>
+    template <typename T>
     struct is_trivially_relocatable<T const volatile>
       : is_trivially_relocatable<T>
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename T>
+    template <typename T>
     struct is_trivially_relocatable<T[]> : is_trivially_relocatable<T>
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename T, int N>
+    template <typename T, int N>
     struct is_trivially_relocatable<T[N]> : is_trivially_relocatable<T>
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename T, int N>
+    template <typename T, int N>
     struct is_trivially_relocatable<T const[N]> : is_trivially_relocatable<T>
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename T, int N>
+    template <typename T, int N>
     struct is_trivially_relocatable<T volatile[N]> : is_trivially_relocatable<T>
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename T, int N>
+    template <typename T, int N>
     struct is_trivially_relocatable<T const volatile[N]>
       : is_trivially_relocatable<T>
     {
diff --git a/libs/core/type_support/include/hpx/type_support/lazy_enable_if.hpp b/libs/core/type_support/include/hpx/type_support/lazy_enable_if.hpp
index a10eb0c66b6f..04abe25a3814 100644
--- a/libs/core/type_support/include/hpx/type_support/lazy_enable_if.hpp
+++ b/libs/core/type_support/include/hpx/type_support/lazy_enable_if.hpp
@@ -15,7 +15,7 @@ namespace hpx::util {
     {
     };
 
-    HPX_CXX_CORE_EXPORT template <typename T>
+    template <typename T>
     struct lazy_enable_if<true, T>
     {
         using type = typename T::type;
diff --git a/libs/core/type_support/include/hpx/type_support/meta.hpp b/libs/core/type_support/include/hpx/type_support/meta.hpp
index 9d6365d6b715..28b4a152d646 100644
--- a/libs/core/type_support/include/hpx/type_support/meta.hpp
+++ b/libs/core/type_support/include/hpx/type_support/meta.hpp
@@ -44,10 +44,10 @@ namespace hpx::meta {
     HPX_CXX_CORE_EXPORT template <typename T>
     inline constexpr auto value = T::value;
 
-    HPX_CXX_CORE_EXPORT template <typename T, typename U>
+    template <typename T, typename U>
     inline constexpr bool value<std::is_same<T, U>> = false;
 
-    HPX_CXX_CORE_EXPORT template <typename T>
+    template <typename T>
     inline constexpr bool value<std::is_same<T, T>> = true;
 
     ///////////////////////////////////////////////////////////////////////////
@@ -483,10 +483,11 @@ namespace hpx::meta {
         using apply = Fn<Args...>;
     };
 
+    // clang-format off
     HPX_CXX_CORE_EXPORT template <typename... As>
-    using single_t = std::enable_if_t < sizeof...(As) == 1,
-          meta::type < front < As... >>>
-        ;
+    using single_t =
+        std::enable_if_t<sizeof...(As) == 1, meta::type<front<As...>>>;
+    // clang-format on
 
     HPX_CXX_CORE_EXPORT template <typename Ty>
     struct single_or
@@ -499,7 +500,7 @@ namespace hpx::meta {
     HPX_CXX_CORE_EXPORT template <typename T, typename = void>
     inline constexpr bool has_id_v = false;
 
-    HPX_CXX_CORE_EXPORT template <typename T>
+    template <typename T>
     inline constexpr bool has_id_v<T, std::void_t<typename T::id>> = true;
 
     HPX_CXX_CORE_EXPORT template <typename T>
@@ -525,17 +526,12 @@ namespace hpx::meta {
     using get_id_t = hpx::type_identity_t<
         hpx::meta::invoke<get_id_func<value<has_id<T>>>, T>>;
 
-    // clang-format off
     HPX_CXX_CORE_EXPORT template <typename T, typename... As>
     inline constexpr bool is_constructible_from_v =
         std::is_destructible_v<T> && std::is_constructible_v<T, As...>;
-    // Clang format bug: thinks   ^^this is a double reference
 
     HPX_CXX_CORE_EXPORT template <typename T, typename... As>
     inline constexpr bool is_nothrow_constructible_from_v =
         is_constructible_from_v<T, As...> &&
-    // Clang format bug: thinks       this^^ is a double reference
         std::is_nothrow_constructible_v<T, As...>;
-    // clang-format on
-
 }    // namespace hpx::meta
diff --git a/libs/core/type_support/include/hpx/type_support/pack.hpp b/libs/core/type_support/include/hpx/type_support/pack.hpp
index 428a41e4110f..917599b2e76f 100644
--- a/libs/core/type_support/include/hpx/type_support/pack.hpp
+++ b/libs/core/type_support/include/hpx/type_support/pack.hpp
@@ -203,7 +203,7 @@ namespace hpx::util {
             template <typename> class Transformer>
         struct transform;
 
-        HPX_CXX_CORE_EXPORT template <template <typename> class Transformer,
+        template <template <typename> class Transformer,
             template <typename...> class Pack, typename... Ts>
         struct transform<Pack<Ts...>, Transformer>
         {
@@ -236,8 +236,7 @@ namespace hpx::util {
         HPX_CXX_CORE_EXPORT template <typename Pack>
         struct unique;
 
-        HPX_CXX_CORE_EXPORT template <template <typename...> class Pack,
-            typename... Ts>
+        template <template <typename...> class Pack, typename... Ts>
         struct unique<Pack<Ts...>> : unique_helper<Pack<>, Pack<Ts...>>
         {
         };
@@ -249,15 +248,14 @@ namespace hpx::util {
         HPX_CXX_CORE_EXPORT template <typename... Packs>
         struct concat;
 
-        HPX_CXX_CORE_EXPORT template <template <typename...> class Pack,
-            typename... Ts>
+        template <template <typename...> class Pack, typename... Ts>
         struct concat<Pack<Ts...>>
         {
             using type = Pack<Ts...>;
         };
 
-        HPX_CXX_CORE_EXPORT template <template <typename...> class Pack,
-            typename... Ts, typename... Us, typename... Rest>
+        template <template <typename...> class Pack, typename... Ts,
+            typename... Us, typename... Rest>
         struct concat<Pack<Ts...>, Pack<Us...>, Rest...>
           : concat<Pack<Ts..., Us...>, Rest...>
         {
@@ -276,8 +274,7 @@ namespace hpx::util {
         HPX_CXX_CORE_EXPORT template <typename Pack>
         struct concat_pack_of_packs;
 
-        HPX_CXX_CORE_EXPORT template <template <typename...> class Pack,
-            typename... Ts>
+        template <template <typename...> class Pack, typename... Ts>
         struct concat_pack_of_packs<Pack<Ts...>>
         {
             using type = typename concat<Ts...>::type;
@@ -292,14 +289,13 @@ namespace hpx::util {
         HPX_CXX_CORE_EXPORT template <typename Pack>
         struct concat_inner_packs;
 
-        HPX_CXX_CORE_EXPORT template <template <typename...> class Pack>
+        template <template <typename...> class Pack>
         struct concat_inner_packs<Pack<>>
         {
             using type = Pack<>;
         };
 
-        HPX_CXX_CORE_EXPORT template <template <typename...> class Pack,
-            typename T, typename... Ts>
+        template <template <typename...> class Pack, typename T, typename... Ts>
         struct concat_inner_packs<Pack<T, Ts...>>
         {
             using type = Pack<typename concat<T, Ts...>::type>;
@@ -313,8 +309,7 @@ namespace hpx::util {
         HPX_CXX_CORE_EXPORT template <typename Pack, typename T>
         struct prepend;
 
-        HPX_CXX_CORE_EXPORT template <typename T,
-            template <typename...> class Pack, typename... Ts>
+        template <typename T, template <typename...> class Pack, typename... Ts>
         struct prepend<Pack<Ts...>, T>
         {
             using type = Pack<T, Ts...>;
@@ -327,8 +322,7 @@ namespace hpx::util {
         HPX_CXX_CORE_EXPORT template <typename Pack, typename T>
         struct append;
 
-        HPX_CXX_CORE_EXPORT template <typename T,
-            template <typename...> class Pack, typename... Ts>
+        template <typename T, template <typename...> class Pack, typename... Ts>
         struct append<Pack<Ts...>, T>
         {
             using type = Pack<Ts..., T>;
@@ -342,7 +336,7 @@ namespace hpx::util {
             typename OldPack>
         struct change_pack;
 
-        HPX_CXX_CORE_EXPORT template <template <typename...> class NewPack,
+        template <template <typename...> class NewPack,
             template <typename...> class OldPack, typename... Ts>
         struct change_pack<NewPack, OldPack<Ts...>>
         {
diff --git a/libs/core/type_support/include/hpx/type_support/unwrap_ref.hpp b/libs/core/type_support/include/hpx/type_support/unwrap_ref.hpp
index b1f04490a8ff..9bc5b1b7872e 100644
--- a/libs/core/type_support/include/hpx/type_support/unwrap_ref.hpp
+++ b/libs/core/type_support/include/hpx/type_support/unwrap_ref.hpp
@@ -18,13 +18,13 @@ namespace hpx::util {
         using type = T;
     };
 
-    HPX_CXX_CORE_EXPORT template <typename T>
+    template <typename T>
     struct unwrap_reference<::std::reference_wrapper<T>>
     {
         using type = T;
     };
 
-    HPX_CXX_CORE_EXPORT template <typename T>
+    template <typename T>
     struct unwrap_reference<::std::reference_wrapper<T> const>
     {
         using type = T;
diff --git a/libs/full/actions_base/include/hpx/actions_base/basic_action.hpp b/libs/full/actions_base/include/hpx/actions_base/basic_action.hpp
index b29341ee5de3..8b76ca2fa844 100644
--- a/libs/full/actions_base/include/hpx/actions_base/basic_action.hpp
+++ b/libs/full/actions_base/include/hpx/actions_base/basic_action.hpp
@@ -210,7 +210,7 @@ namespace hpx::actions {
         }
     }    // namespace detail
 
-    HPX_CXX_EXPORT template <typename Component, typename R, typename... Args,
+    template <typename Component, typename R, typename... Args,
         typename Derived>
     struct basic_action<Component, R(Args...), Derived>
     {
@@ -462,7 +462,7 @@ namespace hpx::actions {
             using type = Derived;
         };
 
-        HPX_CXX_EXPORT template <typename Action>
+        template <typename Action>
         struct action_type<Action, void>
         {
             using type = Action;
@@ -506,7 +506,7 @@ namespace hpx::actions {
         using type = action<TF, F, Derived>;
     };
 
-    HPX_CXX_EXPORT template <typename TF, TF F, typename Derived>
+    template <typename TF, TF F, typename Derived>
     struct make_action<TF, F, Derived, std::true_type>
     {
         using type = direct_action<TF, F, Derived>;
diff --git a/libs/full/actions_base/include/hpx/actions_base/plain_action.hpp b/libs/full/actions_base/include/hpx/actions_base/plain_action.hpp
index a7b235ecb02f..54f08568c8cf 100644
--- a/libs/full/actions_base/include/hpx/actions_base/plain_action.hpp
+++ b/libs/full/actions_base/include/hpx/actions_base/plain_action.hpp
@@ -55,8 +55,7 @@ namespace hpx::actions {
     //  Specialized generic plain (free) action types allowing to hold a
     //  different number of arguments
     ///////////////////////////////////////////////////////////////////////////
-    HPX_CXX_EXPORT template <typename R, typename... Ps, R (*F)(Ps...),
-        typename Derived>
+    template <typename R, typename... Ps, R (*F)(Ps...), typename Derived>
     struct action<R (*)(Ps...), F, Derived>
       : basic_action<detail::plain_function, R(Ps...),
             detail::action_type_t<action<R (*)(Ps...), F, Derived>, Derived>>
@@ -81,7 +80,7 @@ namespace hpx::actions {
         }
     };
 
-    HPX_CXX_EXPORT template <typename R, typename... Ps, R (*F)(Ps...) noexcept,
+    template <typename R, typename... Ps, R (*F)(Ps...) noexcept,
         typename Derived>
     struct action<R (*)(Ps...) noexcept, F, Derived>
       : basic_action<detail::plain_function, R(Ps...),
diff --git a/libs/full/actions_base/include/hpx/actions_base/traits/is_client.hpp b/libs/full/actions_base/include/hpx/actions_base/traits/is_client.hpp
index 86dd42313875..24a9f87ab564 100644
--- a/libs/full/actions_base/include/hpx/actions_base/traits/is_client.hpp
+++ b/libs/full/actions_base/include/hpx/actions_base/traits/is_client.hpp
@@ -27,12 +27,12 @@ namespace hpx::traits {
     {
     };
 
-    HPX_CXX_EXPORT template <typename T>
+    template <typename T>
     struct is_client_or_client_array<T[]> : is_client<T>
     {
     };
 
-    HPX_CXX_EXPORT template <typename T, std::size_t N>
+    template <typename T, std::size_t N>
     struct is_client_or_client_array<T[N]> : is_client<T>
     {
     };
diff --git a/libs/full/components_base/include/hpx/components_base/traits/component_type_database.hpp b/libs/full/components_base/include/hpx/components_base/traits/component_type_database.hpp
index 0a9f069b4201..c13e9133790b 100644
--- a/libs/full/components_base/include/hpx/components_base/traits/component_type_database.hpp
+++ b/libs/full/components_base/include/hpx/components_base/traits/component_type_database.hpp
@@ -28,7 +28,7 @@ namespace hpx::traits {
         HPX_ALWAYS_EXPORT static void set(components::component_type);
     };
 
-    HPX_CXX_EXPORT template <typename Component, typename Enable>
+    template <typename Component, typename Enable>
     struct component_type_database<Component const, Enable>
       : component_type_database<Component, Enable>
     {
diff --git a/libs/full/components_base/include/hpx/components_base/traits/is_component.hpp b/libs/full/components_base/include/hpx/components_base/traits/is_component.hpp
index fa18eff3bd3f..e58066a6b20f 100644
--- a/libs/full/components_base/include/hpx/components_base/traits/is_component.hpp
+++ b/libs/full/components_base/include/hpx/components_base/traits/is_component.hpp
@@ -37,14 +37,14 @@ namespace hpx::traits {
     {
     };
 
-    HPX_CXX_EXPORT template <typename Component>
+    template <typename Component>
     struct is_component<Component const> : is_component<Component>
     {
     };
 
     ///////////////////////////////////////////////////////////////////////////
     // Simple components are components
-    HPX_CXX_EXPORT template <typename Component>
+    template <typename Component>
     struct is_component<Component,
         std::enable_if_t<std::is_base_of_v<detail::component_tag, Component>>>
       : std::true_type
@@ -52,7 +52,7 @@ namespace hpx::traits {
     };
 
     // Fixed components are components
-    HPX_CXX_EXPORT template <typename Component>
+    template <typename Component>
     struct is_component<Component,
         std::enable_if_t<
             std::is_base_of_v<detail::fixed_component_tag, Component>>>
@@ -61,7 +61,7 @@ namespace hpx::traits {
     };
 
     // Managed components are components
-    HPX_CXX_EXPORT template <typename Component>
+    template <typename Component>
     struct is_component<Component,
         std::enable_if_t<
             std::is_base_of_v<detail::managed_component_tag, Component>>>
@@ -78,12 +78,12 @@ namespace hpx::traits {
     {
     };
 
-    HPX_CXX_EXPORT template <typename T>
+    template <typename T>
     struct is_component_or_component_array<T[]> : is_component<T>
     {
     };
 
-    HPX_CXX_EXPORT template <typename T, std::size_t N>
+    template <typename T, std::size_t N>
     struct is_component_or_component_array<T[N]> : is_component<T>
     {
     };
@@ -99,7 +99,7 @@ namespace hpx::traits {
     {
     };
 
-    HPX_CXX_EXPORT template <typename Component>
+    template <typename Component>
     struct is_fixed_component<Component const> : is_fixed_component<Component>
     {
     };
@@ -115,7 +115,7 @@ namespace hpx::traits {
     {
     };
 
-    HPX_CXX_EXPORT template <typename Component>
+    template <typename Component>
     struct is_managed_component<Component const>
       : is_managed_component<Component>
     {
diff --git a/libs/full/components_base/include/hpx/components_base/traits/managed_component_policies.hpp b/libs/full/components_base/include/hpx/components_base/traits/managed_component_policies.hpp
index 6a40617c3c38..2e76e6f53244 100644
--- a/libs/full/components_base/include/hpx/components_base/traits/managed_component_policies.hpp
+++ b/libs/full/components_base/include/hpx/components_base/traits/managed_component_policies.hpp
@@ -29,7 +29,7 @@ namespace hpx::traits {
         using type = construct_without_back_ptr;
     };
 
-    HPX_CXX_EXPORT template <typename Component>
+    template <typename Component>
     struct managed_component_ctor_policy<Component,
         std::void_t<typename Component::has_managed_component_base>>
     {
@@ -56,7 +56,7 @@ namespace hpx::traits {
         using type = managed_object_controls_lifetime;
     };
 
-    HPX_CXX_EXPORT template <typename Component>
+    template <typename Component>
     struct managed_component_dtor_policy<Component,
         std::void_t<typename Component::has_managed_component_base>>
     {
diff --git a/libs/full/naming/include/hpx/naming/detail/preprocess_gid_types.hpp b/libs/full/naming/include/hpx/naming/detail/preprocess_gid_types.hpp
index d9da49dc1431..f1e148195eac 100644
--- a/libs/full/naming/include/hpx/naming/detail/preprocess_gid_types.hpp
+++ b/libs/full/naming/include/hpx/naming/detail/preprocess_gid_types.hpp
@@ -128,15 +128,17 @@ namespace hpx::serialization::detail {
     };
 }    // namespace hpx::serialization::detail
 
-// This is explicitly instantiated to ensure that the id is stable across
-// shared libraries.
-template <>
-struct hpx::util::extra_data_helper<
-    hpx::serialization::detail::preprocess_gid_types>
-{
-    HPX_EXPORT static extra_data_id_type id() noexcept;
-    static constexpr void reset(
-        serialization::detail::preprocess_gid_types*) noexcept
+namespace hpx::util {
+
+    // This is explicitly instantiated to ensure that the id is stable across
+    // shared libraries.
+    template <>
+    struct extra_data_helper<hpx::serialization::detail::preprocess_gid_types>
     {
-    }
-};
+        HPX_EXPORT static extra_data_id_type id() noexcept;
+        static constexpr void reset(
+            serialization::detail::preprocess_gid_types*) noexcept
+        {
+        }
+    };
+}    // namespace hpx::util
diff --git a/libs/full/plugin_factories/include/hpx/plugin_factories/plugin_factory_base.hpp b/libs/full/plugin_factories/include/hpx/plugin_factories/plugin_factory_base.hpp
index 6889c03689b7..8a2a969e248d 100644
--- a/libs/full/plugin_factories/include/hpx/plugin_factories/plugin_factory_base.hpp
+++ b/libs/full/plugin_factories/include/hpx/plugin_factories/plugin_factory_base.hpp
@@ -25,26 +25,29 @@ namespace hpx::plugins {
     };
 }    // namespace hpx::plugins
 
-////////////////////////////////////////////////////////////////////////////////
-// The following specialization of the virtual_constructor template defines the
-// argument list for the constructor of the concrete component factory (derived
-// from the component_factory_base above). This magic is needed because we use
-// hpx::plugin for the creation of instances of derived types using the
-// component_factory_base virtual base class only (essentially implementing a
-// virtual constructor).
-//
-// All derived component factories have to expose a constructor with the
-// matching signature. For instance:
-//
-//     class my_factory : public plugin_factory_base { public:
-//         my_factory (hpx::util::section const*,
-//              hpx::util::section const*, bool)
-//         {}
-//     };
-//
-template <>
-struct hpx::util::plugin::virtual_constructor<hpx::plugins::plugin_factory_base>
-{
-    using type = hpx::util::pack<hpx::util::section const*,
-        hpx::util::section const*, bool>;
-};
+namespace hpx::util::plugin {
+
+    ///////////////////////////////////////////////////////////////////////////
+    // The following specialization of the virtual_constructor template defines
+    // the argument list for the constructor of the concrete component factory
+    // (derived from the component_factory_base above). This magic is needed
+    // because we use hpx::plugin for the creation of instances of derived types
+    // using the component_factory_base virtual base class only (essentially
+    // implementing a virtual constructor).
+    //
+    // All derived component factories have to expose a constructor with the
+    // matching signature. For instance:
+    //
+    //     class my_factory : public plugin_factory_base { public:
+    //         my_factory (hpx::util::section const*,
+    //              hpx::util::section const*, bool)
+    //         {}
+    //     };
+    //
+    template <>
+    struct virtual_constructor<hpx::plugins::plugin_factory_base>
+    {
+        using type = hpx::util::pack<hpx::util::section const*,
+            hpx::util::section const*, bool>;
+    };
+}    // namespace hpx::util::plugin