From f6150b2a9ed66174539f2dbd26596241bc18b982 Mon Sep 17 00:00:00 2001
From: isidorostsa <tsa.isidoros@gmail.com>
Date: Sat, 10 May 2025 19:39:25 +0300
Subject: [PATCH 1/4] fwd opstate tag

---
 .../include/hpx/execution_base/stdexec_forward.hpp             | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/libs/core/execution_base/include/hpx/execution_base/stdexec_forward.hpp b/libs/core/execution_base/include/hpx/execution_base/stdexec_forward.hpp
index 49cc187d8ed7..79a3d86a3654 100644
--- a/libs/core/execution_base/include/hpx/execution_base/stdexec_forward.hpp
+++ b/libs/core/execution_base/include/hpx/execution_base/stdexec_forward.hpp
@@ -98,6 +98,9 @@ namespace hpx::execution::experimental {
     using stdexec::get_completion_signatures;
     using stdexec::get_completion_signatures_t;
 
+    // Operation State
+    using stdexec::operation_state_t;
+
     // Sender
     using stdexec::connect;
     using stdexec::connect_result_t;

From 13cfb156ca91ae2b5bb5a4e21a7ca040f685291d Mon Sep 17 00:00:00 2001
From: isidorostsa <tsa.isidoros@gmail.com>
Date: Mon, 12 May 2025 09:33:29 +0300
Subject: [PATCH 2/4] Add missing concept tags

---
 .../include/hpx/execution/algorithms/when_all_vector.hpp  | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/libs/core/execution/include/hpx/execution/algorithms/when_all_vector.hpp b/libs/core/execution/include/hpx/execution/algorithms/when_all_vector.hpp
index bac1b5685bbe..b2c1f6db25c7 100644
--- a/libs/core/execution/include/hpx/execution/algorithms/when_all_vector.hpp
+++ b/libs/core/execution/include/hpx/execution/algorithms/when_all_vector.hpp
@@ -1,5 +1,6 @@
 //  Copyright (c) 2020 ETH Zurich
 //  Copyright (c) 2022 Hartmut Kaiser
+//  Copyright (c) 2025 Isidoros Tsaousis-Seiras
 //
 //  SPDX-License-Identifier: BSL-1.0
 //  Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -65,6 +66,9 @@ namespace hpx::when_all_vector_detail {
     struct when_all_vector_sender_impl<Sender>::when_all_vector_sender_type
     {
         using is_sender = void;
+#if defined(HPX_HAVE_STDEXEC)
+        using sender_concept = hpx::execution::experimental::sender_t;
+#endif
         using senders_type = std::vector<Sender>;
         senders_type senders;
 
@@ -174,6 +178,10 @@ namespace hpx::when_all_vector_detail {
         struct operation_state
         {
             using receiver_type = std::decay_t<Receiver>;
+#if defined(HPX_HAVE_STDEXEC)
+            using operation_state_concept =
+                hpx::execution::experimental::operation_state_t;
+#endif
 
             struct when_all_vector_receiver
             {

From 90e44ee4f0775a82f5839a6a3ed385dfd965518b Mon Sep 17 00:00:00 2001
From: isidorostsa <tsa.isidoros@gmail.com>
Date: Fri, 16 May 2025 19:37:06 +0300
Subject: [PATCH 3/4] execution ns aliases

---
 .../hpx/execution/algorithms/as_sender.hpp    |  32 ++--
 .../include/hpx/execution/algorithms/bulk.hpp |  58 +++----
 .../hpx/execution/algorithms/keep_future.hpp  |  14 +-
 .../hpx/execution/algorithms/make_future.hpp  |  88 +++++-----
 .../hpx/execution/algorithms/when_all.hpp     |  23 ++-
 .../execution/algorithms/when_all_vector.hpp  | 152 ++++++++----------
 .../include/hpx/execution_base/any_sender.hpp |  61 ++++---
 .../execution_base/completion_scheduler.hpp   |  11 +-
 .../execution_base/completion_signatures.hpp  |  46 +++---
 9 files changed, 214 insertions(+), 271 deletions(-)

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 8b7153c8a7ac..034951899a2e 100644
--- a/libs/core/execution/include/hpx/execution/algorithms/as_sender.hpp
+++ b/libs/core/execution/include/hpx/execution/algorithms/as_sender.hpp
@@ -25,7 +25,7 @@
 #include <utility>
 
 namespace hpx::execution::experimental {
-
+    namespace hpxexec = hpx::execution::experimental;
     namespace detail {
 
         ///////////////////////////////////////////////////////////////////////////
@@ -54,8 +54,8 @@ namespace hpx::execution::experimental {
             as_sender_operation_state& operator=(
                 as_sender_operation_state const&) = delete;
 
-            friend void tag_invoke(hpx::execution::experimental::start_t,
-                as_sender_operation_state& os) noexcept
+            friend void tag_invoke(
+                hpxexec::start_t, as_sender_operation_state& os) noexcept
             {
                 os.start_helper();
             }
@@ -79,19 +79,17 @@ namespace hpx::execution::experimental {
                             {
                                 if constexpr (std::is_void_v<result_type>)
                                 {
-                                    hpx::execution::experimental::set_value(
-                                        HPX_MOVE(receiver_));
+                                    hpxexec::set_value(HPX_MOVE(receiver_));
                                 }
                                 else
                                 {
-                                    hpx::execution::experimental::set_value(
+                                    hpxexec::set_value(
                                         HPX_MOVE(receiver_), future_.get());
                                 }
                             }
                             else if (future_.has_exception())
                             {
-                                hpx::execution::experimental::set_error(
-                                    HPX_MOVE(receiver_),
+                                hpxexec::set_error(HPX_MOVE(receiver_),
                                     future_.get_exception_ptr());
                             }
                         };
@@ -120,8 +118,7 @@ namespace hpx::execution::experimental {
                         }
                     },
                     [&](std::exception_ptr ep) {
-                        hpx::execution::experimental::set_error(
-                            HPX_MOVE(receiver_), HPX_MOVE(ep));
+                        hpxexec::set_error(HPX_MOVE(receiver_), HPX_MOVE(ep));
                     });
             }
 
@@ -140,22 +137,19 @@ namespace hpx::execution::experimental {
             template <bool IsVoid, typename _result_type>
             struct set_value_void_checked
             {
-                using type = hpx::execution::experimental::set_value_t(
-                    _result_type);
+                using type = hpxexec::set_value_t(_result_type);
             };
 
             template <typename _result_type>
             struct set_value_void_checked<true, _result_type>
             {
-                using type = hpx::execution::experimental::set_value_t();
+                using type = hpxexec::set_value_t();
             };
 
-            using completion_signatures =
-                hpx::execution::experimental::completion_signatures<
-                    typename set_value_void_checked<std::is_void_v<result_type>,
-                        result_type>::type,
-                    hpx::execution::experimental::set_error_t(
-                        std::exception_ptr)>;
+            using completion_signatures = hpxexec::completion_signatures<
+                typename set_value_void_checked<std::is_void_v<result_type>,
+                    result_type>::type,
+                hpxexec::set_error_t(std::exception_ptr)>;
 #else
             // Sender compatibility
             template <typename, typename T>
diff --git a/libs/core/execution/include/hpx/execution/algorithms/bulk.hpp b/libs/core/execution/include/hpx/execution/algorithms/bulk.hpp
index 9d67b8c16d08..51e8a8114d6f 100644
--- a/libs/core/execution/include/hpx/execution/algorithms/bulk.hpp
+++ b/libs/core/execution/include/hpx/execution/algorithms/bulk.hpp
@@ -34,6 +34,7 @@
 #include <utility>
 
 namespace hpx::execution::experimental {
+    namespace hpxexec = hpx::execution::experimental;
 
     ///////////////////////////////////////////////////////////////////////////
     namespace detail {
@@ -46,37 +47,33 @@ namespace hpx::execution::experimental {
             HPX_NO_UNIQUE_ADDRESS std::decay_t<F> f;
 
 #if defined(HPX_HAVE_STDEXEC)
-            using sender_concept = hpx::execution::experimental::sender_t;
+            using sender_concept = hpxexec::sender_t;
 
             template <typename... Args>
             using default_set_value =
-                hpx::execution::experimental::completion_signatures<
-                    hpx::execution::experimental::set_value_t(Args...)>;
+                hpxexec::completion_signatures<hpxexec::set_value_t(Args...)>;
 
             template <typename Arg>
             using default_set_error =
-                hpx::execution::experimental::completion_signatures<
-                    hpx::execution::experimental::set_error_t(Arg)>;
+                hpxexec::completion_signatures<hpxexec::set_error_t(Arg)>;
 
-            using disable_set_stopped =
-                hpx::execution::experimental::completion_signatures<>;
+            using disable_set_stopped = hpxexec::completion_signatures<>;
 
             // clang-format off
             template <typename Env>
             friend auto tag_invoke(get_completion_signatures_t,
                 bulk_sender const&, Env) noexcept -> hpx::execution::
                 experimental::transform_completion_signatures_of<Sender, Env,
-                    hpx::execution::experimental::completion_signatures<
-                        hpx::execution::experimental::set_error_t(
+                    hpxexec::completion_signatures<
+                        hpxexec::set_error_t(
                             std::exception_ptr)>,
                     default_set_value, default_set_error, disable_set_stopped>;
             // clang-format on
 
             friend constexpr auto tag_invoke(
-                hpx::execution::experimental::get_env_t,
-                bulk_sender const& s) noexcept
+                hpxexec::get_env_t, bulk_sender const& s) noexcept
             {
-                return hpx::execution::experimental::get_env(s.sender);
+                return hpxexec::get_env(s.sender);
             }
 #else
             using is_sender = void;
@@ -107,14 +104,13 @@ namespace hpx::execution::experimental {
             // clang-format off
             template <typename CPO,
                 HPX_CONCEPT_REQUIRES_(
-                    hpx::execution::experimental::detail::is_receiver_cpo_v<CPO> &&
-                    hpx::execution::experimental::detail::has_completion_scheduler_v<
+                    hpxexec::detail::is_receiver_cpo_v<CPO> &&
+                    hpxexec::detail::has_completion_scheduler_v<
                         CPO, std::decay_t<Sender>>
                 )>
             // clang-format on
             friend constexpr auto tag_invoke(
-                hpx::execution::experimental::get_completion_scheduler_t<CPO>
-                    tag,
+                hpxexec::get_completion_scheduler_t<CPO> tag,
                 bulk_sender const& s)
             {
                 return tag(s.sender);
@@ -124,8 +120,7 @@ namespace hpx::execution::experimental {
             struct bulk_receiver
             {
 #if defined(HPX_HAVE_STDEXEC)
-                using receiver_concept =
-                    hpx::execution::experimental::receiver_t;
+                using receiver_concept = hpxexec::receiver_t;
 #endif
                 HPX_NO_UNIQUE_ADDRESS std::decay_t<Receiver> receiver;
                 HPX_NO_UNIQUE_ADDRESS std::decay_t<Shape> shape;
@@ -143,15 +138,14 @@ namespace hpx::execution::experimental {
                 friend void tag_invoke(
                     set_error_t, bulk_receiver&& r, Error&& error) noexcept
                 {
-                    hpx::execution::experimental::set_error(
+                    hpxexec::set_error(
                         HPX_MOVE(r.receiver), HPX_FORWARD(Error, error));
                 }
 
                 friend void tag_invoke(
                     set_stopped_t, bulk_receiver&& r) noexcept
                 {
-                    hpx::execution::experimental::set_stopped(
-                        HPX_MOVE(r.receiver));
+                    hpxexec::set_stopped(HPX_MOVE(r.receiver));
                 }
 
                 template <typename... Ts>
@@ -167,11 +161,11 @@ namespace hpx::execution::experimental {
                             {
                                 HPX_INVOKE(f, s, ts...);
                             }
-                            hpx::execution::experimental::set_value(
+                            hpxexec::set_value(
                                 HPX_MOVE(receiver), HPX_FORWARD(Ts, ts)...);
                         },
                         [&](std::exception_ptr ep) {
-                            hpx::execution::experimental::set_error(
+                            hpxexec::set_error(
                                 HPX_MOVE(receiver), HPX_MOVE(ep));
                         });
                 }
@@ -179,7 +173,7 @@ namespace hpx::execution::experimental {
                 template <typename... Ts>
                 friend auto tag_invoke(
                     set_value_t, bulk_receiver&& r, Ts&&... ts) noexcept
-                    -> decltype(hpx::execution::experimental::set_value(
+                    -> decltype(hpxexec::set_value(
                                     std::declval<std::decay_t<Receiver>&&>(),
                                     HPX_FORWARD(Ts, ts)...),
                         void())
@@ -196,7 +190,7 @@ namespace hpx::execution::experimental {
             friend auto tag_invoke(
                 connect_t, bulk_sender&& s, Receiver&& receiver)
             {
-                return hpx::execution::experimental::connect(HPX_MOVE(s.sender),
+                return hpxexec::connect(HPX_MOVE(s.sender),
                     bulk_receiver<Receiver>(HPX_FORWARD(Receiver, receiver),
                         HPX_MOVE(s.shape), HPX_MOVE(s.f)));
             }
@@ -205,7 +199,7 @@ namespace hpx::execution::experimental {
             friend auto tag_invoke(
                 connect_t, bulk_sender& s, Receiver&& receiver)
             {
-                return hpx::execution::experimental::connect(s.sender,
+                return hpxexec::connect(s.sender,
                     bulk_receiver<Receiver>(
                         HPX_FORWARD(Receiver, receiver), s.shape, s.f));
             }
@@ -247,7 +241,7 @@ namespace hpx::execution::experimental {
             HPX_CONCEPT_REQUIRES_(
                 is_sender_v<Sender> &&
                 experimental::detail::is_completion_scheduler_tag_invocable_v<
-                    hpx::execution::experimental::set_value_t, Sender,
+                    hpxexec::set_value_t, Sender,
                     bulk_t, Shape, F
                 >
             )>
@@ -255,15 +249,13 @@ namespace hpx::execution::experimental {
         friend constexpr HPX_FORCEINLINE auto tag_override_invoke(
             bulk_t, Sender&& sender, Shape const& shape, F&& f)
         {
-            auto scheduler =
-                hpx::execution::experimental::get_completion_scheduler<
-                    hpx::execution::experimental::set_value_t>(
+            auto scheduler = hpxexec::get_completion_scheduler<hpxexec::set_value_t>(
 #if defined(HPX_HAVE_STDEXEC)
-                    hpx::execution::experimental::get_env(sender)
+                hpxexec::get_env(sender)
 #else
-                    sender
+                sender
 #endif
-                );
+            );
 
             return hpx::functional::tag_invoke(bulk_t{}, HPX_MOVE(scheduler),
                 HPX_FORWARD(Sender, sender), shape, HPX_FORWARD(F, f));
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 bcd58d71db1b..b279bccd229f 100644
--- a/libs/core/execution/include/hpx/execution/algorithms/keep_future.hpp
+++ b/libs/core/execution/include/hpx/execution/algorithms/keep_future.hpp
@@ -23,6 +23,7 @@
 #include <utility>
 
 namespace hpx::execution::experimental {
+    namespace hpxexec = hpx::execution::experimental;
 
     namespace detail {
 
@@ -51,13 +52,12 @@ namespace hpx::execution::experimental {
                         // to move receiver and future into the on_completed
                         // callback.
                         state->set_on_completed([&os]() mutable {
-                            hpx::execution::experimental::set_value(
+                            hpxexec::set_value(
                                 HPX_MOVE(os.receiver), HPX_MOVE(os.future));
                         });
                     },
                     [&](std::exception_ptr ep) {
-                        hpx::execution::experimental::set_error(
-                            HPX_MOVE(os.receiver), HPX_MOVE(ep));
+                        hpxexec::set_error(HPX_MOVE(os.receiver), HPX_MOVE(ep));
                     });
             }
         };
@@ -68,11 +68,9 @@ namespace hpx::execution::experimental {
             std::decay_t<Future> future;
 #if defined(HPX_HAVE_STDEXEC)
             using completion_signatures =
-                hpx::execution::experimental::completion_signatures<
-                    hpx::execution::experimental::set_value_t(
-                        std::decay_t<Future>),
-                    hpx::execution::experimental::set_error_t(
-                        std::exception_ptr)>;
+                hpxexec::completion_signatures<hpxexec::set_value_t(
+                                                   std::decay_t<Future>),
+                    hpxexec::set_error_t(std::exception_ptr)>;
 #else
             struct completion_signatures
             {
diff --git a/libs/core/execution/include/hpx/execution/algorithms/make_future.hpp b/libs/core/execution/include/hpx/execution/algorithms/make_future.hpp
index 4e13bc57a2f6..a66c5f3ff752 100644
--- a/libs/core/execution/include/hpx/execution/algorithms/make_future.hpp
+++ b/libs/core/execution/include/hpx/execution/algorithms/make_future.hpp
@@ -34,6 +34,7 @@
 
 namespace hpx::execution::experimental {
 
+    namespace hpxexec = hpx::execution::experimental;
     // enforce proper formatting
     namespace detail {
 
@@ -133,11 +134,10 @@ namespace hpx::execution::experimental {
             future_data(init_no_addref no_addref, other_allocator const& alloc,
                 Sender&& sender)
               : base_type(no_addref, alloc)
-              , op_state(hpx::execution::experimental::connect(
-                    HPX_FORWARD(Sender, sender),
+              , op_state(hpxexec::connect(HPX_FORWARD(Sender, sender),
                     detail::future_receiver<T>{{this}}))
             {
-                hpx::execution::experimental::start(op_state);
+                hpxexec::start(op_state);
             }
         };
 
@@ -146,7 +146,7 @@ namespace hpx::execution::experimental {
           : future_data<T, Allocator, OperationState,
                 future_data_with_run_loop<T, Allocator, OperationState>>
         {
-            hpx::execution::experimental::run_loop& loop;
+            hpxexec::run_loop& loop;
 
             using base_type = future_data<T, Allocator, OperationState,
                 future_data_with_run_loop>;
@@ -157,10 +157,10 @@ namespace hpx::execution::experimental {
             future_data_with_run_loop(init_no_addref no_addref,
                 other_allocator const& alloc,
 #if defined(HPX_HAVE_STDEXEC)
-                decltype(std::declval<hpx::execution::experimental::run_loop>()
-                             .get_scheduler()) const& sched,
+                decltype(std::declval<hpxexec::run_loop>().get_scheduler())
+                    const& sched,
 #else
-                hpx::execution::experimental::run_loop_scheduler const& sched,
+                hpxexec::run_loop_scheduler const& sched,
 #endif
                 Sender&& sender)
               : base_type(no_addref, alloc, HPX_FORWARD(Sender, sender))
@@ -168,8 +168,7 @@ namespace hpx::execution::experimental {
               //TODO: Keep an eye on this, it is based on the internal impl of
               // stdexec, so it is subect to change. This is currently relying
               // on the env struct to expose __loop_ as a public member.
-              , loop(*hpx::execution::experimental::get_env(schedule(sched))
-                          .__loop_)
+              , loop(*hpxexec::get_env(schedule(sched)).__loop_)
 #else
               , loop(sched.get_run_loop())
 #endif
@@ -196,15 +195,14 @@ namespace hpx::execution::experimental {
         {
             using allocator_type = Allocator;
 
-            using value_types = hpx::execution::experimental::value_types_of_t<
-                std::decay_t<Sender>, hpx::execution::experimental::empty_env,
-                meta::pack, meta::pack>;
+            using value_types = hpxexec::value_types_of_t<std::decay_t<Sender>,
+                hpxexec::empty_env, meta::pack, meta::pack>;
 
             using result_type =
                 std::decay_t<detail::single_result_t<value_types>>;
-            using operation_state_type = hpx::util::invoke_result_t<
-                hpx::execution::experimental::connect_t, Sender,
-                detail::future_receiver<result_type>>;
+            using operation_state_type =
+                hpx::util::invoke_result_t<hpxexec::connect_t, Sender,
+                    detail::future_receiver<result_type>>;
 
             using shared_state =
                 future_data<result_type, allocator_type, operation_state_type>;
@@ -233,24 +231,23 @@ namespace hpx::execution::experimental {
         template <typename Sender, typename Allocator>
         auto make_future_with_run_loop(
 #if defined(HPX_HAVE_STDEXEC)
-            decltype(std::declval<hpx::execution::experimental::run_loop>()
-                         .get_scheduler()) const& sched,
+            decltype(std::declval<hpxexec::run_loop>().get_scheduler())
+                const& sched,
 #else
-            hpx::execution::experimental::run_loop_scheduler const& sched,
+            hpxexec::run_loop_scheduler const& sched,
 #endif
             Sender&& sender, Allocator const& allocator)
         {
             using allocator_type = Allocator;
 
-            using value_types = hpx::execution::experimental::value_types_of_t<
-                std::decay_t<Sender>, hpx::execution::experimental::empty_env,
-                meta::pack, meta::pack>;
+            using value_types = hpxexec::value_types_of_t<std::decay_t<Sender>,
+                hpxexec::empty_env, meta::pack, meta::pack>;
 
             using result_type =
                 std::decay_t<detail::single_result_t<value_types>>;
-            using operation_state_type = hpx::util::invoke_result_t<
-                hpx::execution::experimental::connect_t, Sender,
-                detail::future_receiver<result_type>>;
+            using operation_state_type =
+                hpx::util::invoke_result_t<hpxexec::connect_t, Sender,
+                    detail::future_receiver<result_type>>;
 
             using shared_state = future_data_with_run_loop<result_type,
                 allocator_type, operation_state_type>;
@@ -276,26 +273,25 @@ namespace hpx::execution::experimental {
 
 namespace hpx::traits::detail {
 
+    namespace hpxexec = hpx::execution::experimental;
     template <typename T, typename Allocator, typename OperationState,
         typename NewAllocator>
-    struct shared_state_allocator<hpx::execution::experimental::detail::
-                                      future_data<T, Allocator, OperationState>,
+    struct shared_state_allocator<
+        hpxexec::detail::future_data<T, Allocator, OperationState>,
         NewAllocator>
     {
-        using type = hpx::execution::experimental::detail::future_data<T,
-            NewAllocator, OperationState>;
+        using type =
+            hpxexec::detail::future_data<T, NewAllocator, OperationState>;
     };
 
     template <typename T, typename Allocator, typename OperationState,
         typename NewAllocator>
-    struct shared_state_allocator<
-        hpx::execution::experimental::detail::future_data_with_run_loop<T,
-            Allocator, OperationState>,
+    struct shared_state_allocator<hpxexec::detail::future_data_with_run_loop<T,
+                                      Allocator, OperationState>,
         NewAllocator>
     {
-        using type =
-            hpx::execution::experimental::detail::future_data_with_run_loop<T,
-                NewAllocator, OperationState>;
+        using type = hpxexec::detail::future_data_with_run_loop<T, NewAllocator,
+            OperationState>;
     };
 }    // namespace hpx::traits::detail
 
@@ -330,7 +326,7 @@ namespace hpx::execution::experimental {
                 is_sender_v<Sender> &&
                 hpx::traits::is_allocator_v<Allocator> &&
                 experimental::detail::is_completion_scheduler_tag_invocable_v<
-                    hpx::execution::experimental::set_value_t,
+                    hpxexec::set_value_t,
                     Sender, make_future_t, Allocator
                 >
             )>
@@ -340,13 +336,11 @@ namespace hpx::execution::experimental {
         {
 #if defined(HPX_HAVE_STDEXEC)
             auto scheduler =
-                hpx::execution::experimental::get_completion_scheduler<
-                    hpx::execution::experimental::set_value_t>(
-                    hpx::execution::experimental::get_env(sender));
+                hpxexec::get_completion_scheduler<hpxexec::set_value_t>(
+                    hpxexec::get_env(sender));
 #else
             auto scheduler =
-                hpx::execution::experimental::get_completion_scheduler<
-                    hpx::execution::experimental::set_value_t>(sender);
+                hpxexec::get_completion_scheduler<hpxexec::set_value_t>(sender);
 #endif
 
             return hpx::functional::tag_invoke(make_future_t{},
@@ -357,15 +351,14 @@ namespace hpx::execution::experimental {
         template <typename Sender,
             typename Allocator = hpx::util::internal_allocator<>,
             HPX_CONCEPT_REQUIRES_(
-                hpx::execution::experimental::is_sender_v<Sender>
+                hpxexec::is_sender_v<Sender>
             )>
         // clang-format on
         friend auto tag_invoke(make_future_t,
 #if defined(HPX_HAVE_STDEXEC)
-            decltype(std::declval<hpx::execution::experimental::run_loop>()
-                         .get_scheduler()) const& sched,
+            decltype(std::declval<hpxexec::run_loop>().get_scheduler()) const& sched,
 #else
-            hpx::execution::experimental::run_loop_scheduler const& sched,
+            hpxexec::run_loop_scheduler const& sched,
 #endif
             Sender&& sender, Allocator const& allocator = Allocator{})
         {
@@ -391,16 +384,15 @@ namespace hpx::execution::experimental {
         template <typename Scheduler,
             typename Allocator = hpx::util::internal_allocator<>,
             HPX_CONCEPT_REQUIRES_(
-                hpx::execution::experimental::is_scheduler_v<Scheduler> &&
+                hpxexec::is_scheduler_v<Scheduler> &&
                 hpx::traits::is_allocator_v<Allocator>
             )>
         // clang-format on
         friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(make_future_t,
             Scheduler&& scheduler, Allocator const& allocator = Allocator{})
         {
-            return hpx::execution::experimental::detail::inject_scheduler<
-                make_future_t, Scheduler, Allocator>{
-                HPX_FORWARD(Scheduler, scheduler), allocator};
+            return hpxexec::detail::inject_scheduler<make_future_t, Scheduler,
+                Allocator>{HPX_FORWARD(Scheduler, scheduler), allocator};
         }
 
         // clang-format off
diff --git a/libs/core/execution/include/hpx/execution/algorithms/when_all.hpp b/libs/core/execution/include/hpx/execution/algorithms/when_all.hpp
index 45c5825dea2e..5e5bafb494d3 100644
--- a/libs/core/execution/include/hpx/execution/algorithms/when_all.hpp
+++ b/libs/core/execution/include/hpx/execution/algorithms/when_all.hpp
@@ -14,31 +14,30 @@
 #include <hpx/execution_base/stdexec_forward.hpp>
 
 namespace hpx::execution::experimental {
+
+    namespace hpxexec = hpx::execution::experimental;
+
     template <typename F, typename Sender, typename... Senders>
     constexpr HPX_FORCEINLINE auto tag_invoke(
         hpx::detail::dataflow_t, F&& f, Sender&& sender, Senders&&... senders)
-        -> decltype(hpx::execution::experimental::then(
-            hpx::execution::experimental::when_all(
-                HPX_FORWARD(Sender, sender), HPX_FORWARD(Senders, senders)...),
+        -> decltype(hpxexec::then(hpxexec::when_all(HPX_FORWARD(Sender, sender),
+                                      HPX_FORWARD(Senders, senders)...),
             HPX_FORWARD(F, f)))
     {
-        return hpx::execution::experimental::then(
-            hpx::execution::experimental::when_all(
-                HPX_FORWARD(Sender, sender), HPX_FORWARD(Senders, senders)...),
+        return hpxexec::then(hpxexec::when_all(HPX_FORWARD(Sender, sender),
+                                 HPX_FORWARD(Senders, senders)...),
             HPX_FORWARD(F, f));
     }
 
     template <typename F, typename Sender, typename... Senders>
     constexpr HPX_FORCEINLINE auto tag_invoke(hpx::detail::dataflow_t,
         hpx::launch, F&& f, Sender&& sender, Senders&&... senders)
-        -> decltype(hpx::execution::experimental::then(
-            hpx::execution::experimental::when_all(
-                HPX_FORWARD(Sender, sender), HPX_FORWARD(Senders, senders)...),
+        -> decltype(hpxexec::then(hpxexec::when_all(HPX_FORWARD(Sender, sender),
+                                      HPX_FORWARD(Senders, senders)...),
             HPX_FORWARD(F, f)))
     {
-        return hpx::execution::experimental::then(
-            hpx::execution::experimental::when_all(
-                HPX_FORWARD(Sender, sender), HPX_FORWARD(Senders, senders)...),
+        return hpxexec::then(hpxexec::when_all(HPX_FORWARD(Sender, sender),
+                                 HPX_FORWARD(Senders, senders)...),
             HPX_FORWARD(F, f));
     }
 }    // namespace hpx::execution::experimental
diff --git a/libs/core/execution/include/hpx/execution/algorithms/when_all_vector.hpp b/libs/core/execution/include/hpx/execution/algorithms/when_all_vector.hpp
index b2c1f6db25c7..a753d9c76885 100644
--- a/libs/core/execution/include/hpx/execution/algorithms/when_all_vector.hpp
+++ b/libs/core/execution/include/hpx/execution/algorithms/when_all_vector.hpp
@@ -41,6 +41,7 @@
 #include <vector>
 
 namespace hpx::when_all_vector_detail {
+    namespace hpxexec = hpx::execution::experimental;
 
     // callback object to request cancellation
     struct on_stop_requested
@@ -85,11 +86,9 @@ namespace hpx::when_all_vector_detail {
 
         // We expect a single value type or nothing from the predecessor
         // sender type
-        using element_value_type =
-            std::decay_t<hpx::execution::experimental::detail::single_result_t<
-                hpx::execution::experimental::value_types_of_t<Sender,
-                    hpx::execution::experimental::empty_env, meta::pack,
-                    meta::pack>>>;
+        using element_value_type = std::decay_t<
+            hpxexec::detail::single_result_t<hpxexec::value_types_of_t<Sender,
+                hpxexec::empty_env, meta::pack, meta::pack>>>;
 
         static constexpr bool is_void_value_type =
             std::is_void_v<element_value_type>;
@@ -107,14 +106,13 @@ namespace hpx::when_all_vector_detail {
         template <typename T, typename Dummy = void>
         struct set_value_completion_helper
         {
-            using type = hpx::execution::experimental::set_value_t(
-                std::vector<T>);
+            using type = hpxexec::set_value_t(std::vector<T>);
         };
 
         template <typename Dummy>
         struct set_value_completion_helper<void, Dummy>
         {
-            using type = hpx::execution::experimental::set_value_t();
+            using type = hpxexec::set_value_t();
         };
 
         using set_value_transform_to_vector =
@@ -122,23 +120,19 @@ namespace hpx::when_all_vector_detail {
 
         template <typename...>
         using transformed_comp_sigs_identity =
-            hpx::execution::experimental::completion_signatures<
-                set_value_transform_to_vector>;
+            hpxexec::completion_signatures<set_value_transform_to_vector>;
 
         template <typename Err>
         using decay_set_error =
-            hpx::execution::experimental::completion_signatures<
-                hpx::execution::experimental::set_error_t(std::decay_t<Err>)>;
+            hpxexec::completion_signatures<hpxexec::set_error_t(
+                std::decay_t<Err>)>;
 
         template <typename Env>
-        friend auto tag_invoke(
-            hpx::execution::experimental::get_completion_signatures_t,
+        friend auto tag_invoke(hpxexec::get_completion_signatures_t,
             when_all_vector_sender_type const&, Env const&) noexcept
-            -> hpx::execution::experimental::transform_completion_signatures_of<
-                Sender, Env,
-                hpx::execution::experimental::completion_signatures<
-                    hpx::execution::experimental::set_error_t(
-                        std::exception_ptr)>,
+            -> hpxexec::transform_completion_signatures_of<Sender, Env,
+                hpxexec::completion_signatures<hpxexec::set_error_t(
+                    std::exception_ptr)>,
                 transformed_comp_sigs_identity, decay_set_error>;
 #else
         // This sender sends a single vector of the type sent by the
@@ -157,8 +151,7 @@ namespace hpx::when_all_vector_detail {
             template <template <typename...> class Variant>
             using error_types = hpx::util::detail::unique_concat_t<
                 hpx::util::detail::transform_t<
-                    hpx::execution::experimental::error_types_of_t<Sender, Env,
-                        Variant>,
+                    hpxexec::error_types_of_t<Sender, Env, Variant>,
                     std::decay>,
                 Variant<std::exception_ptr>>;
 
@@ -168,7 +161,7 @@ namespace hpx::when_all_vector_detail {
         // clang-format off
         template <typename Env>
         friend auto tag_invoke(
-            hpx::execution::experimental::get_completion_signatures_t,
+            hpxexec::get_completion_signatures_t,
             when_all_vector_sender_type const&,
             Env) noexcept -> generate_completion_signatures<Env>;
         // clang-format on
@@ -186,15 +179,13 @@ namespace hpx::when_all_vector_detail {
             struct when_all_vector_receiver
             {
 #if defined(HPX_HAVE_STDEXEC)
-                using receiver_concept =
-                    hpx::execution::experimental::receiver_t;
+                using receiver_concept = hpxexec::receiver_t;
 #endif
                 operation_state& op_state;
                 std::size_t const i;
 
                 template <typename Error>
-                friend void tag_invoke(
-                    hpx::execution::experimental::set_error_t,
+                friend void tag_invoke(hpxexec::set_error_t,
                     when_all_vector_receiver&& r, Error&& error) noexcept
                 {
                     if (!r.op_state.set_stopped_error_called.exchange(true))
@@ -214,8 +205,7 @@ namespace hpx::when_all_vector_detail {
                     r.op_state.finish();
                 }
 
-                friend void tag_invoke(
-                    hpx::execution::experimental::set_stopped_t,
+                friend void tag_invoke(hpxexec::set_stopped_t,
                     when_all_vector_receiver&& r) noexcept
                 {
                     // request stop only if we're not in error state
@@ -227,8 +217,7 @@ namespace hpx::when_all_vector_detail {
                 };
 
                 template <typename... Ts>
-                friend void tag_invoke(
-                    hpx::execution::experimental::set_value_t,
+                friend void tag_invoke(hpxexec::set_value_t,
                     when_all_vector_receiver&& r, Ts&&... ts) noexcept
                 {
                     if (!r.op_state.set_stopped_error_called)
@@ -261,14 +250,14 @@ namespace hpx::when_all_vector_detail {
 
                 // clang-format off
                 // TODO: Make this a method
-                friend auto tag_invoke(hpx::execution::experimental::get_env_t,
+                friend auto tag_invoke(hpxexec::get_env_t,
                     when_all_vector_receiver const& r)
 #if defined(HPX_HAVE_STDEXEC)
                     noexcept
-                    -> hpx::execution::experimental::env<
-                        hpx::execution::experimental::env_of_t<receiver_type>,
-                        hpx::execution::experimental::prop<
-                            hpx::execution::experimental::get_stop_token_t,
+                    -> hpxexec::env<
+                        hpxexec::env_of_t<receiver_type>,
+                        hpxexec::prop<
+                            hpxexec::get_stop_token_t,
                             hpx::experimental::in_place_stop_token>>
                 {
                     /* The new calling convention is:
@@ -278,26 +267,26 @@ namespace hpx::when_all_vector_detail {
                     // returning an env constructed directly with the
                     // temporaries returned by the functions causes wrong
                     // behaviour.
-                    auto e = hpx::execution::experimental::get_env(
+                    auto e = hpxexec::get_env(
                         r.op_state.receiver);
-                    auto p = hpx::execution::experimental::prop(
-                        hpx::execution::experimental::get_stop_token,
+                    auto p = hpxexec::prop(
+                        hpxexec::get_stop_token,
                         r.op_state.stop_source_.get_token());
-                    return hpx::execution::experimental::env(
+                    return hpxexec::env(
                         std::move(e), std::move(p));
                 }
 #else
-                    -> hpx::execution::experimental::make_env_t<
-                        hpx::execution::experimental::get_stop_token_t,
+                    -> hpxexec::make_env_t<
+                        hpxexec::get_stop_token_t,
                         hpx::experimental::in_place_stop_token,
-                        hpx::execution::experimental::env_of_t<receiver_type>>
+                        hpxexec::env_of_t<receiver_type>>
                 {
                     /* The old calling convention is:
                      * make_env<tag>(val, old_env) */
-                    return hpx::execution::experimental::make_env<
-                        hpx::execution::experimental::get_stop_token_t>(
+                    return hpxexec::make_env<
+                        hpxexec::get_stop_token_t>(
                         r.op_state.stop_source_.get_token(),
-                        hpx::execution::experimental::get_env(
+                        hpxexec::get_env(
                             r.op_state.receiver));
                 }
 #endif
@@ -309,8 +298,8 @@ namespace hpx::when_all_vector_detail {
 
             hpx::experimental::in_place_stop_source stop_source_{};
 
-            using stop_token_t = hpx::execution::experimental::stop_token_of_t<
-                hpx::execution::experimental::env_of_t<receiver_type>&>;
+            using stop_token_t =
+                hpxexec::stop_token_of_t<hpxexec::env_of_t<receiver_type>&>;
             hpx::optional<typename stop_token_t::template callback_type<
                 on_stop_requested>>
                 on_stop_{};
@@ -330,15 +319,13 @@ namespace hpx::when_all_vector_detail {
             // The first error sent by any predecessor sender is stored in a
             // optional of a variant of the error_types
 #if defined(HPX_HAVE_STDEXEC)
-            using error_types =
-                typename hpx::execution::experimental::error_types_of_t<
-                    when_all_vector_sender_impl<
-                        Sender>::when_all_vector_sender_type,
-                    hpx::execution::experimental::empty_env, hpx::variant>;
+            using error_types = typename hpxexec::error_types_of_t<
+                when_all_vector_sender_impl<
+                    Sender>::when_all_vector_sender_type,
+                hpxexec::empty_env, hpx::variant>;
 #else
             using error_types = typename generate_completion_signatures<
-                hpx::execution::experimental::empty_env>::
-                template error_types<hpx::variant>;
+                hpxexec::empty_env>::template error_types<hpx::variant>;
 #endif
             std::optional<error_types> error;
 
@@ -349,8 +336,7 @@ namespace hpx::when_all_vector_detail {
             // the operation states to handle the non-movability and
             // non-copyability of them
             using operation_state_type =
-                hpx::execution::experimental::connect_result_t<Sender,
-                    when_all_vector_receiver>;
+                hpxexec::connect_result_t<Sender, when_all_vector_receiver>;
             using operation_states_storage_type =
                 std::unique_ptr<std::optional<operation_state_type>[]>;
             operation_states_storage_type op_states = nullptr;
@@ -370,15 +356,13 @@ namespace hpx::when_all_vector_detail {
 #if defined(__NVCC__)
                     op_states[i].emplace(
                         hpx::util::detail::with_result_of([&]() {
-                            return hpx::execution::experimental::connect(
-                                std::move(sender),
+                            return hpxexec::connect(std::move(sender),
                                 when_all_vector_receiver{*this, i});
                         }));
 #else
                     op_states[i].emplace(
                         hpx::util::detail::with_result_of([&]() {
-                            return hpx::execution::experimental::connect(
-                                HPX_MOVE(sender),
+                            return hpxexec::connect(HPX_MOVE(sender),
                                 when_all_vector_receiver{*this, i});
                         }));
 #endif
@@ -386,7 +370,7 @@ namespace hpx::when_all_vector_detail {
                     // MSVC doesn't get copy elision quite right, the operation
                     // state must be constructed explicitly directly in place
                     op_states[i].template emplace_f<operation_state_type>(
-                        hpx::execution::experimental::connect, HPX_MOVE(sender),
+                        hpxexec::connect, HPX_MOVE(sender),
                         when_all_vector_receiver{*this, i});
 #endif
                     ++i;
@@ -411,8 +395,7 @@ namespace hpx::when_all_vector_detail {
                     {
                         if constexpr (is_void_value_type)
                         {
-                            hpx::execution::experimental::set_value(
-                                HPX_MOVE(receiver));
+                            hpxexec::set_value(HPX_MOVE(receiver));
                         }
                         else
                         {
@@ -426,16 +409,14 @@ namespace hpx::when_all_vector_detail {
                                 values.push_back(HPX_MOVE(t.value()));
 #endif
                             }
-                            hpx::execution::experimental::set_value(
-                                HPX_MOVE(receiver), HPX_MOVE(values));
+                            hpxexec::set_value(HPX_MOVE(receiver), HPX_MOVE(values));
                         }
                     }
                     else if (error)
                     {
                         hpx::visit(
                             [this](auto&& error) {
-                                hpx::execution::experimental::set_error(
-                                    HPX_MOVE(receiver),
+                                hpxexec::set_error(HPX_MOVE(receiver),
                                     HPX_FORWARD(decltype(error), error));
                             },
                             HPX_MOVE(error.value()));
@@ -443,12 +424,10 @@ namespace hpx::when_all_vector_detail {
                     else
                     {
 #if defined(HPX_HAVE_STDEXEC)
-                        if constexpr (hpx::execution::experimental::
-                                          sends_stopped<Sender>)
+                        if constexpr (hpxexec::sends_stopped<Sender>)
                         {
 #endif
-                            hpx::execution::experimental::set_stopped(
-                                HPX_MOVE(receiver));
+                            hpxexec::set_stopped(HPX_MOVE(receiver));
 #if defined(HPX_HAVE_STDEXEC)
                         }
                         else
@@ -460,21 +439,18 @@ namespace hpx::when_all_vector_detail {
                 }
             }
 
-            friend void tag_invoke(hpx::execution::experimental::start_t,
-                operation_state& os) noexcept
+            friend void tag_invoke(hpxexec::start_t, operation_state& os) noexcept
             {
                 // register stop callback
                 os.on_stop_.emplace(
-                    hpx::execution::experimental::get_stop_token(
-                        hpx::execution::experimental::get_env(os.receiver)),
+                    hpxexec::get_stop_token(hpxexec::get_env(os.receiver)),
                     on_stop_requested{os.stop_source_});
 
                 // If a stop has already been requested. Don't bother starting
                 // the child operations.
                 if (os.stop_source_.stop_requested())
                 {
-                    hpx::execution::experimental::set_stopped(
-                        HPX_FORWARD(Receiver, os.receiver));
+                    hpxexec::set_stopped(HPX_FORWARD(Receiver, os.receiver));
                     return;
                 }
 
@@ -486,15 +462,13 @@ namespace hpx::when_all_vector_detail {
                     // send nothing to the continuation.
                     if constexpr (is_void_value_type)
                     {
-                        hpx::execution::experimental::set_value(
-                            HPX_MOVE(os.receiver));
+                        hpxexec::set_value(HPX_MOVE(os.receiver));
                     }
                     // If the predecessor sender type sends something we
                     // send an empty vector of that type to the continuation.
                     else
                     {
-                        hpx::execution::experimental::set_value(
-                            HPX_MOVE(os.receiver),
+                        hpxexec::set_value(HPX_MOVE(os.receiver),
                             std::vector<element_value_type>{});
                     }
                 }
@@ -504,24 +478,23 @@ namespace hpx::when_all_vector_detail {
                 {
                     for (std::size_t i = 0; i < os.num_predecessors; ++i)
                     {
-                        hpx::execution::experimental::start(
-                            os.op_states.get()[i].value());
+                        hpxexec::start(os.op_states.get()[i].value());
                     }
                 }
             }
         };
 
         template <typename Receiver>
-        friend auto tag_invoke(hpx::execution::experimental::connect_t,
-            when_all_vector_sender_type&& s, Receiver&& receiver)
+        friend auto tag_invoke(
+            hpxexec::connect_t, when_all_vector_sender_type&& s, Receiver&& receiver)
         {
             return operation_state<Receiver>(
                 HPX_FORWARD(Receiver, receiver), HPX_MOVE(s.senders));
         }
 
         template <typename Receiver>
-        friend auto tag_invoke(hpx::execution::experimental::connect_t,
-            when_all_vector_sender_type& s, Receiver&& receiver)
+        friend auto tag_invoke(
+            hpxexec::connect_t, when_all_vector_sender_type& s, Receiver&& receiver)
         {
             return operation_state<Receiver>(receiver, s.senders);
         }
@@ -530,6 +503,7 @@ namespace hpx::when_all_vector_detail {
 
 namespace hpx::execution::experimental {
 
+    namespace hpxexec = hpx::execution::experimental;
     // execution::when_all_vector is an extension over P2300 (wg21.link/p2300)
     //
     // execution::when_all_vector is used to join an arbitrary number of sender
@@ -557,7 +531,7 @@ namespace hpx::execution::experimental {
         // clang-format off
         template <typename Sender,
             HPX_CONCEPT_REQUIRES_(
-                is_sender_v<Sender>
+                hpxexec::is_sender_v<Sender>
             )>
         // clang-format on
         friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(
@@ -570,7 +544,7 @@ namespace hpx::execution::experimental {
         // clang-format off
         template <typename Sender,
             HPX_CONCEPT_REQUIRES_(
-                is_sender_v<Sender>
+                hpxexec::is_sender_v<Sender>
             )>
         // clang-format on
         friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(
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 dbc2e40441ba..550f0269b6b3 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
@@ -326,6 +326,8 @@ struct hpx::detail::empty_vtable_type<
 
 namespace hpx::execution::experimental::detail {
 
+    namespace hpxexec = hpx::execution::experimental;
+
     template <typename Sender, typename Receiver>
     struct any_operation_state_impl final : any_operation_state_base
     {
@@ -333,14 +335,14 @@ namespace hpx::execution::experimental::detail {
 
         template <typename Sender_, typename Receiver_>
         any_operation_state_impl(Sender_&& sender, Receiver_&& receiver)
-          : operation_state(hpx::execution::experimental::connect(
+          : operation_state(hpxexec::connect(
                 HPX_FORWARD(Sender_, sender), HPX_FORWARD(Receiver_, receiver)))
         {
         }
 
         void start() & noexcept override
         {
-            hpx::execution::experimental::start(operation_state);
+            hpxexec::start(operation_state);
         }
     };
 
@@ -378,8 +380,7 @@ namespace hpx::execution::experimental::detail {
         any_operation_state& operator=(any_operation_state const&) = delete;
 
         HPX_CORE_EXPORT friend void tag_invoke(
-            hpx::execution::experimental::start_t,
-            any_operation_state& os) noexcept;
+            hpxexec::start_t, any_operation_state& os) noexcept;
     };
 
     template <typename... Ts>
@@ -441,6 +442,7 @@ struct hpx::detail::empty_vtable_type<
 
 namespace hpx::execution::experimental::detail {
 
+    namespace hpxexec = hpx::execution::experimental;
     template <typename Receiver, typename... Ts>
     struct any_receiver_impl final : any_receiver_base<Ts...>
     {
@@ -462,19 +464,17 @@ namespace hpx::execution::experimental::detail {
 
         void set_value(Ts... ts) && override
         {
-            hpx::execution::experimental::set_value(
-                HPX_MOVE(receiver), HPX_MOVE(ts)...);
+            hpxexec::set_value(HPX_MOVE(receiver), HPX_MOVE(ts)...);
         }
 
         void set_error(std::exception_ptr ep) && noexcept override
         {
-            hpx::execution::experimental::set_error(
-                HPX_MOVE(receiver), HPX_MOVE(ep));
+            hpxexec::set_error(HPX_MOVE(receiver), HPX_MOVE(ep));
         }
 
         void set_stopped() && noexcept override
         {
-            hpx::execution::experimental::set_stopped(HPX_MOVE(receiver));
+            hpxexec::set_stopped(HPX_MOVE(receiver));
         }
     };
 
@@ -518,8 +518,8 @@ namespace hpx::execution::experimental::detail {
         any_receiver& operator=(any_receiver&&) = default;
         any_receiver& operator=(any_receiver const&) = delete;
 
-        friend void tag_invoke(hpx::execution::experimental::set_value_t,
-            any_receiver&& r, Ts&&... ts) noexcept
+        friend void tag_invoke(
+            hpxexec::set_value_t, any_receiver&& r, Ts&&... ts) noexcept
         {
             // We first move the storage to a temporary variable so that this
             // any_receiver is empty after this set_value. Doing
@@ -539,8 +539,8 @@ namespace hpx::execution::experimental::detail {
             }
         }
 
-        friend void tag_invoke(hpx::execution::experimental::set_error_t,
-            any_receiver&& r, std::exception_ptr ep) noexcept
+        friend void tag_invoke(hpxexec::set_error_t, any_receiver&& r,
+            std::exception_ptr ep) noexcept
         {
             // We first move the storage to a temporary variable so that this
             // any_receiver is empty after this set_error. Doing
@@ -550,8 +550,8 @@ namespace hpx::execution::experimental::detail {
             HPX_MOVE(moved_storage.get()).set_error(HPX_MOVE(ep));
         }
 
-        friend void tag_invoke(hpx::execution::experimental::set_stopped_t,
-            any_receiver&& r) noexcept
+        friend void tag_invoke(
+            hpxexec::set_stopped_t, any_receiver&& r) noexcept
         {
             // We first move the storage to a temporary variable so that this
             // any_receiver is empty after this set_stopped. Doing
@@ -711,6 +711,7 @@ namespace hpx::execution::experimental::detail {
 
 namespace hpx::execution::experimental {
 
+    namespace hpxexec = hpx::execution::experimental;
 #if defined(HPX_MSVC) || !defined(HPX_HAVE_CXX20_TRIVIAL_VIRTUAL_DESTRUCTOR)
     namespace detail {
         // This helper only exists to make it possible to use
@@ -786,8 +787,8 @@ namespace hpx::execution::experimental {
 #if defined(HPX_HAVE_STDEXEC)
         // TODO: Remove this
         using completion_signatures =
-            hpx::execution::experimental::completion_signatures<
-                set_value_t(Ts...), set_error_t(std::exception_ptr)>;
+            hpxexec::completion_signatures<set_value_t(Ts...),
+                set_error_t(std::exception_ptr)>;
 #else
         // clang-format off
         template <typename Env>
@@ -800,8 +801,7 @@ namespace hpx::execution::experimental {
 
         template <typename R>
         friend detail::any_operation_state tag_invoke(
-            hpx::execution::experimental::connect_t, unique_any_sender&& s,
-            R&& r)
+            hpxexec::connect_t, unique_any_sender&& s, R&& r)
         {
             // We first move the storage to a temporary variable so that this
             // any_sender is empty after this connect. Doing
@@ -873,8 +873,8 @@ namespace hpx::execution::experimental {
 #if defined(HPX_HAVE_STDEXEC)
         // TODO: Remove this
         using completion_signatures =
-            hpx::execution::experimental::completion_signatures<
-                set_value_t(Ts...), set_error_t(std::exception_ptr)>;
+            hpxexec::completion_signatures<set_value_t(Ts...),
+                set_error_t(std::exception_ptr)>;
 #else
         // clang-format off
         template <typename Env>
@@ -886,7 +886,7 @@ namespace hpx::execution::experimental {
 
         template <typename R>
         friend detail::any_operation_state tag_invoke(
-            hpx::execution::experimental::connect_t, any_sender& s, R&& r)
+            hpxexec::connect_t, any_sender& s, R&& r)
         {
             return s.storage.get().connect(
                 detail::any_receiver<Ts...>{HPX_FORWARD(R, r)});
@@ -894,7 +894,7 @@ namespace hpx::execution::experimental {
 
         template <typename R>
         friend detail::any_operation_state tag_invoke(
-            hpx::execution::experimental::connect_t, any_sender&& s, R&& r)
+            hpxexec::connect_t, any_sender&& s, R&& r)
         {
             // We first move the storage to a temporary variable so that this
             // any_sender is empty after this connect. Doing
@@ -909,21 +909,18 @@ namespace hpx::execution::experimental {
 
 namespace hpx::detail {
 
+    namespace hpxexec = hpx::execution::experimental;
+
     template <typename... Ts>
-    struct empty_vtable_type<
-        hpx::execution::experimental::detail::unique_any_sender_base<Ts...>>
+    struct empty_vtable_type<hpxexec::detail::unique_any_sender_base<Ts...>>
     {
-        using type =
-            hpx::execution::experimental::detail::empty_unique_any_sender<
-                Ts...>;
+        using type = hpxexec::detail::empty_unique_any_sender<Ts...>;
     };
 
     template <typename... Ts>
-    struct empty_vtable_type<
-        hpx::execution::experimental::detail::any_sender_base<Ts...>>
+    struct empty_vtable_type<hpxexec::detail::any_sender_base<Ts...>>
     {
-        using type =
-            hpx::execution::experimental::detail::empty_any_sender<Ts...>;
+        using type = hpxexec::detail::empty_any_sender<Ts...>;
     };
 }    // namespace hpx::detail
 
diff --git a/libs/core/execution_base/include/hpx/execution_base/completion_scheduler.hpp b/libs/core/execution_base/include/hpx/execution_base/completion_scheduler.hpp
index e0f6af7b3f25..97d2a4230d1a 100644
--- a/libs/core/execution_base/include/hpx/execution_base/completion_scheduler.hpp
+++ b/libs/core/execution_base/include/hpx/execution_base/completion_scheduler.hpp
@@ -15,13 +15,14 @@
 #include <utility>
 
 namespace hpx::execution::experimental { namespace detail {
+    namespace hpxexec = hpx::execution::experimental;
     // clang-format off
     template <typename CPO, typename Sender>
     concept has_completion_scheduler_v = requires(Sender&& s) {
         {
-            hpx::execution::experimental::get_completion_scheduler<CPO>(
-                hpx::execution::experimental::get_env(std::forward<Sender>(s)))
-        } -> hpx::execution::experimental::scheduler;
+            hpxexec::get_completion_scheduler<CPO>(
+                hpxexec::get_env(std::forward<Sender>(s)))
+        } -> hpxexec::scheduler;
     };
 
     template <typename ReceiverCPO, typename Sender, typename AlgorithmCPO,
@@ -29,8 +30,8 @@ namespace hpx::execution::experimental { namespace detail {
     concept is_completion_scheduler_tag_invocable_v = requires(
         AlgorithmCPO alg, Sender&& snd, Ts&&... ts) {
         tag_invoke(alg,
-            hpx::execution::experimental::get_completion_scheduler<ReceiverCPO>(
-                hpx::execution::experimental::get_env(snd)),
+            hpxexec::get_completion_scheduler<ReceiverCPO>(
+                hpxexec::get_env(snd)),
             std::forward<Sender>(snd), std::forward<Ts>(ts)...);
     };
     // clang-format on
diff --git a/libs/core/execution_base/include/hpx/execution_base/completion_signatures.hpp b/libs/core/execution_base/include/hpx/execution_base/completion_signatures.hpp
index 99c708d4647b..41f7b23594ab 100644
--- a/libs/core/execution_base/include/hpx/execution_base/completion_signatures.hpp
+++ b/libs/core/execution_base/include/hpx/execution_base/completion_signatures.hpp
@@ -37,6 +37,8 @@
 
 namespace hpx::execution::experimental {
 
+    namespace hpxexec = hpx::execution::experimental;
+
     // empty_variant will be returned by execution::value_types_of_t and
     // execution::error_types_of_t if no signatures are provided.
     struct empty_variant
@@ -476,9 +478,7 @@ namespace hpx::execution::experimental {
     // operations.
 #if defined(HPX_HAVE_STDEXEC)
     template <typename Sender, typename... Env>
-    struct is_sender_in
-      : std::bool_constant<
-            hpx::execution::experimental::sender_in<Sender, Env...>>
+    struct is_sender_in : std::bool_constant<hpxexec::sender_in<Sender, Env...>>
     {
     };
 
@@ -486,8 +486,7 @@ namespace hpx::execution::experimental {
     inline constexpr bool is_sender_in_v = is_sender_in<Sender, Env...>::value;
 
     template <typename Sender>
-    struct is_sender
-      : std::bool_constant<hpx::execution::experimental::sender<Sender>>
+    struct is_sender : std::bool_constant<hpxexec::sender<Sender>>
     {
     };
 
@@ -497,8 +496,7 @@ namespace hpx::execution::experimental {
     // \see is_sender
     template <typename Sender, typename Receiver>
     struct is_sender_to
-      : std::bool_constant<
-            hpx::execution::experimental::sender_to<Sender, Receiver>>
+      : std::bool_constant<hpxexec::sender_to<Sender, Receiver>>
     {
     };
 
@@ -509,15 +507,14 @@ namespace hpx::execution::experimental {
     // The sender_of concept defines the requirements for a sender type that on
     // successful completion sends the specified set of value types.
     template <typename Sender, typename Signal,
-        typename Env = hpx::execution::experimental::empty_env>
+        typename Env = hpxexec::empty_env>
     struct is_sender_of
-      : std::bool_constant<
-            hpx::execution::experimental::sender_of<Sender, Signal, Env>>
+      : std::bool_constant<hpxexec::sender_of<Sender, Signal, Env>>
     {
     };
 
     template <typename Sender, typename Signal,
-        typename Env = hpx::execution::experimental::empty_env>
+        typename Env = hpxexec::empty_env>
     inline constexpr bool is_sender_of_v =
         is_sender_of<Sender, Signal, Env>::value;
 
@@ -533,11 +530,9 @@ namespace hpx::execution::experimental {
     // single-sender-value-type<S, E> is an alias for type void.
     // 3. Otherwise, single-sender-value-type<S, E> is ill-formed.
     //
-    template <typename Sender,
-        typename Env = hpx::execution::experimental::empty_env>
+    template <typename Sender, typename Env = hpxexec::empty_env>
     using single_sender_value_t =
-        hpx::execution::experimental::stdexec_internal::__single_sender_value_t<
-            Sender, Env>;
+        hpxexec::stdexec_internal::__single_sender_value_t<Sender, Env>;
 
     template <typename A, typename B>
     inline constexpr bool is_derived_from_v = std::derived_from<A, B>;
@@ -548,23 +543,24 @@ namespace hpx::execution::experimental {
     //    hpx::execution::experimental::with_awaitable_senders<Promise>;
 
     template <typename ReceiverID>
-    using operation = hpx::execution::experimental::stdexec_internal::
-        __connect_awaitable_::__operation<ReceiverID>;
+    using operation =
+        hpxexec::stdexec_internal::__connect_awaitable_::__operation<
+            ReceiverID>;
 
     template <typename ReceiverID>
-    using promise = hpx::execution::experimental::stdexec_internal::
-        __connect_awaitable_::__promise<ReceiverID>;
+    using promise =
+        hpxexec::stdexec_internal::__connect_awaitable_::__promise<ReceiverID>;
 
     template <typename Rec>
-    using promise_t = hpx::execution::experimental::stdexec_internal::
-        __connect_awaitable_::__promise_t<Rec>;
+    using promise_t =
+        hpxexec::stdexec_internal::__connect_awaitable_::__promise_t<Rec>;
 
     template <typename Rec>
-    using operation_t = hpx::execution::experimental::stdexec_internal::
-        __connect_awaitable_::__operation_t<Rec>;
+    using operation_t =
+        hpxexec::stdexec_internal::__connect_awaitable_::__operation_t<Rec>;
 
     using connect_awaitable_t =
-        hpx::execution::experimental::stdexec_internal::__connect_awaitable_t;
+        hpxexec::stdexec_internal::__connect_awaitable_t;
     inline constexpr connect_awaitable_t connect_awaitable{};
 #else
     template <typename Sender, typename Env = no_env>
@@ -1606,7 +1602,7 @@ namespace hpx::execution::experimental {
     template <typename Sender, typename Receiver>
     struct has_nothrow_connect
       : std::integral_constant<bool,
-            noexcept(hpx::execution::experimental::connect(
+            noexcept(hpxexec::connect(
                 std::declval<Sender>(), std::declval<Receiver>()))>
     {
     };

From fb679f873d2d007e80d378e563acfc1d8de4e33b Mon Sep 17 00:00:00 2001
From: isidorostsa <tsa.isidoros@gmail.com>
Date: Fri, 16 May 2025 20:37:38 +0300
Subject: [PATCH 4/4] rem all #ifdef HPX_HAVE_STDEXEC

---
 .../parallel/util/detail/algorithm_result.hpp |    2 -
 .../algorithms/adjacentdifference_tests.hpp   |    2 -
 .../unit/algorithms/adjacentfind_tests.hpp    |    2 -
 .../tests/unit/algorithms/all_of_tests.hpp    |    2 -
 .../tests/unit/algorithms/any_of_tests.hpp    |    2 -
 .../tests/unit/algorithms/copy_tests.hpp      |    2 -
 .../tests/unit/algorithms/copyn_tests.hpp     |    2 -
 .../tests/unit/algorithms/count_tests.hpp     |    2 -
 .../tests/unit/algorithms/countif_tests.hpp   |    2 -
 .../tests/unit/algorithms/destroy_tests.hpp   |    2 -
 .../unit/algorithms/equal_binary_tests.hpp    |    4 -
 .../tests/unit/algorithms/equal_tests.hpp     |    4 -
 .../tests/unit/algorithms/fill_tests.hpp      |    2 -
 .../tests/unit/algorithms/filln_tests.hpp     |    2 -
 .../tests/unit/algorithms/find_tests.hpp      |    4 -
 .../tests/unit/algorithms/findend_tests.hpp   |    4 -
 .../unit/algorithms/findfirstof_tests.hpp     |    2 -
 .../tests/unit/algorithms/findif_tests.hpp    |    2 -
 .../tests/unit/algorithms/findifnot_tests.hpp |    2 -
 .../tests/unit/algorithms/foreach_tests.hpp   |    2 -
 .../tests/unit/algorithms/generate_tests.hpp  |    2 -
 .../tests/unit/algorithms/generaten_tests.hpp |    2 -
 .../tests/unit/algorithms/is_heap_tests.hpp   |    2 -
 .../tests/unit/algorithms/is_sorted_tests.hpp |    2 -
 .../unit/algorithms/mismatch_binary_tests.hpp |    2 -
 .../tests/unit/algorithms/mismatch_tests.hpp  |    2 -
 .../tests/unit/algorithms/none_of_tests.hpp   |    2 -
 .../tests/unit/algorithms/reduce_tests.hpp    |    2 -
 .../tests/unit/algorithms/remove_tests.hpp    |    2 -
 .../algorithms/transform_binary2_tests.hpp    |    2 -
 .../algorithms/transform_binary_tests.hpp     |    2 -
 .../transform_reduce_binary_tests.hpp         |    2 -
 .../tests/unit/algorithms/transform_tests.hpp |    2 -
 .../tests/unit/algorithms/unique_tests.hpp    |    2 -
 .../adjacentdifference_range_sender.cpp       |    6 -
 .../hpx/async_cuda/transform_stream.hpp       |   64 -
 .../include/hpx/async_mpi/transform_mpi.hpp   |   48 -
 .../tests/unit/algorithm_transform_mpi.cpp    |   15 +-
 .../tests/unit/mpi_ring_async_executor.cpp    |   42 +-
 .../hpx/execution/algorithms/as_sender.hpp    |   28 -
 .../include/hpx/execution/algorithms/bulk.hpp |   60 +-
 .../algorithms/detail/partial_algorithm.hpp   |    6 -
 .../execution/algorithms/ensure_started.hpp   |  152 --
 .../hpx/execution/algorithms/execute.hpp      |   42 -
 .../include/hpx/execution/algorithms/just.hpp |  194 --
 .../hpx/execution/algorithms/keep_future.hpp  |   14 -
 .../hpx/execution/algorithms/let_error.hpp    |  468 -----
 .../hpx/execution/algorithms/let_stopped.hpp  |  366 ----
 .../hpx/execution/algorithms/let_value.hpp    |  483 -----
 .../hpx/execution/algorithms/make_future.hpp  |   24 +-
 .../hpx/execution/algorithms/run_loop.hpp     |  404 -----
 .../execution/algorithms/schedule_from.hpp    |  362 ----
 .../hpx/execution/algorithms/split.hpp        |  692 --------
 .../execution/algorithms/start_detached.hpp   |  290 ---
 .../hpx/execution/algorithms/sync_wait.hpp    |  577 ------
 .../include/hpx/execution/algorithms/then.hpp |  239 ---
 .../hpx/execution/algorithms/transfer.hpp     |   83 -
 .../execution/algorithms/transfer_just.hpp    |   35 -
 .../hpx/execution/algorithms/when_all.hpp     |  574 ------
 .../execution/algorithms/when_all_vector.hpp  |   80 +-
 .../hpx/execution/queries/get_allocator.hpp   |   42 -
 .../queries/get_delegatee_scheduler.hpp       |   44 -
 .../hpx/execution/queries/get_scheduler.hpp   |  135 --
 .../hpx/execution/queries/get_stop_token.hpp  |   61 -
 .../include/hpx/execution/queries/read.hpp    |  159 --
 libs/core/execution/src/run_loop.cpp          |   19 -
 .../tests/unit/algorithm_as_sender.cpp        |   24 -
 .../execution/tests/unit/algorithm_bulk.cpp   |   56 -
 .../tests/unit/algorithm_ensure_started.cpp   |   96 -
 .../tests/unit/algorithm_execute.cpp          |   16 -
 .../execution/tests/unit/algorithm_just.cpp   |   81 -
 .../tests/unit/algorithm_just_error.cpp       |   13 -
 .../tests/unit/algorithm_just_stopped.cpp     |   12 -
 .../tests/unit/algorithm_let_error.cpp        |   72 -
 .../tests/unit/algorithm_let_stopped.cpp      |   56 -
 .../tests/unit/algorithm_let_value.cpp        |   36 -
 .../execution/tests/unit/algorithm_split.cpp  |  140 --
 .../tests/unit/algorithm_start_detached.cpp   |   18 +-
 .../tests/unit/algorithm_sync_wait.cpp        |   19 -
 .../unit/algorithm_sync_wait_with_variant.cpp |   33 -
 .../execution/tests/unit/algorithm_then.cpp   |   80 -
 .../tests/unit/algorithm_transfer.cpp         |   53 -
 .../tests/unit/algorithm_transfer_just.cpp    |   62 -
 .../unit/algorithm_transfer_when_all.cpp      |   16 -
 .../tests/unit/algorithm_when_all.cpp         |  233 ---
 .../tests/unit/algorithm_when_all_vector.cpp  |  156 --
 .../tests/unit/environment_queries.cpp        |   56 -
 .../tests/unit/forwarding_env_query.cpp       |   19 -
 .../tests/unit/forwarding_scheduler_query.cpp |   14 -
 .../tests/unit/forwarding_sender_query.cpp    |   24 -
 .../include/hpx/execution_base/any_sender.hpp |   19 -
 .../execution_base/completion_scheduler.hpp   |  156 --
 .../execution_base/completion_signatures.hpp  | 1576 -----------------
 .../hpx/execution_base/coroutine_utils.hpp    |   43 -
 .../include/hpx/execution_base/get_env.hpp    |  231 ---
 .../hpx/execution_base/operation_state.hpp    |   98 -
 .../include/hpx/execution_base/receiver.hpp   |  303 ----
 .../include/hpx/execution_base/sender.hpp     |  191 --
 .../hpx/execution_base/stdexec_forward.hpp    |    3 -
 .../hpx/execution_base/this_thread.hpp        |   52 -
 .../traits/coroutine_traits.hpp               |    8 -
 .../tests/include/algorithm_test_utils.hpp    |   66 -
 .../tests/include/coroutine_task.hpp          |    4 -
 .../execution_base/tests/unit/any_sender.cpp  |   24 -
 .../tests/unit/basic_operation_state.cpp      |   34 +-
 .../tests/unit/basic_receiver.cpp             |   44 +-
 .../tests/unit/basic_schedule.cpp             |   51 +-
 .../tests/unit/basic_sender.cpp               |  176 +-
 .../tests/unit/completion_signatures.cpp      |  187 --
 .../tests/unit/coroutine_traits.cpp           |   16 -
 .../tests/unit/coroutine_utils.cpp            |   83 -
 .../tests/unit/execute_may_block_caller.cpp   |    9 -
 .../execution_base/tests/unit/get_env.cpp     |   89 -
 .../execution_base/tests/unit/stdexec.cpp     |    4 -
 .../executors/explicit_scheduler_executor.hpp |   21 +-
 .../hpx/executors/thread_pool_scheduler.hpp   |   18 -
 .../executors/thread_pool_scheduler_bulk.hpp  |   59 -
 .../tests/unit/thread_pool_scheduler.cpp      |  449 +----
 .../hpx/synchronization/async_rw_mutex.hpp    |   40 -
 .../tests/unit/async_rw_mutex.cpp             |   10 +-
 120 files changed, 50 insertions(+), 11283 deletions(-)

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 ae04cb021c5f..a4866cb72a7d 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
@@ -18,10 +18,8 @@
 #include <hpx/futures/future.hpp>
 #include <hpx/type_support/unused.hpp>
 
-#if defined(HPX_HAVE_STDEXEC)
 // for is_sender
 #include <hpx/execution_base/completion_signatures.hpp>
-#endif
 
 #include <type_traits>
 #include <utility>
diff --git a/libs/core/algorithms/tests/unit/algorithms/adjacentdifference_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/adjacentdifference_tests.hpp
index 0bd32e56d915..e4c7a2667553 100644
--- a/libs/core/algorithms/tests/unit/algorithms/adjacentdifference_tests.hpp
+++ b/libs/core/algorithms/tests/unit/algorithms/adjacentdifference_tests.hpp
@@ -71,7 +71,6 @@ void test_adjacent_difference_direct(Policy l, ExPolicy policy)
     HPX_TEST(std::end(d) == it);
 }
 
-#if defined(HPX_HAVE_STDEXEC)
 template <typename Policy, typename ExPolicy>
 void test_adjacent_difference_sender(Policy l, ExPolicy&& policy)
 {
@@ -132,7 +131,6 @@ void test_adjacent_difference_sender(Policy l, ExPolicy&& policy)
         HPX_TEST(++std::begin(d) == result);
     }
 }
-#endif
 
 template <typename ExPolicy>
 void test_adjacent_difference_async(ExPolicy&& p)
diff --git a/libs/core/algorithms/tests/unit/algorithms/adjacentfind_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/adjacentfind_tests.hpp
index 5e34a2527791..ef89014cc5d5 100644
--- a/libs/core/algorithms/tests/unit/algorithms/adjacentfind_tests.hpp
+++ b/libs/core/algorithms/tests/unit/algorithms/adjacentfind_tests.hpp
@@ -55,7 +55,6 @@ void test_adjacent_find(ExPolicy policy, IteratorTag)
     HPX_TEST(index == iterator(test_index));
 }
 
-#if defined(HPX_HAVE_STDEXEC)
 template <typename LnPolicy, typename ExPolicy, typename IteratorTag>
 void test_adjacent_find_sender(
     LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
@@ -103,7 +102,6 @@ void test_adjacent_find_sender(
         HPX_TEST(iterator(std::begin(c)) == result);
     }
 }
-#endif
 
 template <typename ExPolicy, typename IteratorTag>
 void test_adjacent_find_async(ExPolicy p, IteratorTag)
diff --git a/libs/core/algorithms/tests/unit/algorithms/all_of_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/all_of_tests.hpp
index e229122b5633..cd4873aa9332 100644
--- a/libs/core/algorithms/tests/unit/algorithms/all_of_tests.hpp
+++ b/libs/core/algorithms/tests/unit/algorithms/all_of_tests.hpp
@@ -70,7 +70,6 @@ void test_all_of(ExPolicy&& policy, IteratorTag)
     }
 }
 
-#if defined(HPX_HAVE_STDEXEC)
 template <typename LnPolicy, typename ExPolicy, typename IteratorTag>
 void test_all_of_sender(LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
 {
@@ -104,7 +103,6 @@ void test_all_of_sender(LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
         HPX_TEST_EQ(result, expected);
     }
 }
-#endif
 
 template <typename IteratorTag, typename Proj = hpx::identity>
 void test_all_of_ranges_seq(IteratorTag, Proj proj = Proj())
diff --git a/libs/core/algorithms/tests/unit/algorithms/any_of_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/any_of_tests.hpp
index d4b601249b37..021221b430d8 100644
--- a/libs/core/algorithms/tests/unit/algorithms/any_of_tests.hpp
+++ b/libs/core/algorithms/tests/unit/algorithms/any_of_tests.hpp
@@ -70,7 +70,6 @@ void test_any_of(ExPolicy&& policy, IteratorTag)
     }
 }
 
-#if defined(HPX_HAVE_STDEXEC)
 template <typename LnPolicy, typename ExPolicy, typename IteratorTag>
 void test_any_of_sender(LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
 {
@@ -105,7 +104,6 @@ void test_any_of_sender(LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
         HPX_TEST_EQ(result, expected);
     }
 }
-#endif
 
 template <typename IteratorTag, typename Proj = hpx::identity>
 void test_any_of_ranges_seq(IteratorTag, Proj proj = Proj())
diff --git a/libs/core/algorithms/tests/unit/algorithms/copy_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/copy_tests.hpp
index 1e678fb6d29c..effba10741d2 100644
--- a/libs/core/algorithms/tests/unit/algorithms/copy_tests.hpp
+++ b/libs/core/algorithms/tests/unit/algorithms/copy_tests.hpp
@@ -73,7 +73,6 @@ void test_copy(ExPolicy&& policy, IteratorTag)
     HPX_TEST_EQ(count, d.size());
 }
 
-#if defined(HPX_HAVE_STDEXEC)
 template <typename LnPolicy, typename ExPolicy, typename IteratorTag>
 void test_copy_sender(LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
 {
@@ -107,7 +106,6 @@ void test_copy_sender(LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
         }));
     HPX_TEST_EQ(count, d.size());
 }
-#endif
 
 template <typename ExPolicy, typename IteratorTag>
 void test_copy_async(ExPolicy&& p, IteratorTag)
diff --git a/libs/core/algorithms/tests/unit/algorithms/copyn_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/copyn_tests.hpp
index f8ca0f3dcb27..f1213dda3ad3 100644
--- a/libs/core/algorithms/tests/unit/algorithms/copyn_tests.hpp
+++ b/libs/core/algorithms/tests/unit/algorithms/copyn_tests.hpp
@@ -74,7 +74,6 @@ void test_copy_n(ExPolicy&& policy, IteratorTag)
     HPX_TEST_EQ(count, d.size());
 }
 
-#if defined(HPX_HAVE_STDEXEC)
 template <typename LnPolicy, typename ExPolicy, typename IteratorTag>
 void test_copy_n_sender(LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
 {
@@ -111,7 +110,6 @@ void test_copy_n_sender(LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
         }));
     HPX_TEST_EQ(count, d.size());
 }
-#endif
 
 template <typename ExPolicy, typename IteratorTag>
 void test_copy_n_async(ExPolicy&& p, IteratorTag)
diff --git a/libs/core/algorithms/tests/unit/algorithms/count_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/count_tests.hpp
index 27062db0d269..d24642f9bee3 100644
--- a/libs/core/algorithms/tests/unit/algorithms/count_tests.hpp
+++ b/libs/core/algorithms/tests/unit/algorithms/count_tests.hpp
@@ -73,7 +73,6 @@ void test_count(ExPolicy&& policy, IteratorTag)
     HPX_TEST_EQ(num_items, static_cast<std::int64_t>(find_count));
 }
 
-#if defined(HPX_HAVE_STDEXEC)
 template <typename LnPolicy, typename ExPolicy, typename IteratorTag>
 void test_count_sender(LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
 {
@@ -106,7 +105,6 @@ void test_count_sender(LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
 
     HPX_TEST_EQ(num_items, static_cast<std::int64_t>(find_count));
 }
-#endif
 
 template <typename ExPolicy, typename IteratorTag>
 void test_count_async(ExPolicy&& p, IteratorTag)
diff --git a/libs/core/algorithms/tests/unit/algorithms/countif_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/countif_tests.hpp
index 3dd04ff8be96..92383a7beb5a 100644
--- a/libs/core/algorithms/tests/unit/algorithms/countif_tests.hpp
+++ b/libs/core/algorithms/tests/unit/algorithms/countif_tests.hpp
@@ -83,7 +83,6 @@ void test_count_if(ExPolicy&& policy, IteratorTag)
     HPX_TEST_EQ(num_items, 50u);
 }
 
-#if defined(HPX_HAVE_STDEXEC)
 template <typename LnPolicy, typename ExPolicy, typename IteratorTag>
 void test_count_if_sender(LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
 {
@@ -113,7 +112,6 @@ void test_count_if_sender(LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
 
     HPX_TEST_EQ(num_items, 50u);
 }
-#endif
 
 template <typename ExPolicy, typename IteratorTag>
 void test_count_if_async(ExPolicy&& p, IteratorTag)
diff --git a/libs/core/algorithms/tests/unit/algorithms/destroy_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/destroy_tests.hpp
index 68f7a1deaa41..b872013682d3 100644
--- a/libs/core/algorithms/tests/unit/algorithms/destroy_tests.hpp
+++ b/libs/core/algorithms/tests/unit/algorithms/destroy_tests.hpp
@@ -98,7 +98,6 @@ void test_destroy(ExPolicy&& policy, IteratorTag)
     std::free(p);
 }
 
-#if defined(HPX_HAVE_STDEXEC)
 template <typename LnPolicy, typename ExPolicy, typename IteratorTag>
 void test_destroy_sender(LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
 {
@@ -131,7 +130,6 @@ void test_destroy_sender(LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
 
     std::free(p);
 }
-#endif
 
 template <typename ExPolicy, typename IteratorTag>
 void test_destroy_async(ExPolicy&& policy, IteratorTag)
diff --git a/libs/core/algorithms/tests/unit/algorithms/equal_binary_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/equal_binary_tests.hpp
index 9754a0934e99..89d0e0b5241a 100644
--- a/libs/core/algorithms/tests/unit/algorithms/equal_binary_tests.hpp
+++ b/libs/core/algorithms/tests/unit/algorithms/equal_binary_tests.hpp
@@ -465,7 +465,6 @@ void test_equal_binary_bad_alloc_async(ExPolicy&& p, IteratorTag)
 
 ////////////////////////////////////////////////////////////////////////////////
 
-#if defined(HPX_HAVE_STDEXEC)
 template <typename LnPolicy, typename ExPolicy, typename IteratorTag>
 void test_equal_binary_sender(
     LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
@@ -521,7 +520,6 @@ void test_equal_binary_sender(
         HPX_TEST_EQ(result, expected);
     }
 }
-#endif
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -566,7 +564,6 @@ void test_equal_binary_edge_cases(ExPolicy&& policy, IteratorTag)
     }
 }
 
-#if defined(HPX_HAVE_STDEXEC)
 template <typename LnPolicy, typename ExPolicy, typename IteratorTag>
 void test_equal_binary_edge_cases_sender(
     LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
@@ -635,4 +632,3 @@ void test_equal_binary_edge_cases_sender(
         HPX_TEST(!result);
     }
 }
-#endif
diff --git a/libs/core/algorithms/tests/unit/algorithms/equal_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/equal_tests.hpp
index 81ca559e8e8a..f7eb4e8b2388 100644
--- a/libs/core/algorithms/tests/unit/algorithms/equal_tests.hpp
+++ b/libs/core/algorithms/tests/unit/algorithms/equal_tests.hpp
@@ -105,7 +105,6 @@ void test_equal1(ExPolicy&& policy, IteratorTag)
     }
 }
 
-#if defined(HPX_HAVE_STDEXEC)
 template <typename LnPolicy, typename ExPolicy, typename IteratorTag>
 void test_equal1_sender(LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
 {
@@ -173,7 +172,6 @@ void test_equal1_sender(LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
         HPX_TEST(result);
     }
 }
-#endif
 
 template <typename ExPolicy, typename IteratorTag>
 void test_equal1_async(ExPolicy&& p, IteratorTag)
@@ -296,7 +294,6 @@ void test_equal2(ExPolicy&& policy, IteratorTag)
     }
 }
 
-#if defined(HPX_HAVE_STDEXEC)
 template <typename LnPolicy, typename ExPolicy, typename IteratorTag>
 void test_equal2_sender(LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
 {
@@ -365,7 +362,6 @@ void test_equal2_sender(LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
         HPX_TEST(result);
     }
 }
-#endif
 
 template <typename ExPolicy, typename IteratorTag>
 void test_equal2_async(ExPolicy&& p, IteratorTag)
diff --git a/libs/core/algorithms/tests/unit/algorithms/fill_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/fill_tests.hpp
index 82423d46762e..ddfb2d98b1cf 100644
--- a/libs/core/algorithms/tests/unit/algorithms/fill_tests.hpp
+++ b/libs/core/algorithms/tests/unit/algorithms/fill_tests.hpp
@@ -71,7 +71,6 @@ void test_fill(ExPolicy policy, IteratorTag)
     HPX_TEST_EQ(count, c.size());
 }
 
-#if defined(HPX_HAVE_STDEXEC)
 template <typename LnPolicy, typename ExPolicy, typename IteratorTag>
 void test_fill_sender(LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
 {
@@ -101,7 +100,6 @@ void test_fill_sender(LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
     });
     HPX_TEST_EQ(count, c.size());
 }
-#endif
 
 template <typename ExPolicy, typename IteratorTag>
 void test_fill_async(ExPolicy p, IteratorTag)
diff --git a/libs/core/algorithms/tests/unit/algorithms/filln_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/filln_tests.hpp
index 829e11e5ca14..c5ecb92b7d5d 100644
--- a/libs/core/algorithms/tests/unit/algorithms/filln_tests.hpp
+++ b/libs/core/algorithms/tests/unit/algorithms/filln_tests.hpp
@@ -70,7 +70,6 @@ void test_fill_n(ExPolicy policy, IteratorTag)
     HPX_TEST_EQ(count, c.size());
 }
 
-#if defined(HPX_HAVE_STDEXEC)
 template <typename LnPolicy, typename ExPolicy, typename IteratorTag>
 void test_fill_n_sender(LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
 {
@@ -100,7 +99,6 @@ void test_fill_n_sender(LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
     });
     HPX_TEST_EQ(count, c.size());
 }
-#endif
 
 template <typename ExPolicy, typename IteratorTag>
 void test_fill_n_async(ExPolicy p, IteratorTag)
diff --git a/libs/core/algorithms/tests/unit/algorithms/find_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/find_tests.hpp
index 966ef7fb9c00..55ff4fed5d96 100644
--- a/libs/core/algorithms/tests/unit/algorithms/find_tests.hpp
+++ b/libs/core/algorithms/tests/unit/algorithms/find_tests.hpp
@@ -71,7 +71,6 @@ void test_find(ExPolicy&& policy, IteratorTag)
     HPX_TEST(index == iterator(test_index));
 }
 
-#if defined(HPX_HAVE_STDEXEC)
 template <typename Policy, typename ExPolicy, typename IteratorTag>
 void test_find_explicit_sender_direct(Policy l, ExPolicy&& policy, IteratorTag)
 {
@@ -129,7 +128,6 @@ void test_find_explicit_sender(Policy l, ExPolicy&& policy, IteratorTag)
 
     HPX_TEST(hpx::get<0>(*result) == iterator(test_index));
 }
-#endif
 
 template <typename ExPolicy, typename IteratorTag>
 void test_find_async(ExPolicy&& p, IteratorTag)
@@ -155,7 +153,6 @@ void test_find_async(ExPolicy&& p, IteratorTag)
     HPX_TEST(f.get() == iterator(test_index));
 }
 
-#if defined(HPX_HAVE_STDEXEC)
 template <typename Policy, typename ExPolicy, typename IteratorTag>
 void test_find_explicit_sender_direct_async(Policy l, ExPolicy&& p, IteratorTag)
 {
@@ -186,7 +183,6 @@ void test_find_explicit_sender_direct_async(Policy l, ExPolicy&& p, IteratorTag)
 
     HPX_TEST(result == iterator(test_index));
 }
-#endif
 
 ///////////////////////////////////////////////////////////////////////////////
 template <typename IteratorTag>
diff --git a/libs/core/algorithms/tests/unit/algorithms/findend_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/findend_tests.hpp
index ce8afac9652d..a03da83235c5 100644
--- a/libs/core/algorithms/tests/unit/algorithms/findend_tests.hpp
+++ b/libs/core/algorithms/tests/unit/algorithms/findend_tests.hpp
@@ -81,7 +81,6 @@ void test_find_end1(ExPolicy&& policy, IteratorTag)
     HPX_TEST(index == test_index);
 }
 
-#if defined(HPX_HAVE_STDEXEC)
 template <typename LnPolicy, typename ExPolicy, typename IteratorTag>
 void test_find_end1_sender(
     LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
@@ -145,7 +144,6 @@ void test_find_end1_sender(
         HPX_TEST(iterator(std::begin(c)) == result);
     }
 }
-#endif
 
 template <typename ExPolicy, typename IteratorTag>
 void test_find_end1_async(ExPolicy&& p, IteratorTag)
@@ -227,7 +225,6 @@ void test_find_end2(ExPolicy&& policy, IteratorTag)
     HPX_TEST(index == test_index);
 }
 
-#if defined(HPX_HAVE_STDEXEC)
 template <typename LnPolicy, typename ExPolicy, typename IteratorTag>
 void test_find_end2_sender(
     LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
@@ -266,7 +263,6 @@ void test_find_end2_sender(
 
     HPX_TEST(index == test_index);
 }
-#endif
 
 template <typename ExPolicy, typename IteratorTag>
 void test_find_end2_async(ExPolicy&& p, IteratorTag)
diff --git a/libs/core/algorithms/tests/unit/algorithms/findfirstof_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/findfirstof_tests.hpp
index 97cff1921a5f..741c8b1f1984 100644
--- a/libs/core/algorithms/tests/unit/algorithms/findfirstof_tests.hpp
+++ b/libs/core/algorithms/tests/unit/algorithms/findfirstof_tests.hpp
@@ -76,7 +76,6 @@ void test_find_first_of(ExPolicy&& policy, IteratorTag)
     HPX_TEST(index == iterator(test_index));
 }
 
-#if defined(HPX_HAVE_STDEXEC)
 template <typename LnPolicy, typename ExPolicy, typename IteratorTag>
 void test_find_first_of_sender(
     LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
@@ -112,7 +111,6 @@ void test_find_first_of_sender(
 
     HPX_TEST(index == iterator(test_index));
 }
-#endif
 
 template <typename ExPolicy, typename IteratorTag>
 void test_find_first_of_async(ExPolicy&& p, IteratorTag)
diff --git a/libs/core/algorithms/tests/unit/algorithms/findif_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/findif_tests.hpp
index bea933478008..dd3f9992a082 100644
--- a/libs/core/algorithms/tests/unit/algorithms/findif_tests.hpp
+++ b/libs/core/algorithms/tests/unit/algorithms/findif_tests.hpp
@@ -69,7 +69,6 @@ void test_find_if(ExPolicy&& policy, IteratorTag)
     HPX_TEST(index == iterator(test_index));
 }
 
-#if defined(HPX_HAVE_STDEXEC)
 template <typename LnPolicy, typename ExPolicy, typename IteratorTag>
 void test_find_if_sender(LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
 {
@@ -101,7 +100,6 @@ void test_find_if_sender(LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
 
     HPX_TEST(index == iterator(test_index));
 }
-#endif
 
 template <typename ExPolicy, typename IteratorTag>
 void test_find_if_async(ExPolicy&& p, IteratorTag)
diff --git a/libs/core/algorithms/tests/unit/algorithms/findifnot_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/findifnot_tests.hpp
index 2607e4cd9bf6..6173c200f363 100644
--- a/libs/core/algorithms/tests/unit/algorithms/findifnot_tests.hpp
+++ b/libs/core/algorithms/tests/unit/algorithms/findifnot_tests.hpp
@@ -68,7 +68,6 @@ void test_find_if_not(ExPolicy&& policy, IteratorTag)
     HPX_TEST(index == iterator(test_index));
 }
 
-#if defined(HPX_HAVE_STDEXEC)
 template <typename LnPolicy, typename ExPolicy, typename IteratorTag>
 void test_find_if_not_sender(
     LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
@@ -101,7 +100,6 @@ void test_find_if_not_sender(
 
     HPX_TEST(index == iterator(test_index));
 }
-#endif
 
 template <typename ExPolicy, typename IteratorTag>
 void test_find_if_not_async(ExPolicy&& p, IteratorTag)
diff --git a/libs/core/algorithms/tests/unit/algorithms/foreach_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/foreach_tests.hpp
index 81427e4ea3e7..09ad3462800b 100644
--- a/libs/core/algorithms/tests/unit/algorithms/foreach_tests.hpp
+++ b/libs/core/algorithms/tests/unit/algorithms/foreach_tests.hpp
@@ -373,7 +373,6 @@ void test_for_each_n(ExPolicy policy, IteratorTag)
     HPX_TEST_EQ(count, c.size());
 }
 
-#if defined(HPX_HAVE_STDEXEC)
 template <typename LnPolicy, typename ExPolicy, typename IteratorTag>
 void test_for_each_n_sender(
     LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
@@ -410,7 +409,6 @@ void test_for_each_n_sender(
     });
     HPX_TEST_EQ(count, c.size());
 }
-#endif
 
 template <typename ExPolicy, typename IteratorTag>
 void test_for_each_n_async(ExPolicy p, IteratorTag)
diff --git a/libs/core/algorithms/tests/unit/algorithms/generate_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/generate_tests.hpp
index 0cb50f8cb23b..5b3378e5c71c 100644
--- a/libs/core/algorithms/tests/unit/algorithms/generate_tests.hpp
+++ b/libs/core/algorithms/tests/unit/algorithms/generate_tests.hpp
@@ -72,7 +72,6 @@ void test_generate(ExPolicy&& policy, IteratorTag)
     HPX_TEST_EQ(count, c.size());
 }
 
-#if defined(HPX_HAVE_STDEXEC)
 template <typename LnPolicy, typename ExPolicy, typename IteratorTag>
 void test_generate_sender(LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
 {
@@ -104,7 +103,6 @@ void test_generate_sender(LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
     });
     HPX_TEST_EQ(count, c.size());
 }
-#endif
 
 template <typename ExPolicy, typename IteratorTag>
 void test_generate_async(ExPolicy&& p, IteratorTag)
diff --git a/libs/core/algorithms/tests/unit/algorithms/generaten_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/generaten_tests.hpp
index 0ac7b9b44a8e..a60d3bed7026 100644
--- a/libs/core/algorithms/tests/unit/algorithms/generaten_tests.hpp
+++ b/libs/core/algorithms/tests/unit/algorithms/generaten_tests.hpp
@@ -68,7 +68,6 @@ void test_generate_n(ExPolicy&& policy, IteratorTag)
     HPX_TEST_EQ(count, c.size());
 }
 
-#if defined(HPX_HAVE_STDEXEC)
 template <typename LnPolicy, typename ExPolicy, typename IteratorTag>
 void test_generate_n_sender(
     LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
@@ -100,7 +99,6 @@ void test_generate_n_sender(
     });
     HPX_TEST_EQ(count, c.size());
 }
-#endif
 
 template <typename ExPolicy, typename IteratorTag>
 void test_generate_n_async(ExPolicy&& p, IteratorTag)
diff --git a/libs/core/algorithms/tests/unit/algorithms/is_heap_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/is_heap_tests.hpp
index 5dba32d5834b..2d0b759f58ad 100644
--- a/libs/core/algorithms/tests/unit/algorithms/is_heap_tests.hpp
+++ b/libs/core/algorithms/tests/unit/algorithms/is_heap_tests.hpp
@@ -143,7 +143,6 @@ void test_is_heap(
     }
 }
 
-#if defined(HPX_HAVE_STDEXEC)
 template <typename LnPolicy, typename ExPolicy, typename IteratorTag>
 void test_is_heap_sender(LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
 {
@@ -272,7 +271,6 @@ void test_is_heap_until_sender(
         HPX_TEST(result.base() == solution);
     }
 }
-#endif
 
 template <typename IteratorTag, typename DataType, typename Pred>
 void test_is_heap_with_pred(
diff --git a/libs/core/algorithms/tests/unit/algorithms/is_sorted_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/is_sorted_tests.hpp
index 98c46a6047ef..f18733eee3b9 100644
--- a/libs/core/algorithms/tests/unit/algorithms/is_sorted_tests.hpp
+++ b/libs/core/algorithms/tests/unit/algorithms/is_sorted_tests.hpp
@@ -423,7 +423,6 @@ void test_sorted_bad_alloc_seq(IteratorTag)
     HPX_TEST(caught_bad_alloc);
 }
 
-#if defined(HPX_HAVE_STDEXEC)
 template <typename LnPolicy, typename ExPolicy, typename IteratorTag>
 void test_is_sorted_sender(
     LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
@@ -476,4 +475,3 @@ void test_is_sorted_sender(
         HPX_TEST(is_ordered);
     }
 }
-#endif
diff --git a/libs/core/algorithms/tests/unit/algorithms/mismatch_binary_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/mismatch_binary_tests.hpp
index 10e5fd4b99a7..c241276c62ce 100644
--- a/libs/core/algorithms/tests/unit/algorithms/mismatch_binary_tests.hpp
+++ b/libs/core/algorithms/tests/unit/algorithms/mismatch_binary_tests.hpp
@@ -483,7 +483,6 @@ void test_mismatch_binary_bad_alloc_async(ExPolicy&& p, IteratorTag)
 
 ////////////////////////////////////////////////////////////////////////////////
 
-#if defined(HPX_HAVE_STDEXEC)
 template <typename LnPolicy, typename ExPolicy, typename IteratorTag>
 void test_mismatch_binary1_sender(
     LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
@@ -607,4 +606,3 @@ void test_mismatch_binary2_sender(
         HPX_TEST(result.second == std::begin(c2));
     }
 }
-#endif
diff --git a/libs/core/algorithms/tests/unit/algorithms/mismatch_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/mismatch_tests.hpp
index d8c342a2b613..54404906f224 100644
--- a/libs/core/algorithms/tests/unit/algorithms/mismatch_tests.hpp
+++ b/libs/core/algorithms/tests/unit/algorithms/mismatch_tests.hpp
@@ -481,7 +481,6 @@ void test_mismatch_bad_alloc_async(ExPolicy&& p, IteratorTag)
 
 ////////////////////////////////////////////////////////////////////////////////
 
-#if defined(HPX_HAVE_STDEXEC)
 template <typename LnPolicy, typename ExPolicy, typename IteratorTag>
 void test_mismatch_sender(LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
 {
@@ -552,4 +551,3 @@ void test_mismatch_sender(LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
         HPX_TEST(result.second == std::begin(c2));
     }
 }
-#endif
diff --git a/libs/core/algorithms/tests/unit/algorithms/none_of_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/none_of_tests.hpp
index 8176df28cf5a..b9d655d84777 100644
--- a/libs/core/algorithms/tests/unit/algorithms/none_of_tests.hpp
+++ b/libs/core/algorithms/tests/unit/algorithms/none_of_tests.hpp
@@ -70,7 +70,6 @@ void test_none_of(ExPolicy&& policy, IteratorTag)
     }
 }
 
-#if defined(HPX_HAVE_STDEXEC)
 template <typename LnPolicy, typename ExPolicy, typename IteratorTag>
 void test_none_of_sender(LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
 {
@@ -104,7 +103,6 @@ void test_none_of_sender(LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
         HPX_TEST_EQ(result, expected);
     }
 }
-#endif
 
 template <typename IteratorTag, typename Proj = hpx::identity>
 void test_none_of_ranges_seq(IteratorTag, Proj proj = Proj())
diff --git a/libs/core/algorithms/tests/unit/algorithms/reduce_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/reduce_tests.hpp
index d1c7c3b60bb1..046ba0539446 100644
--- a/libs/core/algorithms/tests/unit/algorithms/reduce_tests.hpp
+++ b/libs/core/algorithms/tests/unit/algorithms/reduce_tests.hpp
@@ -345,7 +345,6 @@ void test_reduce_bad_alloc_async(ExPolicy p, IteratorTag)
 
 ////////////////////////////////////////////////////////////////////////////////
 
-#if defined(HPX_HAVE_STDEXEC)
 template <typename LnPolicy, typename ExPolicy, typename IteratorTag>
 void test_reduce_sender(LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
 {
@@ -387,4 +386,3 @@ void test_reduce_sender(LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
         HPX_TEST_EQ(result, val);
     }
 }
-#endif
diff --git a/libs/core/algorithms/tests/unit/algorithms/remove_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/remove_tests.hpp
index a4d8e9dcb2a5..8a412ea6c709 100644
--- a/libs/core/algorithms/tests/unit/algorithms/remove_tests.hpp
+++ b/libs/core/algorithms/tests/unit/algorithms/remove_tests.hpp
@@ -694,7 +694,6 @@ void test_remove_bad_alloc(bool test_for_remove_if = false)
 
 ////////////////////////////////////////////////////////////////////////////////
 
-#if defined(HPX_HAVE_STDEXEC)
 template <typename LnPolicy, typename ExPolicy, typename IteratorTag>
 void test_remove_sender(LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
 {
@@ -768,4 +767,3 @@ void test_remove_if_sender(
 
     HPX_TEST(equality);
 }
-#endif
diff --git a/libs/core/algorithms/tests/unit/algorithms/transform_binary2_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/transform_binary2_tests.hpp
index 56ab761f3e52..1c42f700d757 100644
--- a/libs/core/algorithms/tests/unit/algorithms/transform_binary2_tests.hpp
+++ b/libs/core/algorithms/tests/unit/algorithms/transform_binary2_tests.hpp
@@ -352,7 +352,6 @@ void test_transform_binary2_bad_alloc_async(ExPolicy p, IteratorTag)
 
 ////////////////////////////////////////////////////////////////////////////////
 
-#if defined(HPX_HAVE_STDEXEC)
 template <typename LnPolicy, typename ExPolicy, typename IteratorTag>
 void test_transform_binary2_sender(
     LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
@@ -401,4 +400,3 @@ void test_transform_binary2_sender(
         }));
     HPX_TEST_EQ(count, d2.size());
 }
-#endif
diff --git a/libs/core/algorithms/tests/unit/algorithms/transform_binary_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/transform_binary_tests.hpp
index 6911ace4a7ee..2b683566b650 100644
--- a/libs/core/algorithms/tests/unit/algorithms/transform_binary_tests.hpp
+++ b/libs/core/algorithms/tests/unit/algorithms/transform_binary_tests.hpp
@@ -341,7 +341,6 @@ void test_transform_binary_bad_alloc_async(ExPolicy p, IteratorTag)
 
 ////////////////////////////////////////////////////////////////////////////////
 
-#if defined(HPX_HAVE_STDEXEC)
 template <typename LnPolicy, typename ExPolicy, typename IteratorTag>
 void test_transform_binary_sender(
     LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
@@ -388,4 +387,3 @@ void test_transform_binary_sender(
         }));
     HPX_TEST_EQ(count, d2.size());
 }
-#endif
diff --git a/libs/core/algorithms/tests/unit/algorithms/transform_reduce_binary_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/transform_reduce_binary_tests.hpp
index 78dbcf757a5c..71d37903c9b1 100644
--- a/libs/core/algorithms/tests/unit/algorithms/transform_reduce_binary_tests.hpp
+++ b/libs/core/algorithms/tests/unit/algorithms/transform_reduce_binary_tests.hpp
@@ -86,7 +86,6 @@ void test_transform_reduce_binary_async(ExPolicy&& p, IteratorTag)
 
 ////////////////////////////////////////////////////////////////////////////////
 
-#if defined(HPX_HAVE_STDEXEC)
 template <typename LnPolicy, typename ExPolicy, typename IteratorTag>
 void test_transform_reduce_binary_sender(
     LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
@@ -134,4 +133,3 @@ void test_transform_reduce_binary_sender(
                 std::begin(c), std::begin(c), std::begin(d), init));
     }
 }
-#endif
diff --git a/libs/core/algorithms/tests/unit/algorithms/transform_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/transform_tests.hpp
index d78c061dbadb..3c6e5fc62759 100644
--- a/libs/core/algorithms/tests/unit/algorithms/transform_tests.hpp
+++ b/libs/core/algorithms/tests/unit/algorithms/transform_tests.hpp
@@ -304,7 +304,6 @@ void test_transform_bad_alloc_async(ExPolicy p, IteratorTag)
 
 ////////////////////////////////////////////////////////////////////////////////
 
-#if defined(HPX_HAVE_STDEXEC)
 template <typename LnPolicy, typename ExPolicy, typename IteratorTag>
 void test_transform_sender(
     LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
@@ -343,4 +342,3 @@ void test_transform_sender(
         }));
     HPX_TEST_EQ(count, d.size());
 }
-#endif
diff --git a/libs/core/algorithms/tests/unit/algorithms/unique_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/unique_tests.hpp
index b8639a196093..ec40cfb342e8 100644
--- a/libs/core/algorithms/tests/unit/algorithms/unique_tests.hpp
+++ b/libs/core/algorithms/tests/unit/algorithms/unique_tests.hpp
@@ -506,7 +506,6 @@ void test_unique_bad_alloc()
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-#if defined(HPX_HAVE_STDEXEC)
 template <typename LnPolicy, typename ExPolicy, typename IteratorTag>
 void test_unique_sender(LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
 {
@@ -577,4 +576,3 @@ void test_unique_sender(LnPolicy ln_policy, ExPolicy&& ex_policy, IteratorTag)
         HPX_TEST(equality);
     }
 }
-#endif
diff --git a/libs/core/algorithms/tests/unit/container_algorithms/adjacentdifference_range_sender.cpp b/libs/core/algorithms/tests/unit/container_algorithms/adjacentdifference_range_sender.cpp
index efddda7943f1..fdd7aa066737 100644
--- a/libs/core/algorithms/tests/unit/container_algorithms/adjacentdifference_range_sender.cpp
+++ b/libs/core/algorithms/tests/unit/container_algorithms/adjacentdifference_range_sender.cpp
@@ -87,14 +87,8 @@ void test_adjacent_difference_async_direct(Policy l, ExPolicy&& p)
     using scheduler_t = ex::thread_pool_policy_scheduler<Policy>;
 
     auto exec = ex::explicit_scheduler_executor(scheduler_t(l));
-#if defined(HPX_HAVE_STDEXEC)
     auto result = tt::sync_wait(
         hpx::ranges::adjacent_difference(p.on(exec), c, std::begin(d)));
-#else
-    auto result =
-        hpx::ranges::adjacent_difference(p.on(exec), c, std::begin(d)) |
-        tt::sync_wait();
-#endif
 
     std::adjacent_difference(std::begin(c), std::end(c), std::begin(d_ans));
 
diff --git a/libs/core/async_cuda/include/hpx/async_cuda/transform_stream.hpp b/libs/core/async_cuda/include/hpx/async_cuda/transform_stream.hpp
index 4bf839756ecb..e8660e105e04 100644
--- a/libs/core/async_cuda/include/hpx/async_cuda/transform_stream.hpp
+++ b/libs/core/async_cuda/include/hpx/async_cuda/transform_stream.hpp
@@ -132,9 +132,7 @@ namespace hpx { namespace cuda { namespace experimental {
         template <typename R, typename F>
         struct transform_stream_receiver
         {
-#if defined(HPX_HAVE_STDEXEC)
             using receiver_concept = hpx::execution::experimental::receiver_t;
-#endif
             std::decay_t<R> r;
             std::decay_t<F> f;
             cudaStream_t stream;
@@ -255,7 +253,6 @@ namespace hpx { namespace cuda { namespace experimental {
                     });
             }
 
-#if defined(HPX_HAVE_STDEXEC)
             template <typename... Ts>
             friend void tag_invoke(hpx::execution::experimental::set_value_t,
                 transform_stream_receiver&& r, Ts&&... ts) noexcept
@@ -266,22 +263,8 @@ namespace hpx { namespace cuda { namespace experimental {
                 // error.
                 r.set_value(HPX_FORWARD(Ts, ts)...);
             }
-#endif
         };
 
-#if !defined(HPX_HAVE_STDEXEC)
-        // This should be a hidden friend in transform_stream_receiver. However,
-        // nvcc does not know how to compile it with some argument types
-        // ("error: no instance of overloaded function std::forward matches the
-        // argument list").
-        template <typename R, typename F, typename... Ts>
-        void tag_invoke(hpx::execution::experimental::set_value_t,
-            transform_stream_receiver<R, F>&& r, Ts&&... ts)
-        {
-            r.set_value(HPX_FORWARD(Ts, ts)...);
-        }
-#endif
-
         template <typename S, typename F>
         struct transform_stream_sender
         {
@@ -289,7 +272,6 @@ namespace hpx { namespace cuda { namespace experimental {
             std::decay_t<F> f;
             cudaStream_t stream{};
 
-#if defined(HPX_HAVE_STDEXEC)
             using sender_concept = hpx::execution::experimental::sender_t;
 
             template <typename... Args>
@@ -345,52 +327,6 @@ namespace hpx { namespace cuda { namespace experimental {
             {
                 return hpx::execution::experimental::get_env(s.s);
             }
-#else
-            template <typename Tuple>
-            struct invoke_result_helper;
-
-            template <template <typename...> class Tuple, typename... Ts>
-            struct invoke_result_helper<Tuple<Ts...>>
-            {
-                static_assert(hpx::is_invocable_v<F, Ts..., cudaStream_t>,
-                    "F not invocable with the value_types specified.");
-
-                using result_type =
-                    hpx::util::invoke_result_t<F, Ts..., cudaStream_t>;
-
-                using type = std::conditional_t<std::is_void_v<result_type>,
-                    Tuple<>, Tuple<result_type>>;
-            };
-
-            template <typename Env>
-            struct generate_completion_signatures
-            {
-                template <template <typename...> class Tuple,
-                    template <typename...> class Variant>
-                using value_types =
-                    hpx::util::detail::unique_t<hpx::util::detail::transform_t<
-                        hpx::execution::experimental::value_types_of_t<S, Env,
-                            Tuple, Variant>,
-                        invoke_result_helper>>;
-
-                template <template <typename...> class Variant>
-                using error_types =
-                    hpx::util::detail::unique_t<hpx::util::detail::prepend_t<
-                        hpx::execution::experimental::error_types_of_t<S, Env,
-                            Variant>,
-                        std::exception_ptr>>;
-
-                static constexpr bool sends_stopped = false;
-            };
-
-            // clang-format off
-            template <typename Env>
-            friend auto tag_invoke(
-                hpx::execution::experimental::get_completion_signatures_t,
-                transform_stream_sender const&, Env) noexcept
-                -> generate_completion_signatures<Env>;
-            // clang-format on
-#endif
 
             template <typename R>
             friend auto tag_invoke(hpx::execution::experimental::connect_t,
diff --git a/libs/core/async_mpi/include/hpx/async_mpi/transform_mpi.hpp b/libs/core/async_mpi/include/hpx/async_mpi/transform_mpi.hpp
index 092cdba73e13..2ee644ff1f46 100644
--- a/libs/core/async_mpi/include/hpx/async_mpi/transform_mpi.hpp
+++ b/libs/core/async_mpi/include/hpx/async_mpi/transform_mpi.hpp
@@ -76,9 +76,7 @@ namespace hpx { namespace mpi { namespace experimental {
         template <typename R, typename F>
         struct transform_mpi_receiver
         {
-#if defined(HPX_HAVE_STDEXEC)
             using is_receiver = void;
-#endif
             HPX_NO_UNIQUE_ADDRESS std::decay_t<R> r;
             HPX_NO_UNIQUE_ADDRESS std::decay_t<F> f;
 
@@ -149,7 +147,6 @@ namespace hpx { namespace mpi { namespace experimental {
             HPX_NO_UNIQUE_ADDRESS std::decay_t<Sender> s;
             HPX_NO_UNIQUE_ADDRESS std::decay_t<F> f;
 
-#if defined(HPX_HAVE_STDEXEC)
             using is_sender = void;
 
             template <typename... Args>
@@ -207,51 +204,6 @@ namespace hpx { namespace mpi { namespace experimental {
                 no_set_stopped_signature
             >;
             // clang-format on
-#else
-            template <typename Env>
-            struct generate_completion_signatures
-            {
-                template <typename Tuple>
-                struct invoke_result_helper;
-
-                template <template <typename...> class Tuple, typename... Ts>
-                struct invoke_result_helper<Tuple<Ts...>>
-                {
-                    static_assert(hpx::is_invocable_v<F, Ts..., MPI_Request*>,
-                        "F not invocable with the value_types specified.");
-                    using result_type =
-                        hpx::util::invoke_result_t<F, Ts..., MPI_Request*>;
-                    using type =
-                        std::conditional_t<std::is_void<result_type>::value,
-                            Tuple<>, Tuple<result_type>>;
-                };
-
-                template <template <typename...> class Tuple,
-                    template <typename...> class Variant>
-                using value_types =
-                    hpx::util::detail::unique_t<hpx::util::detail::transform_t<
-                        hpx::execution::experimental::value_types_of_t<Sender,
-                            Env, Tuple, Variant>,
-                        invoke_result_helper>>;
-
-                template <template <typename...> class Variant>
-                using error_types =
-                    hpx::util::detail::unique_t<hpx::util::detail::prepend_t<
-                        hpx::execution::experimental::error_types_of_t<Sender,
-                            Env, Variant>,
-                        std::exception_ptr>>;
-
-                static constexpr bool sends_stopped = false;
-            };
-
-            // clang-format off
-            template <typename Env>
-            friend auto tag_invoke(
-                hpx::execution::experimental::get_completion_signatures_t,
-                transform_mpi_sender const&, Env)
-            -> generate_completion_signatures<Env>;
-            // clang-format on
-#endif
 
             template <typename R>
             friend constexpr auto tag_invoke(
diff --git a/libs/core/async_mpi/tests/unit/algorithm_transform_mpi.cpp b/libs/core/async_mpi/tests/unit/algorithm_transform_mpi.cpp
index b7564c186cee..2489af98a683 100644
--- a/libs/core/async_mpi/tests/unit/algorithm_transform_mpi.cpp
+++ b/libs/core/async_mpi/tests/unit/algorithm_transform_mpi.cpp
@@ -250,17 +250,4 @@ int hpx_main()
     return hpx::local::finalize();
 }
 
-int main([[maybe_unused]] int argc, [[maybe_unused]] char* argv[])
-{
-#if !defined(HPX_HAVE_STDEXEC)
-    // Disable MPI tests because they
-    // hang due to sync_wait consuming the thread
-    MPI_Init(&argc, &argv);
-
-    auto result = hpx::local::init(hpx_main, argc, argv);
-
-    MPI_Finalize();
-
-    return result || hpx::util::report_errors();
-#endif
-}
+int main([[maybe_unused]] int argc, [[maybe_unused]] char* argv[]) {}
diff --git a/libs/core/async_mpi/tests/unit/mpi_ring_async_executor.cpp b/libs/core/async_mpi/tests/unit/mpi_ring_async_executor.cpp
index 8c6e3a227145..5e6639542ce5 100644
--- a/libs/core/async_mpi/tests/unit/mpi_ring_async_executor.cpp
+++ b/libs/core/async_mpi/tests/unit/mpi_ring_async_executor.cpp
@@ -170,44 +170,4 @@ int hpx_main(hpx::program_options::variables_map& vm)
 // the normal int main function that is called at startup and runs on an OS
 // thread the user must call hpx::local::init to start the hpx runtime which
 // will execute hpx_main on an hpx thread
-int main([[maybe_unused]] int argc, [[maybe_unused]] char* argv[])
-{
-#if !defined(HPX_HAVE_STDEXEC)
-    // if this test is run with distributed runtime, we need to make sure
-    // that all ranks run their main function
-    std::vector<std::string> cfg = {"hpx.run_hpx_main!=1"};
-
-    // Init MPI
-    int provided = MPI_THREAD_MULTIPLE;
-    MPI_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &provided);
-    if (provided != MPI_THREAD_MULTIPLE)
-    {
-        std::cout << "Provided MPI is not : MPI_THREAD_MULTIPLE " << provided
-                  << std::endl;
-    }
-
-    // Configure application-specific options.
-    options_description cmdline("usage: " HPX_APPLICATION_STRING " [options]");
-
-    // clang-format off
-    cmdline.add_options()(
-        "iterations",
-        value<std::uint64_t>()->default_value(5000),
-        "number of iterations to test")
-
-        ("output", "display messages during test");
-    // clang-format on
-
-    // Initialize and run HPX.
-    hpx::local::init_params init_args;
-    init_args.desc_cmdline = cmdline;
-    init_args.cfg = cfg;
-
-    auto result = hpx::local::init(hpx_main, argc, argv, init_args);
-
-    // Finalize MPI
-    MPI_Finalize();
-
-    return result || hpx::util::report_errors();
-#endif
-}
+int main([[maybe_unused]] int argc, [[maybe_unused]] char* argv[]) {}
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 034951899a2e..b31e153a5489 100644
--- a/libs/core/execution/include/hpx/execution/algorithms/as_sender.hpp
+++ b/libs/core/execution/include/hpx/execution/algorithms/as_sender.hpp
@@ -133,7 +133,6 @@ namespace hpx::execution::experimental {
 
             std::decay_t<Future> future_;
 
-#if defined(HPX_HAVE_STDEXEC)
             template <bool IsVoid, typename _result_type>
             struct set_value_void_checked
             {
@@ -150,33 +149,6 @@ namespace hpx::execution::experimental {
                 typename set_value_void_checked<std::is_void_v<result_type>,
                     result_type>::type,
                 hpxexec::set_error_t(std::exception_ptr)>;
-#else
-            // Sender compatibility
-            template <typename, typename T>
-            struct completion_signatures_base
-            {
-                template <template <typename...> typename Tuple,
-                    template <typename...> typename Variant>
-                using value_types = Variant<Tuple<result_type>>;
-            };
-
-            template <typename T>
-            struct completion_signatures_base<T, void>
-            {
-                template <template <typename...> typename Tuple,
-                    template <typename...> typename Variant>
-                using value_types = Variant<Tuple<>>;
-            };
-
-            struct completion_signatures
-              : completion_signatures_base<void, result_type>
-            {
-                template <template <typename...> typename Variant>
-                using error_types = Variant<std::exception_ptr>;
-
-                static constexpr bool sends_stopped = false;
-            };
-#endif
         };
 
         template <typename Future>
diff --git a/libs/core/execution/include/hpx/execution/algorithms/bulk.hpp b/libs/core/execution/include/hpx/execution/algorithms/bulk.hpp
index 51e8a8114d6f..aafc5725a2b7 100644
--- a/libs/core/execution/include/hpx/execution/algorithms/bulk.hpp
+++ b/libs/core/execution/include/hpx/execution/algorithms/bulk.hpp
@@ -9,9 +9,7 @@
 
 #include <hpx/config.hpp>
 
-#if defined(HPX_HAVE_STDEXEC)
 #include <hpx/execution_base/stdexec_forward.hpp>
-#endif
 
 #include <hpx/concepts/concepts.hpp>
 #include <hpx/datastructures/tuple.hpp>
@@ -46,7 +44,6 @@ namespace hpx::execution::experimental {
             HPX_NO_UNIQUE_ADDRESS std::decay_t<Shape> shape;
             HPX_NO_UNIQUE_ADDRESS std::decay_t<F> f;
 
-#if defined(HPX_HAVE_STDEXEC)
             using sender_concept = hpxexec::sender_t;
 
             template <typename... Args>
@@ -75,53 +72,10 @@ namespace hpx::execution::experimental {
             {
                 return hpxexec::get_env(s.sender);
             }
-#else
-            using is_sender = void;
-
-            template <typename Env>
-            struct generate_completion_signatures
-            {
-                template <template <typename...> typename Tuple,
-                    template <typename...> typename Variant>
-                using value_types =
-                    value_types_of_t<Sender, Env, Tuple, Variant>;
-
-                template <template <typename...> typename Variant>
-                using error_types = hpx::util::detail::unique_concat_t<
-                    error_types_of_t<Sender, Env, Variant>,
-                    Variant<std::exception_ptr>>;
-
-                static constexpr bool sends_stopped = false;
-            };
-
-            // clang-format off
-            template <typename Env>
-            friend auto tag_invoke(
-                get_completion_signatures_t, bulk_sender const&, Env) noexcept
-                -> generate_completion_signatures<Env>;
-            // clang-format on
-
-            // clang-format off
-            template <typename CPO,
-                HPX_CONCEPT_REQUIRES_(
-                    hpxexec::detail::is_receiver_cpo_v<CPO> &&
-                    hpxexec::detail::has_completion_scheduler_v<
-                        CPO, std::decay_t<Sender>>
-                )>
-            // clang-format on
-            friend constexpr auto tag_invoke(
-                hpxexec::get_completion_scheduler_t<CPO> tag,
-                bulk_sender const& s)
-            {
-                return tag(s.sender);
-            }
-#endif
             template <typename Receiver>
             struct bulk_receiver
             {
-#if defined(HPX_HAVE_STDEXEC)
                 using receiver_concept = hpxexec::receiver_t;
-#endif
                 HPX_NO_UNIQUE_ADDRESS std::decay_t<Receiver> receiver;
                 HPX_NO_UNIQUE_ADDRESS std::decay_t<Shape> shape;
                 HPX_NO_UNIQUE_ADDRESS std::decay_t<F> f;
@@ -149,11 +103,7 @@ namespace hpx::execution::experimental {
                 }
 
                 template <typename... Ts>
-#if defined(HPX_HAVE_STDEXEC)
                 void set_value(Ts&&... ts) noexcept
-#else
-                void set_value(Ts&&... ts)
-#endif
                 {
                     hpx::detail::try_catch_exception_ptr(
                         [&]() {
@@ -249,13 +199,9 @@ namespace hpx::execution::experimental {
         friend constexpr HPX_FORCEINLINE auto tag_override_invoke(
             bulk_t, Sender&& sender, Shape const& shape, F&& f)
         {
-            auto scheduler = hpxexec::get_completion_scheduler<hpxexec::set_value_t>(
-#if defined(HPX_HAVE_STDEXEC)
-                hpxexec::get_env(sender)
-#else
-                sender
-#endif
-            );
+            auto scheduler =
+                hpxexec::get_completion_scheduler<hpxexec::set_value_t>(
+                    hpxexec::get_env(sender));
 
             return hpx::functional::tag_invoke(bulk_t{}, HPX_MOVE(scheduler),
                 HPX_FORWARD(Sender, sender), shape, HPX_FORWARD(F, f));
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 9800a27e5ba3..b03eb298ffba 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
@@ -63,16 +63,10 @@ namespace hpx::execution::experimental::detail {
         friend constexpr HPX_FORCEINLINE auto operator|(
             U&& u, partial_algorithm_base p)
         {
-#if defined(HPX_HAVE_STDEXEC)
             auto scheduler =
                 hpx::execution::experimental::get_completion_scheduler<
                     hpx::execution::experimental::set_value_t>(
                     hpx::execution::experimental::get_env(u));
-#else
-            auto scheduler =
-                hpx::execution::experimental::get_completion_scheduler<
-                    hpx::execution::experimental::set_value_t>(u);
-#endif
 
             return HPX_MOVE(p).invoke(HPX_MOVE(scheduler), HPX_FORWARD(U, u));
         }
diff --git a/libs/core/execution/include/hpx/execution/algorithms/ensure_started.hpp b/libs/core/execution/include/hpx/execution/algorithms/ensure_started.hpp
index 15aeffe99b40..2770d6a935bc 100644
--- a/libs/core/execution/include/hpx/execution/algorithms/ensure_started.hpp
+++ b/libs/core/execution/include/hpx/execution/algorithms/ensure_started.hpp
@@ -9,156 +9,4 @@
 
 #include <hpx/config.hpp>
 
-#if defined(HPX_HAVE_STDEXEC)
 #include <hpx/execution_base/stdexec_forward.hpp>
-#else
-
-#include <hpx/allocator_support/internal_allocator.hpp>
-#include <hpx/allocator_support/traits/is_allocator.hpp>
-#include <hpx/concepts/concepts.hpp>
-#include <hpx/execution/algorithms/detail/inject_scheduler.hpp>
-#include <hpx/execution/algorithms/detail/partial_algorithm.hpp>
-#include <hpx/execution/algorithms/run_loop.hpp>
-#include <hpx/execution/algorithms/split.hpp>
-#include <hpx/execution_base/completion_scheduler.hpp>
-#include <hpx/execution_base/completion_signatures.hpp>
-#include <hpx/functional/detail/tag_priority_invoke.hpp>
-
-#include <exception>
-#include <memory>
-#include <utility>
-
-namespace hpx::execution::experimental {
-
-    // execution::ensure_started is used to eagerly start the execution of a
-    // sender, while also providing a way to attach further work to execute once
-    // it has completed.
-    //
-    // Once ensure_started returns, it is known that the provided sender has
-    // been connected and start has been called on the resulting operation state
-    // (see 5.2 Operation states represent work); in other words, the work
-    // described by the provided sender has been submitted for execution on the
-    // appropriate execution contexts. Returns a sender which completes when the
-    // provided sender completes and sends values equivalent to those of the
-    // provided sender.
-    //
-    // If the returned sender is destroyed before execution::connect() is
-    // called, or if execution::connect() is called but the returned
-    // operation-state is destroyed before execution::start() is called, then a
-    // stop-request is sent to the eagerly launched operation and the operation
-    // is detached and will run to completion in the background. Its result will
-    // be discarded when it eventually completes.
-    //
-    // Note that the application will need to make sure that resources are kept
-    // alive in the case that the operation detaches. e.g. by holding a
-    // std::shared_ptr to those resources or otherwise having some out-of-band
-    // way to signal completion of the operation so that resource release can be
-    // sequenced after the completion.
-    //
-    inline constexpr struct ensure_started_t final
-      : hpx::functional::detail::tag_priority<ensure_started_t>
-    {
-    private:
-        // clang-format off
-        template <typename Sender,
-            typename Allocator = hpx::util::internal_allocator<>,
-            HPX_CONCEPT_REQUIRES_(
-                is_sender_v<Sender> &&
-                hpx::traits::is_allocator_v<Allocator> &&
-                experimental::detail::is_completion_scheduler_tag_invocable_v<
-                    hpx::execution::experimental::set_value_t,
-                    Sender, ensure_started_t, Allocator
-                >
-            )>
-        // clang-format on
-        friend constexpr HPX_FORCEINLINE auto tag_override_invoke(
-            ensure_started_t, Sender&& sender, Allocator const& allocator = {})
-        {
-            auto scheduler =
-                hpx::execution::experimental::get_completion_scheduler<
-                    hpx::execution::experimental::set_value_t>(sender);
-
-            return hpx::functional::tag_invoke(ensure_started_t{},
-                HPX_MOVE(scheduler), HPX_FORWARD(Sender, sender), allocator);
-        }
-
-        // clang-format off
-        template <typename Sender,
-            typename Allocator = hpx::util::internal_allocator<>,
-            HPX_CONCEPT_REQUIRES_(
-                hpx::execution::experimental::is_sender_v<Sender> &&
-                hpx::traits::is_allocator_v<Allocator>
-            )>
-        // clang-format on
-        friend constexpr HPX_FORCEINLINE auto tag_invoke(ensure_started_t,
-            hpx::execution::experimental::run_loop_scheduler const& sched,
-            Sender&& sender, Allocator const& allocator = {})
-        {
-            auto split_sender = detail::split_sender<Sender, Allocator,
-                detail::submission_type::eager,
-                hpx::execution::experimental::run_loop_scheduler>{
-                HPX_FORWARD(Sender, sender), allocator, sched};
-
-            sched.get_run_loop().run();
-            return split_sender;
-        }
-
-        // clang-format off
-        template <typename Sender,
-            typename Allocator = hpx::util::internal_allocator<>,
-            HPX_CONCEPT_REQUIRES_(
-                is_sender_v<Sender> &&
-                hpx::traits::is_allocator_v<Allocator>
-            )>
-        // clang-format on
-        friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(
-            ensure_started_t, Sender&& sender, Allocator const& allocator = {})
-        {
-            return detail::split_sender<Sender, Allocator,
-                detail::submission_type::eager>{
-                HPX_FORWARD(Sender, sender), allocator};
-        }
-
-        template <typename Sender, typename Allocator>
-        friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(
-            ensure_started_t,
-            detail::split_sender<Sender, Allocator,
-                detail::submission_type::eager>
-                sender,
-            Allocator const& = {})
-        {
-            return sender;
-        }
-
-        // clang-format off
-        template <typename Scheduler, typename Allocator,
-            HPX_CONCEPT_REQUIRES_(
-                hpx::execution::experimental::is_scheduler_v<Scheduler> &&
-                hpx::traits::is_allocator_v<Allocator>
-            )>
-        // clang-format on
-        friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(
-            ensure_started_t, Scheduler&& scheduler,
-            Allocator const& allocator = {})
-        {
-            return hpx::execution::experimental::detail::inject_scheduler<
-                ensure_started_t, Scheduler, Allocator>{
-                HPX_FORWARD(Scheduler, scheduler), allocator};
-        }
-
-        // clang-format off
-        template <typename Allocator = hpx::util::internal_allocator<>,
-            HPX_CONCEPT_REQUIRES_(
-                hpx::traits::is_allocator_v<Allocator>
-            )>
-        // clang-format on
-        friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(
-            ensure_started_t, Allocator const& allocator = {})
-        {
-            return detail::partial_algorithm<ensure_started_t, Allocator>{
-                allocator};
-        }
-    } ensure_started{};
-}    // namespace hpx::execution::experimental
-
-#endif
diff --git a/libs/core/execution/include/hpx/execution/algorithms/execute.hpp b/libs/core/execution/include/hpx/execution/algorithms/execute.hpp
index 94720daf2599..2770d6a935bc 100644
--- a/libs/core/execution/include/hpx/execution/algorithms/execute.hpp
+++ b/libs/core/execution/include/hpx/execution/algorithms/execute.hpp
@@ -9,46 +9,4 @@
 
 #include <hpx/config.hpp>
 
-#if defined(HPX_HAVE_STDEXEC)
 #include <hpx/execution_base/stdexec_forward.hpp>
-#else
-
-#include <hpx/execution/algorithms/start_detached.hpp>
-#include <hpx/execution/algorithms/then.hpp>
-#include <hpx/execution_base/sender.hpp>
-#include <hpx/functional/detail/tag_fallback_invoke.hpp>
-
-#include <utility>
-
-namespace hpx::execution::experimental {
-
-    // execution::execute is used to create fire-and-forget tasks on a specified
-    // scheduler.
-    //
-    // This is a convenience function for fire-and-forget eager one-way
-    // submission of an invocable to a scheduler, to fulfil the role of one-way
-    // executors from P0443.
-    //
-    // Submits the provided function for execution on the provided scheduler,
-    // as-if by:
-    //
-    //      auto snd = execution::schedule(sched);
-    //      auto work = execution::then(snd, fn);
-    //      execution::start_detached(work);
-    //
-    inline constexpr struct execute_t final
-      : hpx::functional::detail::tag_fallback<execute_t>
-    {
-    private:
-        template <typename Scheduler, typename F>
-        friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(
-            execute_t, Scheduler&& scheduler, F&& f)
-        {
-            return start_detached(
-                then(schedule(HPX_FORWARD(Scheduler, scheduler)),
-                    HPX_FORWARD(F, f)));
-        }
-    } execute{};
-}    // namespace hpx::execution::experimental
-
-#endif
diff --git a/libs/core/execution/include/hpx/execution/algorithms/just.hpp b/libs/core/execution/include/hpx/execution/algorithms/just.hpp
index d2523c3846f9..4b842130a399 100644
--- a/libs/core/execution/include/hpx/execution/algorithms/just.hpp
+++ b/libs/core/execution/include/hpx/execution/algorithms/just.hpp
@@ -9,198 +9,4 @@
 
 #include <hpx/config.hpp>
 
-#if defined(HPX_HAVE_STDEXEC)
 #include <hpx/execution_base/stdexec_forward.hpp>
-#else
-
-#include <hpx/datastructures/member_pack.hpp>
-#include <hpx/errors/try_catch_exception_ptr.hpp>
-#include <hpx/execution_base/completion_signatures.hpp>
-#include <hpx/execution_base/receiver.hpp>
-#include <hpx/execution_base/sender.hpp>
-#include <hpx/type_support/pack.hpp>
-
-#include <cstddef>
-#include <exception>
-#include <stdexcept>
-#include <type_traits>
-#include <utility>
-
-namespace hpx::execution::experimental {
-
-    namespace detail {
-
-        template <typename CPO, typename Is, typename... Ts>
-        struct just_sender;
-
-        template <typename CPO, std::size_t... Is, typename... Ts>
-        struct just_sender<CPO, hpx::util::index_pack<Is...>, Ts...>
-        {
-            using is_sender = void;
-
-            HPX_NO_UNIQUE_ADDRESS util::member_pack_for<std::decay_t<Ts>...> ts;
-
-            constexpr just_sender() = default;
-
-            template <typename T,
-                typename = std::enable_if_t<
-                    !std::is_same_v<std::decay_t<T>, just_sender>>>
-            explicit constexpr just_sender(T&& t)
-              : ts(std::piecewise_construct, HPX_FORWARD(T, t))
-            {
-            }
-
-            template <typename T0, typename T1, typename... Ts_>
-            explicit constexpr just_sender(T0&& t0, T1&& t1, Ts_&&... ts)
-              : ts(std::piecewise_construct, HPX_FORWARD(T0, t0),
-                    HPX_FORWARD(T1, t1), HPX_FORWARD(Ts_, ts)...)
-            {
-            }
-
-            just_sender(just_sender&&) = default;
-            just_sender(just_sender const&) = default;
-            just_sender& operator=(just_sender&&) = default;
-            just_sender& operator=(just_sender const&) = default;
-
-#if defined(HPX_GCC_VERSION) && HPX_GCC_VERSION >= 110000
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Warray-bounds"
-#endif
-            template <typename Receiver>
-            struct operation_state
-            {
-                using data_type =
-                    hpx::util::member_pack_for<std::decay_t<Ts>...>;
-
-                HPX_NO_UNIQUE_ADDRESS std::decay_t<Receiver> receiver;
-                HPX_NO_UNIQUE_ADDRESS
-                data_type ts;
-
-                template <typename Receiver_>
-                operation_state(Receiver_&& receiver, data_type ts)
-                  : receiver(HPX_FORWARD(Receiver_, receiver))
-                  , ts(HPX_MOVE(ts))
-                {
-                }
-
-                operation_state(operation_state&&) = delete;
-                operation_state& operator=(operation_state&&) = delete;
-                operation_state(operation_state const&) = delete;
-                operation_state& operator=(operation_state const&) = delete;
-
-                friend void tag_invoke(start_t, operation_state& os) noexcept
-                {
-                    hpx::detail::try_catch_exception_ptr(
-                        [&]() {
-                            CPO{}(HPX_MOVE(os.receiver),
-                                HPX_MOVE(os.ts).template get<Is>()...);
-                        },
-                        [&](std::exception_ptr ep) {
-                            hpx::execution::experimental::set_error(
-                                HPX_MOVE(os.receiver), HPX_MOVE(ep));
-                        });
-                }
-            };
-#if defined(HPX_GCC_VERSION) && HPX_GCC_VERSION >= 110000
-#pragma GCC diagnostic pop
-#endif
-
-            template <typename Receiver>
-            friend auto tag_invoke(
-                connect_t, just_sender&& s, Receiver&& receiver)
-#if !defined(HPX_COMPUTE_DEVICE_CODE)
-                noexcept(
-                    util::all_of_v<std::is_nothrow_move_constructible<Ts>...>)
-#endif
-            {
-                return operation_state<Receiver>{
-                    HPX_FORWARD(Receiver, receiver), HPX_MOVE(s.ts)};
-            }
-
-            template <typename Receiver>
-            friend auto tag_invoke(
-                connect_t, just_sender& s, Receiver&& receiver)
-#if !defined(HPX_COMPUTE_DEVICE_CODE)
-                noexcept(
-                    util::all_of_v<std::is_nothrow_copy_constructible<Ts>...>)
-#endif
-            {
-                return operation_state<Receiver>{
-                    HPX_FORWARD(Receiver, receiver), s.ts};
-            }
-        };
-
-        template <typename Pack, typename... Ts, typename Env>
-        auto tag_invoke(get_completion_signatures_t,
-            just_sender<set_value_t, Pack, Ts...> const&, Env) noexcept
-            -> hpx::execution::experimental::completion_signatures<
-                set_value_t(Ts...), set_error_t(std::exception_ptr)>;
-
-        // different versions of clang-format disagree
-        // clang-format off
-        template <typename Pack, typename Error, typename Env>
-        auto tag_invoke(get_completion_signatures_t,
-            just_sender<set_error_t, Pack, Error> const&, Env) noexcept
-            -> hpx::execution::experimental::completion_signatures<
-                set_error_t(std::exception_ptr), set_error_t(Error)>;
-        // clang-format on
-
-        template <typename Pack, typename... Ts, typename Env>
-        auto tag_invoke(get_completion_signatures_t,
-            just_sender<set_stopped_t, Pack, Ts...> const&, Env) noexcept
-            -> hpx::execution::experimental::completion_signatures<
-                set_stopped_t(), set_error_t(std::exception_ptr)>;
-    }    // namespace detail
-
-    // Returns a sender with no completion schedulers, which sends the provided
-    // values. The input values are decay-copied into the returned sender. When
-    // the returned sender is connected to a receiver, the values are moved into
-    // the operation state if the sender is an rvalue; otherwise, they are
-    // copied. Then xvalues referencing the values in the operation state are
-    // passed to the receiver's set_value.
-    inline constexpr struct just_t final
-    {
-        template <typename... Ts>
-        constexpr HPX_FORCEINLINE auto operator()(Ts&&... ts) const
-        {
-            return detail::just_sender<
-                hpx::execution::experimental::set_value_t,
-                hpx::util::make_index_pack_t<sizeof...(Ts)>, Ts...>{
-                HPX_FORWARD(Ts, ts)...};
-        }
-    } just{};
-
-    // Returns a sender with no completion schedulers, which completes with the
-    // specified error. If the provided error is an lvalue reference, a copy is
-    // made inside the returned sender and a non-const lvalue reference to the
-    // copy is sent to the receiver's set_error. If the provided value is an
-    // rvalue reference, it is moved into the returned sender and an rvalue
-    // reference to it is sent to the receiver's set_error.
-    inline constexpr struct just_error_t final
-    {
-        template <typename Error>
-        constexpr HPX_FORCEINLINE auto operator()(Error&& error) const
-        {
-            return detail::just_sender<
-                hpx::execution::experimental::set_error_t,
-                hpx::util::make_index_pack_t<std::size_t(1)>, Error>{
-                HPX_FORWARD(Error, error)};
-        }
-    } just_error{};
-
-    // Returns a sender with no completion schedulers, which completes
-    // immediately by calling the receiver's set_stopped.
-    inline constexpr struct just_stopped_t final
-    {
-        template <typename... Ts>
-        constexpr HPX_FORCEINLINE auto operator()(Ts&&... ts) const
-        {
-            return detail::just_sender<
-                hpx::execution::experimental::set_stopped_t,
-                hpx::util::make_index_pack_t<sizeof...(Ts)>, Ts...>{
-                HPX_FORWARD(Ts, ts)...};
-        }
-    } just_stopped{};
-}    // namespace hpx::execution::experimental
-
-#endif
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 b279bccd229f..897d337bebc7 100644
--- a/libs/core/execution/include/hpx/execution/algorithms/keep_future.hpp
+++ b/libs/core/execution/include/hpx/execution/algorithms/keep_future.hpp
@@ -66,24 +66,10 @@ namespace hpx::execution::experimental {
         struct keep_future_sender_base
         {
             std::decay_t<Future> future;
-#if defined(HPX_HAVE_STDEXEC)
             using completion_signatures =
                 hpxexec::completion_signatures<hpxexec::set_value_t(
                                                    std::decay_t<Future>),
                     hpxexec::set_error_t(std::exception_ptr)>;
-#else
-            struct completion_signatures
-            {
-                template <template <typename...> class Tuple,
-                    template <typename...> class Variant>
-                using value_types = Variant<Tuple<std::decay_t<Future>>>;
-
-                template <template <typename...> class Variant>
-                using error_types = Variant<std::exception_ptr>;
-
-                static constexpr bool sends_stopped = false;
-            };
-#endif
         };
 
         template <typename Future>
diff --git a/libs/core/execution/include/hpx/execution/algorithms/let_error.hpp b/libs/core/execution/include/hpx/execution/algorithms/let_error.hpp
index 818232f3f5a0..2770d6a935bc 100644
--- a/libs/core/execution/include/hpx/execution/algorithms/let_error.hpp
+++ b/libs/core/execution/include/hpx/execution/algorithms/let_error.hpp
@@ -9,472 +9,4 @@
 
 #include <hpx/config.hpp>
 
-#if defined(HPX_HAVE_STDEXEC)
 #include <hpx/execution_base/stdexec_forward.hpp>
-#else
-
-#include <hpx/assert.hpp>
-#include <hpx/concepts/concepts.hpp>
-#include <hpx/datastructures/variant.hpp>
-#include <hpx/errors/try_catch_exception_ptr.hpp>
-#include <hpx/execution/algorithms/detail/inject_scheduler.hpp>
-#include <hpx/execution/algorithms/detail/partial_algorithm.hpp>
-#include <hpx/execution/algorithms/run_loop.hpp>
-#include <hpx/execution_base/completion_scheduler.hpp>
-#include <hpx/execution_base/completion_signatures.hpp>
-#include <hpx/execution_base/get_env.hpp>
-#include <hpx/execution_base/receiver.hpp>
-#include <hpx/execution_base/sender.hpp>
-#include <hpx/functional/detail/tag_priority_invoke.hpp>
-#include <hpx/functional/invoke_fused.hpp>
-#include <hpx/functional/invoke_result.hpp>
-#include <hpx/type_support/detail/with_result_of.hpp>
-#include <hpx/type_support/meta.hpp>
-#include <hpx/type_support/pack.hpp>
-
-#include <exception>
-#include <type_traits>
-#include <utility>
-
-namespace hpx::execution::experimental {
-
-    namespace detail {
-
-        template <typename PredecessorSender, typename F,
-            typename Scheduler = no_scheduler>
-        struct let_error_sender
-        {
-            using is_sender = void;
-            using predecessor_sender_t = std::decay_t<PredecessorSender>;
-
-            HPX_NO_UNIQUE_ADDRESS predecessor_sender_t predecessor_sender;
-            HPX_NO_UNIQUE_ADDRESS std::decay_t<F> f;
-            HPX_NO_UNIQUE_ADDRESS std::decay_t<Scheduler> scheduler;
-
-            template <typename Env = empty_env>
-            struct generate_completion_signatures
-            {
-                template <typename Error,
-                    typename Enable =
-                        typename std::enable_if_t<hpx::is_invocable_v<F,
-                            std::add_lvalue_reference_t<std::decay_t<Error>>>>>
-                struct successor_sender_types_helper
-                {
-                    using type = hpx::util::invoke_result_t<F,
-                        std::add_lvalue_reference_t<std::decay_t<Error>>>;
-
-                    static_assert(is_sender_v<type>,
-                        "let_error expects the invocable sender factory to "
-                        "return a sender");
-                };
-
-                template <typename Error>
-                using successor_sender_types =
-                    meta::type<successor_sender_types_helper<Error>>;
-
-                // Type of the potential values returned from the predecessor
-                // sender
-                template <template <typename...> class Tuple = meta::pack,
-                    template <typename...> class Variant = meta::pack>
-                using predecessor_value_types =
-                    value_types_of_t<predecessor_sender_t, Env, Tuple, Variant>;
-
-                // Type of the potential errors returned from the predecessor
-                // sender
-                template <template <typename...> class Variant = meta::pack>
-                using predecessor_error_types =
-                    error_types_of_t<predecessor_sender_t, Env, Variant>;
-
-                static_assert(
-                    !std::is_same_v<predecessor_error_types<>, meta::pack<>>,
-                    "let_error used with a predecessor that has an empty "
-                    "error_types. Is let_error misplaced?");
-
-                // Type of the potential senders returned from the sender
-                // factory F
-
-                // clang-format off
-                template <template <typename...> typename Variant = meta::pack>
-                using sender_types =
-                    meta::apply<
-                        meta::transform<
-                            meta::func1<successor_sender_types>,
-                            meta::unique<meta::func<Variant>>>,
-                        predecessor_error_types<>>;
-
-                template <template <typename...> typename Tuple,
-                    template <typename...> typename Variant>
-                using value_types =
-                    meta::invoke<
-                        meta::push_back<meta::uncurry<
-                            meta::unique<meta::func<Variant>>>>,
-                        meta::apply<
-                            meta::transform<
-                                meta::bind_back<
-                                    meta::defer<detail::value_types_of>, Env,
-                                    meta::func<Tuple>>>,
-                            sender_types<>>,
-                        predecessor_value_types<Tuple>>;
-
-                template <template <typename...> typename Variant>
-                using error_types =
-                    meta::invoke<
-                        meta::push_back<meta::uncurry<
-                            meta::unique<meta::func<Variant>>>>,
-                        meta::apply<
-                            meta::transform<meta::bind_back<
-                                meta::defer<detail::error_types_of>, Env>>,
-                            sender_types<>>,
-                        predecessor_error_types<>,
-                        meta::pack<std::exception_ptr>>;
-
-                static constexpr bool sends_stopped = meta::value<
-                    meta::apply<
-                        meta::transform<
-                            meta::bind_back1_func<
-                                detail::sends_stopped_of, Env>,
-                            meta::right_fold<
-                                detail::sends_stopped_of<
-                                    predecessor_sender_t, Env>,
-                                meta::func2<meta::or_>>>,
-                        sender_types<>>>;
-                // clang-format on
-            };
-
-            // clang-format off
-            template <typename Env>
-            friend auto tag_invoke(get_completion_signatures_t,
-                let_error_sender const&, Env) noexcept
-                -> generate_completion_signatures<Env>;
-            // clang-format on
-
-            // clang-format off
-            template <typename CPO, typename Scheduler_ = Scheduler,
-                HPX_CONCEPT_REQUIRES_(
-                   !hpx::execution::experimental::is_scheduler_v<Scheduler_> &&
-                    hpx::execution::experimental::detail::is_receiver_cpo_v<CPO> &&
-                    hpx::execution::experimental::detail::has_completion_scheduler_v<
-                        CPO, predecessor_sender_t>
-                )>
-            // clang-format on
-            friend constexpr auto tag_invoke(
-                hpx::execution::experimental::get_completion_scheduler_t<CPO>
-                    tag,
-                let_error_sender const& sender)
-            {
-                return tag(sender.predecessor_sender);
-            }
-
-            // clang-format off
-            template <typename CPO, typename Scheduler_ = Scheduler,
-                HPX_CONCEPT_REQUIRES_(
-                    hpx::execution::experimental::is_scheduler_v<Scheduler_> &&
-                    hpx::execution::experimental::detail::is_receiver_cpo_v<CPO>
-                )>
-            // clang-format on
-            friend constexpr auto tag_invoke(
-                hpx::execution::experimental::get_completion_scheduler_t<CPO>,
-                let_error_sender const& sender)
-            {
-                return sender.scheduler;
-            }
-
-            // TODO: add forwarding_sender_query
-
-            template <typename Receiver>
-            struct operation_state
-            {
-                struct let_error_predecessor_receiver
-                {
-                    HPX_NO_UNIQUE_ADDRESS std::decay_t<Receiver> receiver;
-                    HPX_NO_UNIQUE_ADDRESS std::decay_t<F> f;
-                    operation_state& op_state;
-
-                    template <typename Receiver_, typename F_>
-                    let_error_predecessor_receiver(
-                        Receiver_&& receiver, F_&& f, operation_state& op_state)
-                      : receiver(HPX_FORWARD(Receiver_, receiver))
-                      , f(HPX_FORWARD(F_, f))
-                      , op_state(op_state)
-                    {
-                    }
-
-                    struct start_visitor
-                    {
-                        [[noreturn]] void operator()(hpx::monostate) const
-                        {
-                            HPX_UNREACHABLE;
-                        }
-
-                        template <typename OperationState_,
-                            typename = std::enable_if_t<!std::is_same_v<
-                                std::decay_t<OperationState_>, hpx::monostate>>>
-                        void operator()(OperationState_& op_state) const
-                        {
-                            hpx::execution::experimental::start(op_state);
-                        }
-                    };
-
-                    struct set_error_visitor
-                    {
-                        HPX_NO_UNIQUE_ADDRESS std::decay_t<Receiver> receiver;
-                        HPX_NO_UNIQUE_ADDRESS std::decay_t<F> f;
-                        operation_state& op_state;
-
-                        [[noreturn]] void operator()(hpx::monostate) const
-                        {
-                            HPX_UNREACHABLE;
-                        }
-
-                        template <typename Error,
-                            typename = std::enable_if_t<!std::is_same_v<
-                                std::decay_t<Error>, hpx::monostate>>>
-                        void operator()(Error& error)
-                        {
-                            using operation_state_type =
-                                decltype(hpx::execution::experimental::connect(
-                                    HPX_INVOKE(HPX_MOVE(f), error),
-                                    std::declval<Receiver>()));
-
-#if defined(HPX_HAVE_CXX17_COPY_ELISION)
-                            // with_result_of is used to emplace the operation
-                            // state returned from connect without any
-                            // intermediate copy construction (the operation
-                            // state is not required to be copyable nor movable).
-                            op_state.successor_op_state
-                                .template emplace<operation_state_type>(
-                                    hpx::util::detail::with_result_of([&]() {
-                                        return hpx::execution::experimental::
-                                            connect(
-                                                HPX_INVOKE(HPX_MOVE(f), error),
-                                                HPX_MOVE(receiver));
-                                    }));
-#else
-                            // earlier versions of MSVC don't get copy elision
-                            // quite right, the operation state must be
-                            // constructed explicitly directly in place
-                            op_state.successor_op_state
-                                .template emplace_f<operation_state_type>(
-                                    hpx::execution::experimental::connect,
-                                    HPX_INVOKE(HPX_MOVE(f), error),
-                                    HPX_MOVE(receiver));
-#endif
-                            hpx::visit(
-                                start_visitor{}, op_state.successor_op_state);
-                        }
-                    };
-
-                    template <typename Error>
-                    friend void tag_invoke(set_error_t,
-                        let_error_predecessor_receiver&& r,
-                        Error&& error) noexcept
-                    {
-                        hpx::detail::try_catch_exception_ptr(
-                            [&]() {
-                                // TODO: receiver is moved before the visit, but
-                                // the invoke inside the visit may throw.
-                                r.op_state.predecessor_error
-                                    .template emplace<Error>(
-                                        HPX_FORWARD(Error, error));
-
-                                hpx::visit(
-                                    set_error_visitor{HPX_MOVE(r.receiver),
-                                        HPX_MOVE(r.f), r.op_state},
-                                    r.op_state.predecessor_error);
-                            },
-                            [&](std::exception_ptr ep) {
-                                hpx::execution::experimental::set_error(
-                                    HPX_MOVE(r.receiver), HPX_MOVE(ep));
-                            });
-                    }
-
-                    friend void tag_invoke(set_stopped_t,
-                        let_error_predecessor_receiver&& r) noexcept
-                    {
-                        hpx::execution::experimental::set_stopped(
-                            HPX_MOVE(r.receiver));
-                    };
-
-                    template <typename... Ts,
-                        typename = std::enable_if_t<hpx::is_invocable_v<
-                            hpx::execution::experimental::set_value_t,
-                            Receiver&&, Ts...>>>
-                    friend void tag_invoke(set_value_t,
-                        let_error_predecessor_receiver&& r, Ts&&... ts) noexcept
-                    {
-                        hpx::execution::experimental::set_value(
-                            HPX_MOVE(r.receiver), HPX_FORWARD(Ts, ts)...);
-                    }
-
-                    // Pass through the get_env receiver query
-                    friend auto tag_invoke(
-                        get_env_t, let_error_predecessor_receiver const& r)
-                        -> env_of_t<std::decay_t<Receiver>>
-                    {
-                        return hpx::execution::experimental::get_env(
-                            r.receiver);
-                    }
-                };
-
-                // Type of the operation state returned when connecting the
-                // predecessor sender to the let_error_predecessor_receiver
-                using predecessor_operation_state_type =
-                    std::decay_t<connect_result_t<PredecessorSender&&,
-                        let_error_predecessor_receiver>>;
-
-                // Type of the potential operation states returned when
-                // connecting a sender in successor_sender_types to the receiver
-                // connected to the let_error_sender
-                template <typename Sender>
-                struct successor_operation_state_types_helper
-                {
-                    using type = connect_result_t<Sender, Receiver>;
-                };
-
-                template <template <typename...> class Variant>
-                using successor_operation_state_types =
-                    hpx::util::detail::transform_t<
-                        typename generate_completion_signatures<>::
-                            template sender_types<Variant>,
-                        successor_operation_state_types_helper>;
-
-                // Operation state from connecting predecessor sender to
-                // let_error_predecessor_receiver
-                predecessor_operation_state_type predecessor_operation_state;
-
-                // Potential errors returned from the predecessor sender
-                hpx::util::detail::prepend_t<
-                    typename generate_completion_signatures<>::
-                        template predecessor_error_types<hpx::variant>,
-                    hpx::monostate>
-                    predecessor_error;
-
-                // Potential operation states returned when connecting a sender
-                // in successor_sender_types to the receiver connected to the
-                // let_error_sender
-                hpx::util::detail::prepend_t<
-                    successor_operation_state_types<hpx::variant>,
-                    hpx::monostate>
-                    successor_op_state;
-
-                template <typename PredecessorSender_, typename Receiver_,
-                    typename F_>
-                operation_state(PredecessorSender_&& predecessor_sender,
-                    Receiver_&& receiver, F_&& f)
-                  : predecessor_operation_state{
-                        hpx::execution::experimental::connect(
-                            std::forward<PredecessorSender_>(
-                                predecessor_sender),
-                            let_error_predecessor_receiver(
-                                HPX_FORWARD(Receiver_, receiver),
-                                HPX_FORWARD(F_, f), *this))}
-                {
-                }
-
-                operation_state(operation_state&&) = delete;
-                operation_state& operator=(operation_state&&) = delete;
-                operation_state(operation_state const&) = delete;
-                operation_state& operator=(operation_state const&) = delete;
-
-                friend void tag_invoke(start_t, operation_state& os) noexcept
-                {
-                    hpx::execution::experimental::start(
-                        os.predecessor_operation_state);
-                }
-            };
-
-            template <typename Receiver>
-            friend auto tag_invoke(
-                connect_t, let_error_sender&& s, Receiver&& receiver)
-            {
-                return operation_state<Receiver>(HPX_MOVE(s.predecessor_sender),
-                    HPX_FORWARD(Receiver, receiver), HPX_MOVE(s.f));
-            }
-        };
-    }    // namespace detail
-
-    // let_error and let_stopped are similar to let_value, but where let_value
-    // works with values sent by the input sender, let_error works with errors,
-    // and let_stopped is invoked when the "stopped" signal is sent.
-    inline constexpr struct let_error_t final
-      : hpx::functional::detail::tag_priority<let_error_t>
-    {
-    private:
-        // clang-format off
-        template <typename PredecessorSender, typename F,
-            HPX_CONCEPT_REQUIRES_(
-                is_sender_v<PredecessorSender> &&
-                experimental::detail::is_completion_scheduler_tag_invocable_v<
-                    hpx::execution::experimental::set_value_t,
-                    PredecessorSender, let_error_t, F
-                >
-            )>
-        // clang-format on
-        friend constexpr HPX_FORCEINLINE auto tag_override_invoke(
-            let_error_t, PredecessorSender&& predecessor_sender, F&& f)
-        {
-            auto scheduler =
-                hpx::execution::experimental::get_completion_scheduler<
-                    hpx::execution::experimental::set_value_t>(
-                    predecessor_sender);
-
-            return hpx::functional::tag_invoke(let_error_t{},
-                HPX_MOVE(scheduler),
-                HPX_FORWARD(PredecessorSender, predecessor_sender),
-                HPX_FORWARD(F, f));
-        }
-
-        // clang-format off
-        template <typename PredecessorSender, typename F,
-            HPX_CONCEPT_REQUIRES_(
-                hpx::execution::experimental::is_sender_v<PredecessorSender>
-            )>
-        // clang-format on
-        friend constexpr HPX_FORCEINLINE auto tag_invoke(let_error_t,
-            hpx::execution::experimental::run_loop_scheduler const& sched,
-            PredecessorSender&& predecessor_sender, F&& f)
-        {
-            return detail::let_error_sender<PredecessorSender, F,
-                hpx::execution::experimental::run_loop_scheduler>{
-                HPX_FORWARD(PredecessorSender, predecessor_sender),
-                HPX_FORWARD(F, f), sched};
-        }
-
-        // clang-format off
-        template <typename PredecessorSender, typename F,
-            HPX_CONCEPT_REQUIRES_(
-                is_sender_v<PredecessorSender>
-            )>
-        // clang-format on
-        friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(
-            let_error_t, PredecessorSender&& predecessor_sender, F&& f)
-        {
-            return detail::let_error_sender<PredecessorSender, F>{
-                HPX_FORWARD(PredecessorSender, predecessor_sender),
-                HPX_FORWARD(F, f), detail::no_scheduler{}};
-        }
-
-        // clang-format off
-        template <typename F, typename Scheduler,
-            HPX_CONCEPT_REQUIRES_(
-                hpx::execution::experimental::is_scheduler_v<Scheduler>
-            )>
-        // clang-format on
-        friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(
-            let_error_t, Scheduler&& scheduler, F&& f)
-        {
-            return hpx::execution::experimental::detail::inject_scheduler<
-                let_error_t, Scheduler, F>{
-                HPX_FORWARD(Scheduler, scheduler), HPX_FORWARD(F, f)};
-        }
-
-        template <typename F>
-        friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(
-            let_error_t, F&& f)
-        {
-            return detail::partial_algorithm<let_error_t, F>{HPX_FORWARD(F, f)};
-        }
-    } let_error{};
-}    // namespace hpx::execution::experimental
-
-#endif
diff --git a/libs/core/execution/include/hpx/execution/algorithms/let_stopped.hpp b/libs/core/execution/include/hpx/execution/algorithms/let_stopped.hpp
index 3ba1cd7cbbb2..f22e39c83891 100644
--- a/libs/core/execution/include/hpx/execution/algorithms/let_stopped.hpp
+++ b/libs/core/execution/include/hpx/execution/algorithms/let_stopped.hpp
@@ -8,370 +8,4 @@
 #pragma once
 
 #include <hpx/config.hpp>
-#if defined(HPX_HAVE_STDEXEC)
 #include <hpx/execution_base/stdexec_forward.hpp>
-#else
-
-#include <hpx/assert.hpp>
-#include <hpx/concepts/concepts.hpp>
-#include <hpx/datastructures/optional.hpp>
-#include <hpx/datastructures/tuple.hpp>
-#include <hpx/datastructures/variant.hpp>
-#include <hpx/errors/try_catch_exception_ptr.hpp>
-#include <hpx/execution/algorithms/detail/inject_scheduler.hpp>
-#include <hpx/execution/algorithms/detail/partial_algorithm.hpp>
-#include <hpx/execution/algorithms/run_loop.hpp>
-#include <hpx/execution_base/completion_scheduler.hpp>
-#include <hpx/execution_base/completion_signatures.hpp>
-#include <hpx/execution_base/receiver.hpp>
-#include <hpx/execution_base/sender.hpp>
-#include <hpx/functional/detail/tag_priority_invoke.hpp>
-#include <hpx/functional/invoke_fused.hpp>
-#include <hpx/functional/invoke_result.hpp>
-#include <hpx/type_support/detail/with_result_of.hpp>
-#include <hpx/type_support/meta.hpp>
-#include <hpx/type_support/pack.hpp>
-
-#include <exception>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-
-namespace hpx::execution::experimental {
-
-    namespace detail {
-
-        template <typename PredecessorSender, typename F,
-            typename Scheduler = no_scheduler>
-        struct let_stopped_sender
-        {
-            using is_sender = void;
-            using predecessor_sender_t = std::decay_t<PredecessorSender>;
-
-            HPX_NO_UNIQUE_ADDRESS predecessor_sender_t predecessor_sender;
-            HPX_NO_UNIQUE_ADDRESS std::decay_t<F> f;
-            HPX_NO_UNIQUE_ADDRESS std::decay_t<Scheduler> scheduler;
-
-            template <typename Env = empty_env>
-            struct generate_completion_signatures
-            {
-                struct successor_sender_type_helper
-                {
-                    using type = hpx::util::invoke_result_t<F>;
-
-                    static_assert(is_sender_v<type>,
-                        "let_stopped expects the invocable sender factory to "
-                        "return a sender");
-                };
-
-                using sender_type = meta::type<successor_sender_type_helper>;
-
-                // Type of the potential values returned from the predecessor
-                // sender
-                template <template <typename...> class Tuple = meta::pack,
-                    template <typename...> class Variant = meta::pack>
-                using predecessor_value_types =
-                    value_types_of_t<predecessor_sender_t, Env, Tuple, Variant>;
-
-                template <template <typename...> class Variant = meta::pack>
-                using predecessor_error_types =
-                    error_types_of_t<predecessor_sender_t, Env, Variant>;
-
-                // Type of the potential values returned from the predecessor
-                // sender
-                template <template <typename...> class Tuple = meta::pack,
-                    template <typename...> class Variant = meta::pack>
-                using successor_value_types =
-                    value_types_of_t<sender_type, Env, Tuple, Variant>;
-
-                // Types of the potential senders returned from the sender
-                // factory F
-
-                // clang-format off
-                template <template <typename...> typename Tuple = meta::pack,
-                    template <typename...> typename Variant = meta::pack>
-                using value_types =
-                    meta::apply<
-                        meta::push_back<meta::unique<meta::func<Variant>>>,
-                        meta::pack<
-                            value_types_of_t<sender_type, Env, Tuple, meta::pack>>,
-                        predecessor_value_types<Tuple>>;
-
-                template <template <typename...> typename Variant>
-                using error_types =
-                    meta::apply<
-                        meta::push_back<meta::unique<meta::func<Variant>>>,
-                        meta::pack<
-                            error_types_of_t<sender_type, Env, meta::pack>>,
-                        predecessor_error_types<>,
-                        meta::pack<std::exception_ptr>>;
-
-                static constexpr bool sends_stopped =
-                    sends_stopped_of_v<sender_type, Env>;
-                // clang-format on
-            };
-
-            // clang-format off
-            template <typename Env>
-            friend auto tag_invoke(get_completion_signatures_t,
-                let_stopped_sender const&,
-                Env) noexcept -> generate_completion_signatures<Env>;
-
-            template <typename CPO, typename Scheduler_ = Scheduler,
-                HPX_CONCEPT_REQUIRES_(
-                   !hpx::execution::experimental::is_scheduler_v<Scheduler_> &&
-                    hpx::execution::experimental::detail::is_receiver_cpo_v<CPO> &&
-                    hpx::execution::experimental::detail::has_completion_scheduler_v<
-                        CPO, predecessor_sender_t>
-                )>
-            // clang-format on
-            friend constexpr auto tag_invoke(
-                hpx::execution::experimental::get_completion_scheduler_t<CPO>
-                    tag,
-                let_stopped_sender const& sender)
-            {
-                return tag(sender.predecessor_sender);
-            }
-
-            // clang-format off
-            template <typename CPO, typename Scheduler_ = Scheduler,
-                HPX_CONCEPT_REQUIRES_(
-                    hpx::execution::experimental::is_scheduler_v<Scheduler_> &&
-                    hpx::execution::experimental::detail::is_receiver_cpo_v<CPO>
-                )>
-            // clang-format on
-            friend constexpr auto tag_invoke(
-                hpx::execution::experimental::get_completion_scheduler_t<CPO>,
-                let_stopped_sender const& sender)
-            {
-                return sender.scheduler;
-            }
-
-            // TODO: add forwarding_sender_query
-
-            template <typename Receiver>
-            struct operation_state
-            {
-                struct let_stopped_predecessor_receiver;
-
-                // Type of the operation state returned when connecting the
-                // predecessor sender to the let_stopped_predecessor_receiver
-                using predecessor_operation_state_type =
-                    std::decay_t<connect_result_t<PredecessorSender&&,
-                        let_stopped_predecessor_receiver>>;
-
-                // Operation state from connecting predecessor sender to
-                // let_stopped_predecessor_receiver
-                predecessor_operation_state_type predecessor_op_state;
-
-                struct let_stopped_predecessor_receiver
-                {
-                    HPX_NO_UNIQUE_ADDRESS std::decay_t<Receiver> receiver;
-                    HPX_NO_UNIQUE_ADDRESS std::decay_t<F> f;
-                    operation_state& op_state;
-
-                    template <typename Receiver_, typename F_>
-                    let_stopped_predecessor_receiver(
-                        Receiver_&& receiver, F_&& f, operation_state& op_state)
-                      : receiver(HPX_FORWARD(Receiver_, receiver))
-                      , f(HPX_FORWARD(F_, f))
-                      , op_state(op_state)
-                    {
-                    }
-
-                    template <typename Error>
-                    friend void tag_invoke(set_error_t,
-                        let_stopped_predecessor_receiver&& r,
-                        Error&& error) noexcept
-                    {
-                        hpx::execution::experimental::set_error(
-                            HPX_MOVE(r.receiver), HPX_FORWARD(Error, error));
-                    }
-
-                    friend void tag_invoke(set_stopped_t,
-                        let_stopped_predecessor_receiver&& r) noexcept
-                    {
-                        hpx::detail::try_catch_exception_ptr(
-                            [&]() {
-#if defined(HPX_HAVE_CXX17_COPY_ELISION)
-                                // with_result_of is used to emplace the
-                                // operation state returned from connect without
-                                // any intermediate copy construction (the
-                                // operation state is not required to be
-                                // copyable nor movable).
-                                r.op_state.successor_op_state.emplace(
-                                    hpx::util::detail::with_result_of([&]() {
-                                        return hpx::execution::experimental::
-                                            connect(HPX_INVOKE(HPX_MOVE(r.f), ),
-                                                HPX_MOVE(r.receiver));
-                                    }));
-#else
-                                // earlier versions of MSVC don't get copy
-                                // elision quite right, the operation state must
-                                // be constructed explicitly directly in place
-                                r.op_state.successor_op_state.emplace_f(
-                                    hpx::execution::experimental::connect,
-                                    HPX_INVOKE(HPX_MOVE(r.f), ),
-                                    HPX_MOVE(r.receiver));
-#endif
-                                hpx::execution::experimental::start(
-                                    *r.op_state.successor_op_state);
-                            },
-                            [&](std::exception_ptr ep) {
-                                hpx::execution::experimental::set_error(
-                                    HPX_MOVE(r.receiver), HPX_MOVE(ep));
-                            });
-                    };
-
-                    template <typename... Ts,
-                        typename = std::enable_if_t<hpx::is_invocable_v<
-                            hpx::execution::experimental::set_value_t,
-                            Receiver&&, Ts...>>>
-                    friend void tag_invoke(set_value_t,
-                        let_stopped_predecessor_receiver&& r,
-                        Ts&&... ts) noexcept
-                    {
-                        hpx::execution::experimental::set_value(
-                            HPX_MOVE(r.receiver), HPX_FORWARD(Ts, ts)...);
-                    }
-                };
-
-                // Type of the potential operation state returned when
-                // connecting a successor_sender_type to the receiver connected
-                // to the let_stpped_sender
-                using successor_operation_state_type =
-                    connect_result_t<hpx::util::invoke_result_t<F>, Receiver>;
-
-                // Potential operation states returned when connecting a sender
-                // in successor_sender_types to the receiver connected to the
-                // let_stopped_sender
-                hpx::optional<successor_operation_state_type>
-                    successor_op_state;
-
-                template <typename PredecessorSender_, typename Receiver_,
-                    typename F_>
-                operation_state(PredecessorSender_&& predecessor_sender,
-                    Receiver_&& receiver, F_&& f)
-                  : predecessor_op_state{hpx::execution::experimental::connect(
-                        HPX_FORWARD(PredecessorSender_, predecessor_sender),
-                        let_stopped_predecessor_receiver(
-                            HPX_FORWARD(Receiver_, receiver),
-                            HPX_FORWARD(F_, f), *this))}
-                {
-                }
-
-                operation_state(operation_state&&) = delete;
-                operation_state& operator=(operation_state&&) = delete;
-                operation_state(operation_state const&) = delete;
-                operation_state& operator=(operation_state const&) = delete;
-
-                friend void tag_invoke(start_t, operation_state& os) noexcept
-                {
-                    hpx::execution::experimental::start(
-                        os.predecessor_op_state);
-                }
-            };
-
-            template <typename Receiver>
-            friend auto tag_invoke(
-                connect_t, let_stopped_sender&& s, Receiver&& receiver)
-            {
-                return operation_state<Receiver>(HPX_MOVE(s.predecessor_sender),
-                    HPX_FORWARD(Receiver, receiver), HPX_MOVE(s.f));
-            }
-        };
-    }    // namespace detail
-
-    // let_stopped is very similar to then: when it is started, it invokes the
-    // provided function with the values sent by the input sender as arguments.
-    // However, where the sender returned from then sends exactly what that
-    // function ends up returning - let_stopped requires that the function
-    // return a sender, and the sender returned by let_stopped sends the values
-    // sent by the sender returned from the callback. This is similar to the
-    // notion of "future unwrapping" in future/promise-based frameworks.
-    //
-    // let_stopped is guaranteed to not begin executing function until the
-    // returned sender is started.
-    inline constexpr struct let_stopped_t final
-      : hpx::functional::detail::tag_priority<let_stopped_t>
-    {
-    private:
-        // clang-format off
-        template <typename PredecessorSender, typename F,
-            HPX_CONCEPT_REQUIRES_(
-                is_sender_v<PredecessorSender> &&
-                experimental::detail::is_completion_scheduler_tag_invocable_v<
-                    hpx::execution::experimental::set_value_t,
-                    PredecessorSender, let_stopped_t, F
-                >
-            )>
-        // clang-format on
-        friend constexpr HPX_FORCEINLINE auto tag_override_invoke(
-            let_stopped_t, PredecessorSender&& predecessor_sender, F&& f)
-        {
-            auto scheduler =
-                hpx::execution::experimental::get_completion_scheduler<
-                    hpx::execution::experimental::set_value_t>(
-                    predecessor_sender);
-
-            return hpx::functional::tag_invoke(let_stopped_t{},
-                HPX_MOVE(scheduler),
-                HPX_FORWARD(PredecessorSender, predecessor_sender),
-                HPX_FORWARD(F, f));
-        }
-
-        // clang-format off
-        template <typename PredecessorSender, typename F,
-            HPX_CONCEPT_REQUIRES_(
-                hpx::execution::experimental::is_sender_v<PredecessorSender>
-            )>
-        // clang-format on
-        friend constexpr HPX_FORCEINLINE auto tag_invoke(let_stopped_t,
-            hpx::execution::experimental::run_loop_scheduler const& sched,
-            PredecessorSender&& predecessor_sender, F&& f)
-        {
-            return detail::let_stopped_sender<PredecessorSender, F,
-                hpx::execution::experimental::run_loop_scheduler>{
-                HPX_FORWARD(PredecessorSender, predecessor_sender),
-                HPX_FORWARD(F, f), sched};
-        }
-
-        // clang-format off
-        template <typename PredecessorSender, typename F,
-            HPX_CONCEPT_REQUIRES_(
-                is_sender_v<PredecessorSender>
-            )>
-        // clang-format on
-        friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(
-            let_stopped_t, PredecessorSender&& predecessor_sender, F&& f)
-        {
-            return detail::let_stopped_sender<PredecessorSender, F>{
-                HPX_FORWARD(PredecessorSender, predecessor_sender),
-                HPX_FORWARD(F, f), detail::no_scheduler{}};
-        }
-
-        // clang-format off
-        template <typename F, typename Scheduler,
-            HPX_CONCEPT_REQUIRES_(
-                hpx::execution::experimental::is_scheduler_v<Scheduler>
-            )>
-        // clang-format on
-        friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(
-            let_stopped_t, Scheduler&& scheduler, F&& f)
-        {
-            return hpx::execution::experimental::detail::inject_scheduler<
-                let_stopped_t, Scheduler, F>{
-                HPX_FORWARD(Scheduler, scheduler), HPX_FORWARD(F, f)};
-        }
-
-        template <typename F>
-        friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(
-            let_stopped_t, F&& f)
-        {
-            return detail::partial_algorithm<let_stopped_t, F>{
-                HPX_FORWARD(F, f)};
-        }
-    } let_stopped{};
-}    // namespace hpx::execution::experimental
-
-#endif
diff --git a/libs/core/execution/include/hpx/execution/algorithms/let_value.hpp b/libs/core/execution/include/hpx/execution/algorithms/let_value.hpp
index d1e4d062a326..f22e39c83891 100644
--- a/libs/core/execution/include/hpx/execution/algorithms/let_value.hpp
+++ b/libs/core/execution/include/hpx/execution/algorithms/let_value.hpp
@@ -8,487 +8,4 @@
 #pragma once
 
 #include <hpx/config.hpp>
-#if defined(HPX_HAVE_STDEXEC)
 #include <hpx/execution_base/stdexec_forward.hpp>
-#else
-
-#include <hpx/assert.hpp>
-#include <hpx/concepts/concepts.hpp>
-#include <hpx/datastructures/tuple.hpp>
-#include <hpx/datastructures/variant.hpp>
-#include <hpx/errors/try_catch_exception_ptr.hpp>
-#include <hpx/execution/algorithms/detail/inject_scheduler.hpp>
-#include <hpx/execution/algorithms/detail/partial_algorithm.hpp>
-#include <hpx/execution/algorithms/run_loop.hpp>
-#include <hpx/execution_base/completion_scheduler.hpp>
-#include <hpx/execution_base/completion_signatures.hpp>
-#include <hpx/execution_base/get_env.hpp>
-#include <hpx/execution_base/receiver.hpp>
-#include <hpx/execution_base/sender.hpp>
-#include <hpx/functional/detail/tag_priority_invoke.hpp>
-#include <hpx/functional/invoke_fused.hpp>
-#include <hpx/functional/invoke_result.hpp>
-#include <hpx/type_support/detail/with_result_of.hpp>
-#include <hpx/type_support/meta.hpp>
-#include <hpx/type_support/pack.hpp>
-
-#include <exception>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-
-namespace hpx::execution::experimental {
-
-    namespace detail {
-
-        template <typename PredecessorSender, typename F,
-            typename Scheduler = no_scheduler>
-        struct let_value_sender
-        {
-            using is_sender = void;
-            using predecessor_sender_t = std::decay_t<PredecessorSender>;
-
-            HPX_NO_UNIQUE_ADDRESS predecessor_sender_t predecessor_sender;
-            HPX_NO_UNIQUE_ADDRESS std::decay_t<F> f;
-            HPX_NO_UNIQUE_ADDRESS std::decay_t<Scheduler> scheduler;
-
-            template <typename Env = empty_env>
-            struct generate_completion_signatures
-            {
-                template <typename Pack, typename Enable = void>
-                struct successor_sender_types_helper;
-
-                template <typename... Ts>
-                struct successor_sender_types_helper<meta::pack<Ts...>,
-                    std::enable_if_t<hpx::is_invocable_v<F,
-                        std::add_lvalue_reference_t<std::decay_t<Ts>>...>>>
-                {
-                    using type = hpx::util::invoke_result_t<F,
-                        std::add_lvalue_reference_t<std::decay_t<Ts>>...>;
-
-                    static_assert(is_sender_v<type>,
-                        "let_value expects the invocable sender factory to "
-                        "return a sender");
-                };
-
-                template <typename... Ts>
-                using successor_sender_types = meta::type<
-                    successor_sender_types_helper<meta::pack<Ts...>>>;
-
-                // Type of the potential values returned from the predecessor
-                // sender
-                template <template <typename...> class Tuple = meta::pack,
-                    template <typename...> class Variant = meta::pack>
-                using predecessor_value_types =
-                    value_types_of_t<predecessor_sender_t, Env, Tuple, Variant>;
-
-                // Types of the potential senders returned from the sender
-                // factory F
-
-                // clang-format off
-                template <template <typename...> typename Tuple = meta::pack,
-                    template <typename...> typename Variant = meta::pack>
-                using sender_types =
-                    meta::apply<
-                        meta::transform<meta::uncurry<
-                            meta::func<successor_sender_types>>,
-                            meta::func<Variant>>,
-                        predecessor_value_types<Tuple>>;
-
-                template <template <typename...> typename Tuple,
-                    template <typename...> typename Variant>
-                using value_types =
-                    meta::apply<
-                        meta::transform<
-                            meta::bind_back<
-                                meta::defer<detail::value_types_of>, Env,
-                                meta::func<Tuple>>,
-                            meta::uncurry<meta::unique<meta::func<Variant>>>>,
-                        sender_types<>>;
-
-                template <template <typename...> typename Variant>
-                using error_types =
-                    meta::invoke<
-                        meta::push_back<meta::uncurry<
-                            meta::unique<meta::func<Variant>>>>,
-                        meta::apply<
-                            meta::transform<meta::bind_back<
-                                meta::defer<detail::error_types_of>, Env>>,
-                            sender_types<>>,
-                        meta::pack<std::exception_ptr>>;
-
-                static constexpr bool sends_stopped = meta::value<
-                    meta::apply<
-                        meta::transform<
-                            meta::bind_back1_func<
-                                detail::sends_stopped_of, Env>,
-                            meta::right_fold<
-                                detail::sends_stopped_of<
-                                    predecessor_sender_t, Env>,
-                                meta::func2<meta::or_>>>,
-                        sender_types<>>>;
-                // clang-format on
-            };
-
-            // clang-format off
-            template <typename Env>
-            friend auto tag_invoke(get_completion_signatures_t,
-                let_value_sender const&,
-                Env) noexcept -> generate_completion_signatures<Env>;
-
-            template <typename CPO, typename Scheduler_ = Scheduler,
-                HPX_CONCEPT_REQUIRES_(
-                   !hpx::execution::experimental::is_scheduler_v<Scheduler_> &&
-                    hpx::execution::experimental::detail::is_receiver_cpo_v<CPO> &&
-                    hpx::execution::experimental::detail::has_completion_scheduler_v<
-                        CPO, predecessor_sender_t>
-                )>
-            // clang-format on
-            friend constexpr auto tag_invoke(
-                hpx::execution::experimental::get_completion_scheduler_t<CPO>
-                    tag,
-                let_value_sender const& sender)
-            {
-                return tag(sender.predecessor_sender);
-            }
-
-            // clang-format off
-            template <typename CPO, typename Scheduler_ = Scheduler,
-                HPX_CONCEPT_REQUIRES_(
-                    hpx::execution::experimental::is_scheduler_v<Scheduler_> &&
-                    hpx::execution::experimental::detail::is_receiver_cpo_v<CPO>
-                )>
-            // clang-format on
-            friend constexpr auto tag_invoke(
-                hpx::execution::experimental::get_completion_scheduler_t<CPO>,
-                let_value_sender const& sender)
-            {
-                return sender.scheduler;
-            }
-
-            // TODO: add forwarding_sender_query
-
-            template <typename Receiver>
-            struct operation_state
-            {
-                struct let_value_predecessor_receiver;
-
-                // Type of the operation state returned when connecting the
-                // predecessor sender to the let_value_predecessor_receiver
-                using predecessor_operation_state_type =
-                    std::decay_t<connect_result_t<PredecessorSender&&,
-                        let_value_predecessor_receiver>>;
-
-                // Type of the potential operation states returned when
-                // connecting a sender in successor_sender_types to the receiver
-                // connected to the let_value_sender
-                template <typename Sender>
-                struct successor_operation_state_types_helper
-                {
-                    using type = connect_result_t<Sender, Receiver>;
-                };
-
-                template <template <typename...> class Tuple,
-                    template <typename...> class Variant>
-                using successor_operation_state_types =
-                    hpx::util::detail::transform_t<
-                        typename generate_completion_signatures<>::
-                            template sender_types<Tuple, Variant>,
-                        successor_operation_state_types_helper>;
-
-                // Operation state from connecting predecessor sender to
-                // let_value_predecessor_receiver
-                predecessor_operation_state_type predecessor_op_state;
-
-                using predecessor_ts_type = hpx::util::detail::prepend_t<
-                    typename generate_completion_signatures<>::
-                        template predecessor_value_types<decayed_tuple,
-                            hpx::variant>,
-                    hpx::monostate>;
-
-                // Potential values returned from the predecessor sender
-                predecessor_ts_type predecessor_ts;
-
-                // Potential operation states returned when connecting a sender
-                // in successor_sender_types to the receiver connected to the
-                // let_value_sender
-                hpx::util::detail::prepend_t<
-                    successor_operation_state_types<hpx::tuple, hpx::variant>,
-                    hpx::monostate>
-                    successor_op_state;
-
-                struct let_value_predecessor_receiver
-                {
-                    HPX_NO_UNIQUE_ADDRESS std::decay_t<Receiver> receiver;
-                    HPX_NO_UNIQUE_ADDRESS std::decay_t<F> f;
-                    operation_state& op_state;
-
-                    template <typename Receiver_, typename F_>
-                    let_value_predecessor_receiver(
-                        Receiver_&& receiver, F_&& f, operation_state& op_state)
-                      : receiver(HPX_FORWARD(Receiver_, receiver))
-                      , f(HPX_FORWARD(F_, f))
-                      , op_state(op_state)
-                    {
-                    }
-
-                    template <typename Error>
-                    friend void tag_invoke(set_error_t,
-                        let_value_predecessor_receiver&& r,
-                        Error&& error) noexcept
-                    {
-                        hpx::execution::experimental::set_error(
-                            HPX_MOVE(r.receiver), HPX_FORWARD(Error, error));
-                    }
-
-                    friend void tag_invoke(set_stopped_t,
-                        let_value_predecessor_receiver&& r) noexcept
-                    {
-                        hpx::execution::experimental::set_stopped(
-                            HPX_MOVE(r.receiver));
-                    };
-
-                    struct start_visitor
-                    {
-                        [[noreturn]] void operator()(hpx::monostate) const
-                        {
-                            HPX_UNREACHABLE;
-                        }
-
-                        template <typename OperationState_,
-                            typename = std::enable_if_t<!std::is_same_v<
-                                std::decay_t<OperationState_>, hpx::monostate>>>
-                        void operator()(OperationState_& op_state) const
-                        {
-                            hpx::execution::experimental::start(op_state);
-                        }
-                    };
-
-                    struct set_value_visitor
-                    {
-                        HPX_NO_UNIQUE_ADDRESS std::decay_t<Receiver> receiver;
-                        HPX_NO_UNIQUE_ADDRESS std::decay_t<F> f;
-                        operation_state& op_state;
-
-                        [[noreturn]] void operator()(hpx::monostate) const
-                        {
-                            HPX_UNREACHABLE;
-                        }
-
-                        template <typename T,
-                            typename = std::enable_if_t<!std::is_same_v<
-                                std::decay_t<T>, hpx::monostate>>>
-                        void operator()(T& t)
-                        {
-                            using operation_state_type =
-                                decltype(hpx::execution::experimental::connect(
-                                    hpx::invoke_fused(HPX_MOVE(f), t),
-                                    std::declval<Receiver>()));
-
-#if defined(HPX_HAVE_CXX17_COPY_ELISION)
-                            // with_result_of is used to emplace the operation state
-                            // returned from connect without any intermediate copy
-                            // construction (the operation state is not required to be
-                            // copyable nor movable).
-                            op_state.successor_op_state
-                                .template emplace<operation_state_type>(
-                                    hpx::util::detail::with_result_of([&]() {
-                                        return hpx::execution::experimental::
-                                            connect(hpx::invoke_fused(
-                                                        HPX_MOVE(f), t),
-                                                HPX_MOVE(receiver));
-                                    }));
-#else
-                            // earlier versions of MSVC don't get copy elision
-                            // quite right, the operation state must be
-                            // constructed explicitly directly in place
-                            op_state.successor_op_state
-                                .template emplace_f<operation_state_type>(
-                                    hpx::execution::experimental::connect,
-                                    hpx::invoke_fused(HPX_MOVE(f), t),
-                                    HPX_MOVE(receiver));
-#endif
-                            hpx::visit(
-                                start_visitor{}, op_state.successor_op_state);
-                        }
-                    };
-
-                    // This typedef is duplicated from the parent struct. The
-                    // parent typedef is not instantiated early enough for use
-                    // here.
-                    using predecessor_ts_type = hpx::util::detail::prepend_t<
-                        typename generate_completion_signatures<>::
-                            template predecessor_value_types<decayed_tuple,
-                                hpx::variant>,
-                        hpx::monostate>;
-
-                    template <typename... Ts>
-                    void set_value(Ts&&... ts)
-                    {
-                        hpx::detail::try_catch_exception_ptr(
-                            [&]() {
-                                op_state.predecessor_ts
-                                    .template emplace<hpx::tuple<Ts...>>(
-                                        HPX_FORWARD(Ts, ts)...);
-                                hpx::visit(set_value_visitor{HPX_MOVE(receiver),
-                                               HPX_MOVE(f), op_state},
-                                    op_state.predecessor_ts);
-                            },
-                            [&](std::exception_ptr ep) {
-                                hpx::execution::experimental::set_error(
-                                    HPX_MOVE(receiver), HPX_MOVE(ep));
-                            });
-                    }
-
-                    template <typename... Ts>
-                    friend auto tag_invoke(set_value_t,
-                        let_value_predecessor_receiver&& r, Ts&&... ts) noexcept
-                        -> decltype(std::declval<predecessor_ts_type>()
-                                        .template emplace<
-                                            hpx::tuple<std::decay_t<Ts>...>>(
-                                            HPX_FORWARD(Ts, ts)...),
-                            void())
-                    {
-                        // set_value is in a member function only because of a
-                        // compiler bug in GCC 7. When the body of set_value is
-                        // inlined here compilation fails with an internal
-                        // compiler error.
-                        r.set_value(HPX_FORWARD(Ts, ts)...);
-                    }
-
-                    // Pass through the get_env receiver query
-                    friend auto tag_invoke(
-                        get_env_t, let_value_predecessor_receiver const& r)
-                        -> env_of_t<std::decay_t<Receiver>>
-                    {
-                        return hpx::execution::experimental::get_env(
-                            r.receiver);
-                    }
-                };
-
-                template <typename PredecessorSender_, typename Receiver_,
-                    typename F_>
-                operation_state(PredecessorSender_&& predecessor_sender,
-                    Receiver_&& receiver, F_&& f)
-                  : predecessor_op_state{hpx::execution::experimental::connect(
-                        HPX_FORWARD(PredecessorSender_, predecessor_sender),
-                        let_value_predecessor_receiver(
-                            HPX_FORWARD(Receiver_, receiver),
-                            HPX_FORWARD(F_, f), *this))}
-                {
-                }
-
-                operation_state(operation_state&&) = delete;
-                operation_state& operator=(operation_state&&) = delete;
-                operation_state(operation_state const&) = delete;
-                operation_state& operator=(operation_state const&) = delete;
-
-                friend void tag_invoke(start_t, operation_state& os) noexcept
-                {
-                    hpx::execution::experimental::start(
-                        os.predecessor_op_state);
-                }
-            };
-
-            template <typename Receiver>
-            friend auto tag_invoke(
-                connect_t, let_value_sender&& s, Receiver&& receiver)
-            {
-                return operation_state<Receiver>(HPX_MOVE(s.predecessor_sender),
-                    HPX_FORWARD(Receiver, receiver), HPX_MOVE(s.f));
-            }
-        };
-    }    // namespace detail
-
-    // let_value is very similar to then: when it is started, it invokes the
-    // provided function with the values sent by the input sender as arguments.
-    // However, where the sender returned from then sends exactly what that
-    // function ends up returning - let_value requires that the function return
-    // a sender, and the sender returned by let_value sends the values sent by
-    // the sender returned from the callback. This is similar to the notion of
-    // "future unwrapping" in future/promise-based frameworks.
-    //
-    // let_value is guaranteed to not begin executing function until the
-    // returned sender is started.
-    inline constexpr struct let_value_t final
-      : hpx::functional::detail::tag_priority<let_value_t>
-    {
-    private:
-        // clang-format off
-        template <typename PredecessorSender, typename F,
-            HPX_CONCEPT_REQUIRES_(
-                hpx::execution::experimental::is_sender_v<PredecessorSender> &&
-                experimental::detail::is_completion_scheduler_tag_invocable_v<
-                    hpx::execution::experimental::set_value_t,
-                    PredecessorSender, let_value_t, F
-                >
-            )>
-        // clang-format on
-        friend constexpr HPX_FORCEINLINE auto tag_override_invoke(
-            let_value_t, PredecessorSender&& predecessor_sender, F&& f)
-        {
-            auto scheduler =
-                hpx::execution::experimental::get_completion_scheduler<
-                    hpx::execution::experimental::set_value_t>(
-                    predecessor_sender);
-
-            return hpx::functional::tag_invoke(let_value_t{},
-                HPX_MOVE(scheduler),
-                HPX_FORWARD(PredecessorSender, predecessor_sender),
-                HPX_FORWARD(F, f));
-        }
-
-        // clang-format off
-        template <typename PredecessorSender, typename F,
-            HPX_CONCEPT_REQUIRES_(
-                hpx::execution::experimental::is_sender_v<PredecessorSender>
-            )>
-        // clang-format on
-        friend constexpr HPX_FORCEINLINE auto tag_invoke(let_value_t,
-            hpx::execution::experimental::run_loop_scheduler const& sched,
-            PredecessorSender&& predecessor_sender, F&& f)
-        {
-            return detail::let_value_sender<PredecessorSender, F,
-                hpx::execution::experimental::run_loop_scheduler>{
-                HPX_FORWARD(PredecessorSender, predecessor_sender),
-                HPX_FORWARD(F, f), sched};
-        }
-
-        // clang-format off
-        template <typename PredecessorSender, typename F,
-            HPX_CONCEPT_REQUIRES_(
-                hpx::execution::experimental::is_sender_v<PredecessorSender>
-            )>
-        // clang-format on
-        friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(
-            let_value_t, PredecessorSender&& predecessor_sender, F&& f)
-        {
-            return detail::let_value_sender<PredecessorSender, F>{
-                HPX_FORWARD(PredecessorSender, predecessor_sender),
-                HPX_FORWARD(F, f), detail::no_scheduler{}};
-        }
-
-        // clang-format off
-        template <typename F, typename Scheduler,
-            HPX_CONCEPT_REQUIRES_(
-                hpx::execution::experimental::is_scheduler_v<Scheduler>
-            )>
-        // clang-format on
-        friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(
-            let_value_t, Scheduler&& scheduler, F&& f)
-        {
-            return hpx::execution::experimental::detail::inject_scheduler<
-                let_value_t, Scheduler, F>{
-                HPX_FORWARD(Scheduler, scheduler), HPX_FORWARD(F, f)};
-        }
-
-        template <typename F>
-        friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(
-            let_value_t, F&& f)
-        {
-            return detail::partial_algorithm<let_value_t, F>{HPX_FORWARD(F, f)};
-        }
-    } let_value{};
-}    // namespace hpx::execution::experimental
-
-#endif
diff --git a/libs/core/execution/include/hpx/execution/algorithms/make_future.hpp b/libs/core/execution/include/hpx/execution/algorithms/make_future.hpp
index a66c5f3ff752..b18e735abd83 100644
--- a/libs/core/execution/include/hpx/execution/algorithms/make_future.hpp
+++ b/libs/core/execution/include/hpx/execution/algorithms/make_future.hpp
@@ -156,22 +156,14 @@ namespace hpx::execution::experimental {
             template <typename Sender>
             future_data_with_run_loop(init_no_addref no_addref,
                 other_allocator const& alloc,
-#if defined(HPX_HAVE_STDEXEC)
                 decltype(std::declval<hpxexec::run_loop>().get_scheduler())
                     const& sched,
-#else
-                hpxexec::run_loop_scheduler const& sched,
-#endif
                 Sender&& sender)
               : base_type(no_addref, alloc, HPX_FORWARD(Sender, sender))
-#if defined(HPX_HAVE_STDEXEC)
               //TODO: Keep an eye on this, it is based on the internal impl of
               // stdexec, so it is subect to change. This is currently relying
               // on the env struct to expose __loop_ as a public member.
               , loop(*hpxexec::get_env(schedule(sched)).__loop_)
-#else
-              , loop(sched.get_run_loop())
-#endif
             {
                 this->set_on_completed([this]() { loop.finish(); });
             }
@@ -230,12 +222,8 @@ namespace hpx::execution::experimental {
         ///////////////////////////////////////////////////////////////////////
         template <typename Sender, typename Allocator>
         auto make_future_with_run_loop(
-#if defined(HPX_HAVE_STDEXEC)
             decltype(std::declval<hpxexec::run_loop>().get_scheduler())
                 const& sched,
-#else
-            hpxexec::run_loop_scheduler const& sched,
-#endif
             Sender&& sender, Allocator const& allocator)
         {
             using allocator_type = Allocator;
@@ -334,14 +322,9 @@ namespace hpx::execution::experimental {
         friend constexpr HPX_FORCEINLINE auto tag_override_invoke(make_future_t,
             Sender&& sender, Allocator const& allocator = Allocator{})
         {
-#if defined(HPX_HAVE_STDEXEC)
             auto scheduler =
                 hpxexec::get_completion_scheduler<hpxexec::set_value_t>(
                     hpxexec::get_env(sender));
-#else
-            auto scheduler =
-                hpxexec::get_completion_scheduler<hpxexec::set_value_t>(sender);
-#endif
 
             return hpx::functional::tag_invoke(make_future_t{},
                 HPX_MOVE(scheduler), HPX_FORWARD(Sender, sender), allocator);
@@ -355,11 +338,8 @@ namespace hpx::execution::experimental {
             )>
         // clang-format on
         friend auto tag_invoke(make_future_t,
-#if defined(HPX_HAVE_STDEXEC)
-            decltype(std::declval<hpxexec::run_loop>().get_scheduler()) const& sched,
-#else
-            hpxexec::run_loop_scheduler const& sched,
-#endif
+            decltype(std::declval<hpxexec::run_loop>().get_scheduler())
+                const& sched,
             Sender&& sender, Allocator const& allocator = Allocator{})
         {
             return detail::make_future_with_run_loop(
diff --git a/libs/core/execution/include/hpx/execution/algorithms/run_loop.hpp b/libs/core/execution/include/hpx/execution/algorithms/run_loop.hpp
index c6fcf3c0bdc9..d918ddd78165 100644
--- a/libs/core/execution/include/hpx/execution/algorithms/run_loop.hpp
+++ b/libs/core/execution/include/hpx/execution/algorithms/run_loop.hpp
@@ -8,408 +8,4 @@
 
 #include <hpx/config.hpp>
 
-#if defined(HPX_HAVE_STDEXEC)
 #include <hpx/execution_base/stdexec_forward.hpp>
-#else
-
-#include <hpx/assert.hpp>
-#include <hpx/concepts/concepts.hpp>
-#include <hpx/errors/try_catch_exception_ptr.hpp>
-#include <hpx/execution/queries/get_scheduler.hpp>
-#include <hpx/execution/queries/get_stop_token.hpp>
-#include <hpx/execution_base/completion_scheduler.hpp>
-#include <hpx/execution_base/completion_signatures.hpp>
-#include <hpx/execution_base/execution.hpp>
-#include <hpx/execution_base/get_env.hpp>
-#include <hpx/modules/memory.hpp>
-#include <hpx/synchronization/detail/condition_variable.hpp>
-#include <hpx/synchronization/spinlock.hpp>
-#include <hpx/thread_support/atomic_count.hpp>
-#include <hpx/type_support/meta.hpp>
-
-#include <exception>
-#include <mutex>
-
-namespace hpx::execution::experimental {
-
-    namespace detail {
-
-        struct run_loop_data;
-
-        HPX_CORE_EXPORT void intrusive_ptr_add_ref(run_loop_data* p) noexcept;
-        HPX_CORE_EXPORT void intrusive_ptr_release(run_loop_data* p) noexcept;
-
-        struct run_loop_data
-        {
-            using mutex_type = hpx::spinlock;
-
-            run_loop_data() noexcept
-              : count_(1)
-            {
-            }
-
-            run_loop_data(run_loop_data const&) = delete;
-            run_loop_data(run_loop_data&&) = delete;
-            run_loop_data& operator=(run_loop_data const&) = delete;
-            run_loop_data& operator=(run_loop_data&&) = delete;
-
-            ~run_loop_data() = default;
-
-            mutable mutex_type mtx_;
-
-        private:
-            friend HPX_CORE_EXPORT void intrusive_ptr_add_ref(
-                run_loop_data*) noexcept;
-            friend HPX_CORE_EXPORT void intrusive_ptr_release(
-                run_loop_data*) noexcept;
-
-            hpx::util::atomic_count count_;
-        };
-    }    // namespace detail
-
-    // A run_loop is an execution context on which work can be scheduled. It
-    // maintains a simple, thread-safe first-in-first-out queue of work. Its
-    // run() member function removes elements from the queue and executes them
-    // in a loop on whatever thread of execution calls run().
-    //
-    // A run_loop instance has an associated count that corresponds to the
-    // number of work items that are in its queue. Additionally, a run_loop has
-    // an associated state that can be one of starting, running, or finishing.
-    //
-    // Concurrent invocations of the member functions of run_loop, other than
-    // run and its destructor, do not introduce data races. The member functions
-    // pop_front, push_back, and finish execute atomically.
-    //
-    // [Note: Implementations are encouraged to use an intrusive queue of
-    // operation states to hold the work units to make scheduling
-    // allocation-free. -- end note]
-    //
-    class run_loop
-    {
-        struct run_loop_opstate_base
-        {
-            explicit run_loop_opstate_base(run_loop_opstate_base* tail) noexcept
-              : next(this)
-              , tail(tail)
-            {
-            }
-
-            run_loop_opstate_base(run_loop_opstate_base* tail,
-                void (*execute)(run_loop_opstate_base*) noexcept) noexcept
-              : next(tail)
-              , execute_(execute)
-            {
-            }
-
-            run_loop_opstate_base(run_loop_opstate_base const&) = delete;
-            run_loop_opstate_base(run_loop_opstate_base&&) = delete;
-            run_loop_opstate_base& operator=(
-                run_loop_opstate_base const&) = delete;
-            run_loop_opstate_base& operator=(run_loop_opstate_base&&) = delete;
-
-            ~run_loop_opstate_base() = default;
-
-            run_loop_opstate_base* next;
-            union
-            {
-                void (*execute_)(run_loop_opstate_base*) noexcept;
-                run_loop_opstate_base* tail;
-            };
-
-            void execute() noexcept
-            {
-                (*execute_)(this);
-            }
-        };
-
-        template <typename ReceiverId>
-        struct run_loop_opstate
-        {
-            using Receiver = hpx::meta::type<ReceiverId>;
-
-            struct type : run_loop_opstate_base
-            {
-                using id = run_loop_opstate;
-
-                run_loop& loop;
-                HPX_NO_UNIQUE_ADDRESS std::decay_t<Receiver> receiver;
-
-                template <typename Receiver_>
-                type(run_loop_opstate_base* tail, run_loop& loop,
-                    Receiver_&& receiver) noexcept(noexcept(std::
-                        is_nothrow_constructible_v<std::decay_t<Receiver>,
-                            Receiver_>))
-                  : run_loop_opstate_base(tail)
-                  , loop(loop)
-                  , receiver(HPX_FORWARD(Receiver_, receiver))
-                {
-                }
-
-                static void execute(run_loop_opstate_base* p) noexcept
-                {
-                    auto& receiver = static_cast<type*>(p)->receiver;
-                    hpx::detail::try_catch_exception_ptr(
-                        [&]() {
-                            if (get_stop_token(get_env(receiver))
-                                    .stop_requested())
-                            {
-                                hpx::execution::experimental::set_stopped(
-                                    HPX_MOVE(receiver));
-                            }
-                            else
-                            {
-                                hpx::execution::experimental::set_value(
-                                    HPX_MOVE(receiver));
-                            }
-                        },
-                        [&](std::exception_ptr ep) {
-                            hpx::execution::experimental::set_error(
-                                HPX_MOVE(receiver), HPX_MOVE(ep));
-                        });
-                }
-
-                type(run_loop_opstate_base* next, run_loop& loop, Receiver r)
-                  : run_loop_opstate_base(next, &execute)
-                  , loop(loop)
-                  , receiver(HPX_MOVE(r))
-                {
-                }
-
-                friend void tag_invoke(
-                    hpx::execution::experimental::start_t, type& os) noexcept
-                {
-                    os.start();
-                }
-
-                void start() & noexcept;
-            };
-        };
-
-    public:
-        class run_loop_scheduler
-        {
-        public:
-            using type = run_loop_scheduler;
-            using id = run_loop_scheduler;
-
-            struct run_loop_sender
-            {
-                using is_sender = void;
-                using type = run_loop_sender;
-                using id = run_loop_sender;
-
-                explicit run_loop_sender(run_loop& loop) noexcept
-                  : loop(loop)
-                {
-                }
-
-            private:
-                friend run_loop_scheduler;
-
-                template <typename Receiver>
-                using operation_state = hpx::meta::type<
-                    run_loop_opstate<hpx::meta::get_id_t<Receiver>>>;
-
-                template <typename Receiver>
-                friend operation_state<Receiver> tag_invoke(
-                    hpx::execution::experimental::connect_t,
-                    run_loop_sender const& s,
-                    Receiver&& receiver) noexcept(noexcept(std::
-                        is_nothrow_constructible_v<operation_state<Receiver>,
-                            run_loop_opstate_base*, run_loop&>))
-                {
-                    return operation_state<Receiver>(
-                        &s.loop.head, s.loop, HPX_FORWARD(Receiver, receiver));
-                }
-
-                // clang-format off
-                template <typename CPO,
-                    HPX_CONCEPT_REQUIRES_(
-                        meta::value<meta::one_of<
-                            std::decay_t<CPO>, set_value_t, set_stopped_t>>
-                    )>
-                // clang-format on
-                friend run_loop_scheduler tag_invoke(
-                    hpx::execution::experimental::get_completion_scheduler_t<
-                        CPO>,
-                    run_loop_sender const& s) noexcept
-                {
-                    return run_loop_scheduler{s.loop};
-                }
-
-                using completion_signatures =
-                    hpx::execution::experimental::completion_signatures<
-                        hpx::execution::experimental::set_value_t(),
-                        hpx::execution::experimental::set_error_t(
-                            std::exception_ptr),
-                        hpx::execution::experimental::set_stopped_t()>;
-
-                // clang-format off
-                template <typename Env>
-                friend auto tag_invoke(
-                    hpx::execution::experimental::get_completion_signatures_t,
-                    run_loop_sender const&,
-                    Env) noexcept -> completion_signatures;
-                // clang-format on
-
-                run_loop& loop;
-            };
-
-            friend run_loop;
-
-        public:
-            explicit run_loop_scheduler(run_loop& loop) noexcept
-              : loop(loop)
-            {
-            }
-
-            run_loop& get_run_loop() const noexcept
-            {
-                return loop;
-            }
-
-        private:
-            friend run_loop_sender tag_invoke(
-                hpx::execution::experimental::schedule_t,
-                run_loop_scheduler const& sched) noexcept
-            {
-                return run_loop_sender(sched.loop);
-            }
-
-            friend constexpr hpx::execution::experimental::
-                forward_progress_guarantee
-                tag_invoke(hpx::execution::experimental::
-                               get_forward_progress_guarantee_t,
-                    run_loop_scheduler const&) noexcept
-            {
-                return hpx::execution::experimental::
-                    forward_progress_guarantee::parallel;
-            }
-
-            friend constexpr bool operator==(run_loop_scheduler const& lhs,
-                run_loop_scheduler const& rhs) noexcept
-            {
-                return &lhs.loop == &rhs.loop;
-            }
-            friend constexpr bool operator!=(run_loop_scheduler const& lhs,
-                run_loop_scheduler const& rhs) noexcept
-            {
-                return !(lhs == rhs);
-            }
-
-        private:
-            run_loop& loop;
-        };
-
-    private:
-        friend struct run_loop_scheduler::run_loop_sender;
-
-        hpx::intrusive_ptr<detail::run_loop_data> mtx;
-        hpx::lcos::local::detail::condition_variable cond_var;
-
-        // MSVC and gcc don't properly handle the friend declaration above
-#if defined(HPX_MSVC) || defined(HPX_GCC_VERSION)
-    public:
-#endif
-        run_loop_opstate_base head;
-
-    private:
-        bool stop = false;
-
-        void push_back(run_loop_opstate_base* t)
-        {
-            auto const local_mtx = mtx;    // keep alive
-            std::unique_lock l(local_mtx->mtx_);
-
-            stop = false;
-            t->next = &head;
-            head.tail = head.tail->next = t;
-            cond_var.notify_one(HPX_MOVE(l));
-        }
-
-        run_loop_opstate_base* pop_front()
-        {
-            auto const local_mtx = mtx;    // keep alive
-            std::unique_lock l(local_mtx->mtx_);
-
-            while (head.next == &head && !stop)
-            {
-                cond_var.wait(l);
-            }
-
-            if (head.tail == head.next)
-            {
-                head.tail = &head;
-            }
-
-            // std::exchange(head.next, head.next->next);
-            auto const old_val = HPX_MOVE(head.next);
-            head.next = HPX_MOVE(head.next->next);
-            return old_val;
-        }
-
-    public:
-        // [exec.run_loop.ctor] construct/copy/destroy
-        run_loop() noexcept
-          : mtx(new detail::run_loop_data(), false)
-          , head(&head)    //-V546
-        {
-        }
-
-        run_loop(run_loop const&) = delete;
-        run_loop(run_loop&&) = delete;
-        run_loop& operator=(run_loop const&) = delete;
-        run_loop& operator=(run_loop&&) = delete;
-
-        // If count is not 0 or if state is running, invokes terminate().
-        // Otherwise, has no effects.
-        ~run_loop()
-        {
-            if (head.next != &head || !stop)
-            {
-                std::terminate();
-            }
-        }
-
-        // [exec.run_loop.members] Member functions:
-        run_loop_scheduler get_scheduler()
-        {
-            return run_loop_scheduler(*this);
-        }
-
-        void run()
-        {
-            // Precondition: state is starting.
-            //HPX_ASSERT(head.next != &head || !stop);
-            for (run_loop_opstate_base* t; (t = pop_front()) != &head; /**/)
-            {
-                t->execute();
-            }
-            HPX_ASSERT(stop);    // Postcondition: state is finishing.
-        }
-
-        void finish()
-        {
-            auto const local_mtx = mtx;    // keep alive
-            std::unique_lock l(local_mtx->mtx_);
-
-            stop = true;
-            cond_var.notify_all(HPX_MOVE(l));
-        }
-    };
-
-    using run_loop_scheduler = run_loop::run_loop_scheduler;
-
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename ReceiverId>
-    inline void run_loop::run_loop_opstate<ReceiverId>::type::start() & noexcept
-    try
-    {
-        loop.push_back(this);
-    }
-    catch (...)
-    {
-        set_error(HPX_MOVE(receiver), std::current_exception());
-    }
-}    // namespace hpx::execution::experimental
-#endif
diff --git a/libs/core/execution/include/hpx/execution/algorithms/schedule_from.hpp b/libs/core/execution/include/hpx/execution/algorithms/schedule_from.hpp
index 2758af28e563..4b842130a399 100644
--- a/libs/core/execution/include/hpx/execution/algorithms/schedule_from.hpp
+++ b/libs/core/execution/include/hpx/execution/algorithms/schedule_from.hpp
@@ -9,366 +9,4 @@
 
 #include <hpx/config.hpp>
 
-#if defined(HPX_HAVE_STDEXEC)
 #include <hpx/execution_base/stdexec_forward.hpp>
-#else
-
-#include <hpx/concepts/concepts.hpp>
-#include <hpx/datastructures/optional.hpp>
-#include <hpx/datastructures/tuple.hpp>
-#include <hpx/datastructures/variant.hpp>
-#include <hpx/execution_base/completion_scheduler.hpp>
-#include <hpx/execution_base/completion_signatures.hpp>
-#include <hpx/execution_base/get_env.hpp>
-#include <hpx/execution_base/receiver.hpp>
-#include <hpx/execution_base/sender.hpp>
-#include <hpx/functional/bind_front.hpp>
-#include <hpx/functional/detail/tag_fallback_invoke.hpp>
-#include <hpx/functional/invoke_fused.hpp>
-#include <hpx/type_support/detail/with_result_of.hpp>
-#include <hpx/type_support/meta.hpp>
-#include <hpx/type_support/pack.hpp>
-
-#include <atomic>
-#include <cstddef>
-#include <exception>
-#include <type_traits>
-#include <utility>
-
-namespace hpx::execution::experimental {
-
-    namespace detail {
-
-        template <typename Sender, typename Scheduler>
-        struct schedule_from_sender
-        {
-            using is_sender = void;
-            HPX_NO_UNIQUE_ADDRESS std::decay_t<Sender> predecessor_sender;
-            HPX_NO_UNIQUE_ADDRESS std::decay_t<Scheduler> scheduler;
-
-            template <typename Env>
-            struct generate_completion_signatures
-            {
-                template <template <typename...> typename Tuple,
-                    template <typename...> typename Variant>
-                using value_types =
-                    value_types_of_t<Sender, Env, Tuple, Variant>;
-
-                template <template <typename...> typename Variant>
-                using predecessor_sender_error_types =
-                    error_types_of_t<Sender, Env, Variant>;
-
-                using scheduler_sender_type = hpx::util::invoke_result_t<
-                    hpx::execution::experimental::schedule_t, Scheduler>;
-
-                template <template <typename...> typename Variant>
-                using scheduler_sender_error_types =
-                    error_types_of_t<scheduler_sender_type, Env, Variant>;
-
-                template <template <typename...> typename Variant>
-                using error_types = hpx::util::detail::unique_concat_t<
-                    predecessor_sender_error_types<Variant>,
-                    scheduler_sender_error_types<Variant>>;
-
-                static constexpr bool sends_stopped = false;
-            };
-
-            // clang-format off
-            template <typename Env>
-            friend auto tag_invoke(get_completion_signatures_t,
-                schedule_from_sender const&,
-                Env) -> generate_completion_signatures<Env>;
-
-            template <typename CPO,
-                HPX_CONCEPT_REQUIRES_(
-                    meta::value<meta::one_of<
-                        std::decay_t<CPO>, set_value_t, set_stopped_t>>
-                )>
-            // clang-format on
-            friend constexpr auto tag_invoke(
-                hpx::execution::experimental::get_completion_scheduler_t<CPO>,
-                schedule_from_sender const& sender)
-            {
-                return sender.scheduler;
-            }
-
-            // TODO: add forwarding_sender_query
-
-#if defined(HPX_GCC_VERSION) && HPX_GCC_VERSION >= 110000
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Warray-bounds"
-#endif
-            template <typename Receiver>
-            struct operation_state
-            {
-                HPX_NO_UNIQUE_ADDRESS std::decay_t<Scheduler> scheduler;
-                HPX_NO_UNIQUE_ADDRESS std::decay_t<Receiver> receiver;
-
-                struct predecessor_sender_receiver;
-                struct scheduler_sender_receiver;
-
-                using value_type = hpx::util::detail::prepend_t<
-                    value_types_of_t<Sender, empty_env, decayed_tuple,
-                        hpx::variant>,
-                    hpx::monostate>;
-                value_type ts;
-
-                using sender_operation_state_type =
-                    connect_result_t<Sender, predecessor_sender_receiver>;
-                sender_operation_state_type sender_os;
-
-                using scheduler_operation_state_type = connect_result_t<
-                    hpx::util::invoke_result_t<schedule_t, Scheduler>,
-                    scheduler_sender_receiver>;
-                hpx::optional<scheduler_operation_state_type>
-                    scheduler_op_state;
-
-                template <typename Sender_, typename Scheduler_,
-                    typename Receiver_>
-                operation_state(Sender_&& predecessor_sender,
-                    Scheduler_&& scheduler, Receiver_&& receiver)
-                  : scheduler(HPX_FORWARD(Scheduler, scheduler))
-                  , receiver(HPX_FORWARD(Receiver_, receiver))
-                  , sender_os(hpx::execution::experimental::connect(
-                        HPX_FORWARD(Sender_, predecessor_sender),
-                        predecessor_sender_receiver{*this}))
-                {
-                }
-
-                operation_state(operation_state&&) = delete;
-                operation_state(operation_state const&) = delete;
-                operation_state& operator=(operation_state&&) = delete;
-                operation_state& operator=(operation_state const&) = delete;
-
-                struct predecessor_sender_receiver
-                {
-                    operation_state& op_state;
-
-                    template <typename Error>
-                    friend void tag_invoke(set_error_t,
-                        predecessor_sender_receiver&& r, Error&& error) noexcept
-                    {
-                        r.op_state.set_error_predecessor_sender(
-                            HPX_FORWARD(Error, error));
-                    }
-
-                    friend void tag_invoke(
-                        set_stopped_t, predecessor_sender_receiver&& r) noexcept
-                    {
-                        r.op_state.set_stopped_predecessor_sender();
-                    }
-
-                    // This typedef is duplicated from the parent struct. The
-                    // parent typedef is not instantiated early enough for use
-                    // here.
-                    using value_type = hpx::util::detail::prepend_t<
-                        value_types_of_t<Sender, empty_env, decayed_tuple,
-                            hpx::variant>,
-                        hpx::monostate>;
-
-                    template <typename... Ts>
-                    friend auto tag_invoke(set_value_t,
-                        predecessor_sender_receiver&& r, Ts&&... ts) noexcept
-                        -> decltype(std::declval<value_type>()
-                                        .template emplace<hpx::tuple<Ts...>>(
-                                            HPX_FORWARD(Ts, ts)...),
-                            void())
-                    {
-                        r.op_state.set_value_predecessor_sender(
-                            HPX_FORWARD(Ts, ts)...);
-                    }
-
-                    // Pass through the get_env receiver query
-                    friend auto tag_invoke(
-                        get_env_t, predecessor_sender_receiver const& r)
-                        -> env_of_t<std::decay_t<Receiver>>
-                    {
-                        return hpx::execution::experimental::get_env(
-                            r.op_state.receiver);
-                    }
-                };
-
-                template <typename Error>
-                void set_error_predecessor_sender(Error&& error) noexcept
-                {
-                    hpx::execution::experimental::set_error(
-                        HPX_MOVE(receiver), HPX_FORWARD(Error, error));
-                }
-
-                void set_stopped_predecessor_sender() noexcept
-                {
-                    hpx::execution::experimental::set_stopped(
-                        HPX_MOVE(receiver));
-                }
-
-                template <typename... Us>
-                void set_value_predecessor_sender(Us&&... us) noexcept
-                {
-                    ts.template emplace<hpx::tuple<Us...>>(
-                        HPX_FORWARD(Us, us)...);
-#if defined(HPX_HAVE_CXX17_COPY_ELISION) &&                                    \
-    defined(HPX_HAVE_CXX17_OPTIONAL_COPY_ELISION)
-                    // with_result_of is used to emplace the operation
-                    // state returned from connect without any
-                    // intermediate copy construction (the operation
-                    // state is not required to be copyable nor movable).
-                    scheduler_op_state.emplace(
-                        hpx::util::detail::with_result_of([&]() {
-                            return hpx::execution::experimental::connect(
-                                hpx::execution::experimental::schedule(
-                                    HPX_MOVE(scheduler)),
-                                scheduler_sender_receiver{*this});
-                        }));
-#else
-                    // earlier versions of MSVC don't get copy elision quite
-                    // right, the operation state must be constructed explicitly
-                    // directly in place
-                    scheduler_op_state.emplace_f(
-                        hpx::execution::experimental::connect,
-                        hpx::execution::experimental::schedule(
-                            HPX_MOVE(scheduler)),
-                        scheduler_sender_receiver{*this});
-#endif
-                    hpx::execution::experimental::start(*scheduler_op_state);
-                }
-
-                struct scheduler_sender_receiver
-                {
-                    operation_state& op_state;
-
-                    template <typename Error>
-                    friend void tag_invoke(set_error_t,
-                        scheduler_sender_receiver&& r, Error&& error) noexcept
-                    {
-                        r.op_state.set_error_scheduler_sender(
-                            HPX_FORWARD(Error, error));
-                    }
-
-                    friend void tag_invoke(
-                        set_stopped_t, scheduler_sender_receiver&& r) noexcept
-                    {
-                        r.op_state.set_stopped_scheduler_sender();
-                    }
-
-                    friend void tag_invoke(
-                        set_value_t, scheduler_sender_receiver&& r) noexcept
-                    {
-                        r.op_state.set_value_scheduler_sender();
-                    }
-
-                    // Pass through the get_env receiver query
-                    friend auto tag_invoke(
-                        get_env_t, scheduler_sender_receiver const& r)
-                        -> env_of_t<std::decay_t<Receiver>>
-                    {
-                        return get_env(r.op_state.receiver);
-                    }
-                };
-
-                struct scheduler_sender_value_visitor
-                {
-                    HPX_NO_UNIQUE_ADDRESS std::decay_t<Receiver> receiver;
-
-                    [[noreturn]] void operator()(hpx::monostate) const
-                    {
-                        HPX_UNREACHABLE;
-                    }
-
-                    template <typename Ts,
-                        typename = std::enable_if_t<
-                            !std::is_same_v<std::decay_t<Ts>, hpx::monostate>>>
-                    void operator()(Ts&& ts)
-                    {
-                        hpx::invoke_fused(
-                            hpx::bind_front(
-                                hpx::execution::experimental::set_value,
-                                HPX_MOVE(receiver)),
-                            HPX_FORWARD(Ts, ts));
-                    }
-                };
-
-                template <typename Error>
-                void set_error_scheduler_sender(Error&& error) noexcept
-                {
-                    scheduler_op_state.reset();
-                    hpx::execution::experimental::set_error(
-                        HPX_MOVE(receiver), HPX_FORWARD(Error, error));
-                }
-
-                void set_stopped_scheduler_sender() noexcept
-                {
-                    scheduler_op_state.reset();
-                    hpx::execution::experimental::set_stopped(
-                        HPX_MOVE(receiver));
-                }
-
-                void set_value_scheduler_sender() noexcept
-                {
-                    scheduler_op_state.reset();
-                    hpx::visit(
-                        scheduler_sender_value_visitor{HPX_MOVE(receiver)},
-                        HPX_MOVE(ts));
-                }
-
-                friend void tag_invoke(start_t, operation_state& os) noexcept
-                {
-                    hpx::execution::experimental::start(os.sender_os);
-                }
-            };
-#if defined(HPX_GCC_VERSION) && HPX_GCC_VERSION >= 110000
-#pragma GCC diagnostic pop
-#endif
-
-            template <typename Receiver>
-            friend operation_state<Receiver> tag_invoke(
-                connect_t, schedule_from_sender&& s, Receiver&& receiver)
-            {
-                return {HPX_MOVE(s.predecessor_sender), HPX_MOVE(s.scheduler),
-                    HPX_FORWARD(Receiver, receiver)};
-            }
-
-            template <typename Receiver>
-            friend operation_state<Receiver> tag_invoke(
-                connect_t, schedule_from_sender& s, Receiver&& receiver)
-            {
-                return {s.predecessor_sender, s.scheduler,
-                    HPX_FORWARD(Receiver, receiver)};
-            }
-        };
-    }    // namespace detail
-
-    // execution::schedule_from is used to schedule work dependent on the
-    // completion of a sender onto a scheduler's associated execution context.
-    //
-    // [Note: schedule_from is not meant to be used in user code; it is used in
-    // the implementation of transfer. -end note]
-    //
-    // Senders returned from execution::schedule_from shall not propagate the
-    // sender queries get_completion_scheduler<CPO> to an input sender. They
-    // will implement get_completion_scheduler<CPO>, where CPO is one of
-    // set_value_t and set_stopped_t; this query returns a scheduler equivalent
-    // to the sch argument from those queries. The
-    // get_completion_scheduler<set_error_t> is not implemented, as the
-    // scheduler cannot be guaranteed in case an error is thrown while trying to
-    // schedule work on the given scheduler object.
-    HPX_HOST_DEVICE_INLINE_CONSTEXPR_VARIABLE struct schedule_from_t final
-      : hpx::functional::detail::tag_fallback<schedule_from_t>
-    {
-    private:
-        // clang-format off
-        template <typename Scheduler, typename Sender,
-            HPX_CONCEPT_REQUIRES_(
-                is_sender_v<Sender>
-            )>
-        // clang-format on
-        friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(
-            schedule_from_t, Scheduler&& scheduler, Sender&& predecessor_sender)
-        {
-            return detail::schedule_from_sender<Sender, Scheduler>{
-                HPX_FORWARD(Sender, predecessor_sender),
-                HPX_FORWARD(Scheduler, scheduler)};
-        }
-    } schedule_from{};
-}    // namespace hpx::execution::experimental
-
-#endif
diff --git a/libs/core/execution/include/hpx/execution/algorithms/split.hpp b/libs/core/execution/include/hpx/execution/algorithms/split.hpp
index 98b9f5ab0985..2770d6a935bc 100644
--- a/libs/core/execution/include/hpx/execution/algorithms/split.hpp
+++ b/libs/core/execution/include/hpx/execution/algorithms/split.hpp
@@ -9,696 +9,4 @@
 
 #include <hpx/config.hpp>
 
-#if defined(HPX_HAVE_STDEXEC)
 #include <hpx/execution_base/stdexec_forward.hpp>
-#else
-
-#include <hpx/allocator_support/allocator_deleter.hpp>
-#include <hpx/allocator_support/internal_allocator.hpp>
-#include <hpx/allocator_support/traits/is_allocator.hpp>
-#include <hpx/assert.hpp>
-#include <hpx/concepts/concepts.hpp>
-#include <hpx/datastructures/detail/small_vector.hpp>
-#include <hpx/datastructures/tuple.hpp>
-#include <hpx/datastructures/variant.hpp>
-#include <hpx/errors/try_catch_exception_ptr.hpp>
-#include <hpx/execution/algorithms/detail/inject_scheduler.hpp>
-#include <hpx/execution/algorithms/detail/partial_algorithm.hpp>
-#include <hpx/execution/algorithms/detail/single_result.hpp>
-#include <hpx/execution/algorithms/run_loop.hpp>
-#include <hpx/execution_base/completion_scheduler.hpp>
-#include <hpx/execution_base/completion_signatures.hpp>
-#include <hpx/execution_base/operation_state.hpp>
-#include <hpx/execution_base/receiver.hpp>
-#include <hpx/execution_base/sender.hpp>
-#include <hpx/functional/bind_front.hpp>
-#include <hpx/functional/detail/tag_priority_invoke.hpp>
-#include <hpx/functional/invoke_fused.hpp>
-#include <hpx/functional/move_only_function.hpp>
-#include <hpx/modules/memory.hpp>
-#include <hpx/synchronization/spinlock.hpp>
-#include <hpx/thread_support/atomic_count.hpp>
-#include <hpx/type_support/meta.hpp>
-#include <hpx/type_support/pack.hpp>
-
-#include <atomic>
-#include <cstddef>
-#include <exception>
-#include <memory>
-#include <mutex>
-#include <type_traits>
-#include <utility>
-
-namespace hpx::execution::experimental {
-
-    namespace detail {
-
-        enum class submission_type
-        {
-            eager,
-            lazy
-        };
-
-        template <typename Receiver>
-        struct error_visitor
-        {
-            HPX_NO_UNIQUE_ADDRESS std::decay_t<Receiver>& receiver;
-
-            template <typename Error>
-            void operator()(Error const& error) noexcept
-            {
-                // FIXME: check whether it is ok to move the receiver
-                hpx::execution::experimental::set_error(
-                    HPX_MOVE(receiver), error);
-            }
-        };
-
-        template <typename Receiver>
-        struct value_visitor
-        {
-            HPX_NO_UNIQUE_ADDRESS std::decay_t<Receiver>& receiver;
-
-            template <typename Ts>
-            void operator()(Ts const& ts) noexcept
-            {
-                // FIXME: check whether it is ok to move the receiver
-                hpx::invoke_fused(
-                    hpx::bind_front(hpx::execution::experimental::set_value,
-                        HPX_MOVE(receiver)),
-                    ts);
-            }
-        };
-
-        template <typename Sender, typename Allocator, submission_type Type,
-            typename Scheduler = no_scheduler>
-        struct split_sender
-        {
-            using is_sender = void;
-            HPX_NO_UNIQUE_ADDRESS std::decay_t<Scheduler> scheduler;
-
-            template <typename Tuple>
-            struct value_types_helper
-            {
-                using const_type =
-                    hpx::util::detail::transform_t<Tuple, std::add_const>;
-                using type = hpx::util::detail::transform_t<const_type,
-                    std::add_lvalue_reference>;
-            };
-
-            template <typename Env>
-            struct generate_completion_signatures
-            {
-                template <template <typename...> typename Tuple,
-                    template <typename...> typename Variant>
-                using value_types = hpx::util::detail::transform_t<
-                    value_types_of_t<Sender, Env, Tuple, Variant>,
-                    value_types_helper>;
-
-                template <template <typename...> typename Variant>
-                using error_types =
-                    hpx::util::detail::unique_t<hpx::util::detail::prepend_t<
-                        error_types_of_t<Sender, Env, Variant>,
-                        std::exception_ptr>>;
-
-                static constexpr bool sends_stopped = true;
-            };
-
-            // clang-format off
-            template <typename Env>
-            friend auto tag_invoke(get_completion_signatures_t,
-                split_sender const&,
-                Env) -> generate_completion_signatures<Env>;
-
-            template <typename CPO, typename Scheduler_ = Scheduler,
-                HPX_CONCEPT_REQUIRES_(
-                    hpx::execution::experimental::is_scheduler_v<Scheduler_> &&
-                    is_receiver_cpo_v<std::decay_t<CPO>>
-                )>
-            // clang-format on
-            friend constexpr auto tag_invoke(
-                hpx::execution::experimental::get_completion_scheduler_t<CPO>,
-                split_sender const& sender)
-            {
-                return sender.scheduler;
-            }
-
-            // TODO: add forwarding_sender_query
-
-            struct shared_state
-            {
-                struct split_receiver;
-
-                using allocator_type = typename std::allocator_traits<
-                    Allocator>::template rebind_alloc<shared_state>;
-                HPX_NO_UNIQUE_ADDRESS allocator_type alloc;
-
-                hpx::spinlock mtx;
-                hpx::util::atomic_count reference_count{0};
-                std::atomic<bool> start_called{false};
-                std::atomic<bool> predecessor_done{false};
-
-                using operation_state_type =
-                    std::decay_t<connect_result_t<Sender, split_receiver>>;
-                operation_state_type os;
-
-                using signatures = generate_completion_signatures<empty_env>;
-
-                struct stopped_type
-                {
-                };
-                using value_type = value_types_of_t<Sender, empty_env,
-                    decayed_tuple, hpx::variant>;
-                using error_type = detail::error_types_from<signatures,
-                    meta::func<hpx::variant>>;
-
-                hpx::variant<hpx::monostate, stopped_type, error_type,
-                    value_type>
-                    v;
-
-                using continuation_type = hpx::move_only_function<void()>;
-                hpx::detail::small_vector<continuation_type, 1> continuations;
-
-                struct split_receiver
-                {
-                    hpx::intrusive_ptr<shared_state> state;
-
-                    template <typename Error>
-                    friend void tag_invoke(
-                        set_error_t, split_receiver&& r, Error&& error) noexcept
-                    {
-                        HPX_MOVE(r).set_error(HPX_FORWARD(Error, error));
-                    }
-
-                    template <typename Error>
-                    void set_error(Error&& error) && noexcept
-                    {
-                        try
-                        {
-                            state->v.template emplace<error_type>(
-                                error_type(HPX_FORWARD(Error, error)));
-                        }
-                        catch (...)
-                        {
-                            // no way of reporting this error
-                            std::terminate();
-                        }
-                        state->set_predecessor_done();
-                        state.reset();
-                    }
-
-                    friend void tag_invoke(
-                        set_stopped_t, split_receiver&& r) noexcept
-                    {
-                        if (r.state)
-                        {
-                            r.state->v.template emplace<stopped_type>();
-                            r.state->set_predecessor_done();
-                            r.state.reset();
-                        }
-                    };
-
-                    // This typedef is duplicated from the parent struct. The
-                    // parent typedef is not instantiated early enough for use
-                    // here.
-                    using value_type = value_types_of_t<Sender, empty_env,
-                        decayed_tuple, hpx::variant>;
-
-                    // different versions of clang-format disagree
-                    // clang-format off
-                    template <typename... Ts>
-                    friend auto tag_invoke(
-                        set_value_t, split_receiver&& r, Ts&&... ts) noexcept
-                        -> decltype(
-                            std::declval<
-                                hpx::variant<hpx::monostate, value_type>>()
-                                .template emplace<value_type>(
-                                    hpx::tuple<std::decay_t<Ts>...>(
-                                        HPX_FORWARD(Ts, ts)...)),
-                            void())
-                    // clang-format on
-                    {
-                        hpx::detail::try_catch_exception_ptr(
-                            [&]() {
-                                r.state->v.template emplace<value_type>(
-                                    hpx::make_tuple(HPX_FORWARD(Ts, ts)...));
-                                r.state->set_predecessor_done();
-                                r.state.reset();
-                            },
-                            [&](std::exception_ptr ep) {
-                                HPX_MOVE(r).set_error(HPX_MOVE(ep));
-                            });
-                    }
-                };
-
-                // clang-format off
-                template <typename Sender_,
-                    HPX_CONCEPT_REQUIRES_(
-                        meta::value<meta::none_of<
-                            shared_state, std::decay_t<Sender_>>>
-                    )>
-                // clang-format on
-                shared_state(Sender_&& sender, allocator_type const& alloc)
-                  : alloc(alloc)
-                  , os(hpx::execution::experimental::connect(
-                        HPX_FORWARD(Sender_, sender), split_receiver{this}))
-                {
-                }
-
-                virtual ~shared_state()
-                {
-                    HPX_ASSERT_MSG(start_called,
-                        "start was never called on the operation state of "
-                        "split or ensure_started. Did you forget to connect the"
-                        "sender to a receiver, or call start on the operation "
-                        "state?");
-                }
-
-                template <typename Receiver>
-                struct done_error_value_visitor
-                {
-                    HPX_NO_UNIQUE_ADDRESS std::decay_t<Receiver> receiver;
-
-                    [[noreturn]] void operator()(hpx::monostate) const
-                    {
-                        HPX_UNREACHABLE;
-                    }
-
-                    void operator()(stopped_type)
-                    {
-                        hpx::execution::experimental::set_stopped(
-                            HPX_MOVE(receiver));
-                    }
-
-                    void operator()(error_type const& error)
-                    {
-                        hpx::visit(error_visitor<Receiver>{receiver}, error);
-                    }
-
-                    void operator()(value_type const& ts)
-                    {
-                        hpx::visit(value_visitor<Receiver>{receiver}, ts);
-                    }
-                };
-
-                virtual void set_predecessor_done()
-                {
-                    predecessor_done = true;
-
-                    {
-                        // We require taking the lock here to synchronize with
-                        // threads attempting to add continuations to the vector
-                        // of continuations. However, it is enough to take it
-                        // once and release it immediately.
-                        //
-                        // Without the lock we may not see writes to the vector.
-                        // With the lock threads attempting to add continuations
-                        // will either:
-                        // - See predecessor_done = true in which case they will
-                        //   call the continuation directly without adding it to
-                        //   the vector of continuations. Accessing the vector
-                        //   below without the lock is safe in this case because
-                        //   the vector is not modified.
-                        // - See predecessor_done = false and proceed to take
-                        //   the lock. If they see predecessor_done after taking
-                        //   the lock they can again release the lock and call
-                        //   the continuation directly. Accessing the vector
-                        //   without the lock is again safe because the vector
-                        //   is not modified.
-                        // - See predecessor_done = false and proceed to take
-                        //   the lock. If they see predecessor_done is still
-                        //   false after taking the lock, they will proceed to
-                        //   add a continuation to the vector. Since they keep
-                        //   the lock they can safely write to the vector. This
-                        //   thread will not proceed past the lock until they
-                        //   have finished writing to the vector.
-                        //
-                        // Importantly, once this thread has taken and released
-                        // this lock, threads attempting to add continuations to
-                        // the vector must see predecessor_done = true after
-                        // taking the lock in their threads and will not add
-                        // continuations to the vector.
-                        std::unique_lock l{mtx};
-                    }
-
-                    if (!continuations.empty())
-                    {
-                        for (auto const& continuation : continuations)
-                        {
-                            continuation();
-                        }
-
-                        continuations.clear();
-                    }
-                }
-
-                template <typename Receiver>
-                void add_continuation(Receiver& receiver) = delete;
-
-                template <typename Receiver>
-                void add_continuation(Receiver&& receiver)
-                {
-                    if (predecessor_done)
-                    {
-                        // If we read predecessor_done here it means that one of
-                        // set_error/set_stopped/set_value has been called and
-                        // values/errors have been stored into the shared state.
-                        // We can trigger the continuation directly.
-                        // TODO: Should this preserve the scheduler? It does not
-                        // if we call set_* inline.
-                        hpx::visit(
-                            done_error_value_visitor<Receiver>{
-                                HPX_FORWARD(Receiver, receiver)},
-                            v);
-                    }
-                    else
-                    {
-                        // If predecessor_done is false, we have to take the
-                        // lock to potentially add the continuation to the
-                        // vector of continuations.
-                        std::unique_lock l{mtx};
-
-                        if (predecessor_done)
-                        {
-                            // By the time the lock has been taken,
-                            // predecessor_done might already be true and we can
-                            // release the lock early and call the continuation
-                            // directly again.
-                            l.unlock();
-                            hpx::visit(
-                                done_error_value_visitor<Receiver>{
-                                    HPX_FORWARD(Receiver, receiver)},
-                                v);
-                        }
-                        else
-                        {
-                            // If predecessor_done is still false, we add the
-                            // continuation to the vector of continuations. This
-                            // has to be done while holding the lock, since
-                            // other threads may also try to add continuations
-                            // to the vector and the vector is not threadsafe in
-                            // itself. The continuation will be called later
-                            // when set_error/set_stopped/set_value is called.
-                            continuations.emplace_back(
-                                [this,
-                                    receiver = HPX_FORWARD(
-                                        Receiver, receiver)]() mutable {
-                                    hpx::visit(
-                                        done_error_value_visitor<Receiver>{
-                                            HPX_MOVE(receiver)},
-                                        v);
-                                });
-                        }
-                    }
-                }
-
-                void start() & noexcept
-                {
-                    if (!start_called.exchange(true))
-                    {
-                        hpx::execution::experimental::start(os);
-                    }
-                }
-
-                friend void intrusive_ptr_add_ref(shared_state* p) noexcept
-                {
-                    ++p->reference_count;
-                }
-
-                friend void intrusive_ptr_release(shared_state* p) noexcept
-                {
-                    if (--p->reference_count == 0)
-                    {
-                        allocator_type other_alloc(p->alloc);
-                        std::allocator_traits<allocator_type>::destroy(
-                            other_alloc, p);
-                        std::allocator_traits<allocator_type>::deallocate(
-                            other_alloc, p, 1);
-                    }
-                }
-            };
-
-            struct shared_state_run_loop : shared_state
-            {
-                run_loop& loop;
-
-                // clang-format off
-                template <typename Sender_,
-                    HPX_CONCEPT_REQUIRES_(
-                        meta::value<meta::none_of<
-                            shared_state_run_loop, std::decay<Sender_>>>
-                    )>
-                // clang-format on
-                shared_state_run_loop(Sender_&& sender,
-                    typename shared_state::allocator_type const& alloc,
-                    run_loop& loop)
-                  : shared_state(HPX_FORWARD(Sender_, sender), alloc)
-                  , loop(loop)
-                {
-                }
-
-                ~shared_state_run_loop() override = default;
-
-                void set_predecessor_done() override
-                {
-                    shared_state::set_predecessor_done();
-                    loop.finish();
-                }
-            };
-
-            hpx::intrusive_ptr<shared_state> state;
-
-            template <typename Sender_, typename Scheduler_ = no_scheduler>
-            split_sender(Sender_&& sender, Allocator const& allocator,
-                Scheduler_&& scheduler = Scheduler_{})
-              : scheduler(HPX_FORWARD(Scheduler_, scheduler))
-            {
-                using allocator_type = Allocator;
-                using other_allocator = typename std::allocator_traits<
-                    allocator_type>::template rebind_alloc<shared_state>;
-                using allocator_traits = std::allocator_traits<other_allocator>;
-                using unique_ptr = std::unique_ptr<shared_state,
-                    util::allocator_deleter<other_allocator>>;
-
-                other_allocator alloc(allocator);
-                unique_ptr p(allocator_traits::allocate(alloc, 1),
-                    hpx::util::allocator_deleter<other_allocator>{alloc});
-
-                allocator_traits::construct(
-                    alloc, p.get(), HPX_FORWARD(Sender_, sender), allocator);
-                state = p.release();
-
-                // Eager submission means that we start the predecessor
-                // operation state already when creating the sender. We don't
-                // wait for another receiver to be connected.
-                if constexpr (Type == submission_type::eager)
-                {
-                    state->start();
-                }
-            }
-
-            template <typename Sender_>
-            split_sender(Sender_&& sender, Allocator const& allocator,
-                run_loop_scheduler const& sched)
-              : scheduler(sched)
-            {
-                using allocator_type = Allocator;
-                using other_allocator =
-                    typename std::allocator_traits<allocator_type>::
-                        template rebind_alloc<shared_state_run_loop>;
-                using allocator_traits = std::allocator_traits<other_allocator>;
-                using unique_ptr = std::unique_ptr<shared_state_run_loop,
-                    util::allocator_deleter<other_allocator>>;
-
-                other_allocator alloc(allocator);
-                unique_ptr p(allocator_traits::allocate(alloc, 1),
-                    hpx::util::allocator_deleter<other_allocator>{alloc});
-
-                allocator_traits::construct(alloc, p.get(),
-                    HPX_FORWARD(Sender_, sender), allocator,
-                    sched.get_run_loop());
-                state = p.release();
-
-                // Eager submission means that we start the predecessor
-                // operation state already when creating the sender. We don't
-                // wait for another receiver to be connected.
-                if constexpr (Type == submission_type::eager)
-                {
-                    state->start();
-                }
-            }
-
-            split_sender(split_sender const&) = default;
-            split_sender& operator=(split_sender const&) = default;
-            split_sender(split_sender&&) = default;
-            split_sender& operator=(split_sender&&) = default;
-
-            template <typename Receiver>
-            struct operation_state
-            {
-                HPX_NO_UNIQUE_ADDRESS std::decay_t<Receiver> receiver;
-                hpx::intrusive_ptr<shared_state> state;
-
-                template <typename Receiver_>
-                operation_state(Receiver_&& receiver,
-                    hpx::intrusive_ptr<shared_state> state)
-                  : receiver(HPX_FORWARD(Receiver_, receiver))
-                  , state(HPX_MOVE(state))
-                {
-                }
-
-                operation_state(operation_state&&) = delete;
-                operation_state& operator=(operation_state&&) = delete;
-                operation_state(operation_state const&) = delete;
-                operation_state& operator=(operation_state const&) = delete;
-
-                friend void tag_invoke(start_t, operation_state& os) noexcept
-                {
-                    // Lazy submission means that we wait to start the
-                    // predecessor operation state when a downstream operation
-                    // state is started, i.e. this start function is called.
-                    if constexpr (Type == submission_type::lazy)
-                    {
-                        os.state->start();
-                    }
-
-                    os.state->add_continuation(HPX_MOVE(os.receiver));
-                }
-            };
-
-            template <typename Receiver>
-            friend operation_state<Receiver> tag_invoke(
-                connect_t, split_sender&& s, Receiver&& receiver)
-            {
-                return {HPX_FORWARD(Receiver, receiver), HPX_MOVE(s.state)};
-            }
-
-            template <typename Receiver>
-            friend operation_state<Receiver> tag_invoke(
-                connect_t, split_sender& s, Receiver&& receiver)
-            {
-                return {HPX_FORWARD(Receiver, receiver), s.state};
-            }
-        };
-    }    // namespace detail
-
-    // execution::split is used to adapt an arbitrary sender into a sender that
-    // can be connected multiple times.
-    //
-    // If the provided sender is a multi-shot sender, returns that sender.
-    // Otherwise, returns a multi-shot sender which sends values equivalent to
-    // the values sent by the provided sender.
-    //
-    // A single-shot sender can only be connected to a receiver at most once.
-    // Its implementation of execution::connect only has overloads for an
-    // rvalue-qualified sender. Callers must pass the sender as an rvalue to the
-    // call to execution::connect, indicating that the call consumes the sender.
-    //
-    // A multi-shot sender can be connected to multiple receivers and can be
-    // launched multiple times. Multi-shot senders customise execution::connect
-    // to accept an lvalue reference to the sender. Callers can indicate that
-    // they want the sender to remain valid after the call to execution::connect
-    // by passing an lvalue reference to the sender to call these overloads.
-    // Multi-shot senders should also define overloads of execution::connect
-    // that accept rvalue-qualified senders to allow the sender to be also used
-    // in places where only a single-shot sender is required.
-    inline constexpr struct split_t final
-      : hpx::functional::detail::tag_priority<split_t>
-    {
-    private:
-        // clang-format off
-        template <typename Sender,
-            typename Allocator = hpx::util::internal_allocator<>,
-            HPX_CONCEPT_REQUIRES_(
-                is_sender_v<Sender> &&
-                hpx::traits::is_allocator_v<Allocator> &&
-                experimental::detail::is_completion_scheduler_tag_invocable_v<
-                    hpx::execution::experimental::set_value_t,
-                    Sender, split_t, Allocator
-                >
-            )>
-        // clang-format on
-        friend constexpr HPX_FORCEINLINE auto tag_override_invoke(
-            split_t, Sender&& sender, Allocator const& allocator = {})
-        {
-            auto scheduler =
-                hpx::execution::experimental::get_completion_scheduler<
-                    hpx::execution::experimental::set_value_t>(sender);
-
-            return hpx::functional::tag_invoke(split_t{}, HPX_MOVE(scheduler),
-                HPX_FORWARD(Sender, sender), allocator);
-        }
-
-        // clang-format off
-        template <typename Sender,
-            typename Allocator = hpx::util::internal_allocator<>,
-            HPX_CONCEPT_REQUIRES_(
-                hpx::execution::experimental::is_sender_v<Sender> &&
-                hpx::traits::is_allocator_v<Allocator>
-            )>
-        // clang-format on
-        friend constexpr HPX_FORCEINLINE auto tag_invoke(split_t,
-            hpx::execution::experimental::run_loop_scheduler const& sched,
-            Sender&& sender, Allocator const& allocator = {})
-        {
-            return detail::split_sender<Sender, Allocator,
-                detail::submission_type::lazy,
-                hpx::execution::experimental::run_loop_scheduler>{
-                HPX_FORWARD(Sender, sender), allocator, sched};
-        }
-
-        // clang-format off
-        template <typename Sender,
-            typename Allocator = hpx::util::internal_allocator<>,
-            HPX_CONCEPT_REQUIRES_(
-                hpx::execution::experimental::is_sender_v<Sender> &&
-                hpx::traits::is_allocator_v<Allocator>
-            )>
-        // clang-format on
-        friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(
-            split_t, Sender&& sender, Allocator const& allocator = {})
-        {
-            return detail::split_sender<Sender, Allocator,
-                detail::submission_type::lazy>{
-                HPX_FORWARD(Sender, sender), allocator};
-        }
-
-        template <typename Sender, typename Allocator>
-        friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(split_t,
-            detail::split_sender<Sender, Allocator,
-                detail::submission_type::lazy>
-                sender,
-            Allocator const& = {})
-        {
-            return sender;
-        }
-
-        // clang-format off
-        template <typename Scheduler, typename Allocator,
-            HPX_CONCEPT_REQUIRES_(
-                hpx::execution::experimental::is_scheduler_v<Scheduler> &&
-                hpx::traits::is_allocator_v<Allocator>
-            )>
-        // clang-format on
-        friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(
-            split_t, Scheduler&& scheduler, Allocator const& allocator = {})
-        {
-            return hpx::execution::experimental::detail::inject_scheduler<
-                split_t, Scheduler, Allocator>{
-                HPX_FORWARD(Scheduler, scheduler), allocator};
-        }
-
-        // clang-format off
-        template <typename Allocator = hpx::util::internal_allocator<>,
-            HPX_CONCEPT_REQUIRES_(
-                hpx::traits::is_allocator_v<Allocator>
-            )>
-        // clang-format on
-        friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(
-            split_t, Allocator const& allocator = {})
-        {
-            return detail::partial_algorithm<split_t, Allocator>{allocator};
-        }
-    } split{};
-}    // namespace hpx::execution::experimental
-
-#endif
diff --git a/libs/core/execution/include/hpx/execution/algorithms/start_detached.hpp b/libs/core/execution/include/hpx/execution/algorithms/start_detached.hpp
index 681a091fbc97..2770d6a935bc 100644
--- a/libs/core/execution/include/hpx/execution/algorithms/start_detached.hpp
+++ b/libs/core/execution/include/hpx/execution/algorithms/start_detached.hpp
@@ -9,294 +9,4 @@
 
 #include <hpx/config.hpp>
 
-#if defined(HPX_HAVE_STDEXEC)
 #include <hpx/execution_base/stdexec_forward.hpp>
-#else
-
-#include <hpx/allocator_support/allocator_deleter.hpp>
-#include <hpx/allocator_support/internal_allocator.hpp>
-#include <hpx/allocator_support/traits/is_allocator.hpp>
-#include <hpx/assert.hpp>
-#include <hpx/concepts/concepts.hpp>
-#include <hpx/execution/algorithms/detail/inject_scheduler.hpp>
-#include <hpx/execution/algorithms/detail/partial_algorithm.hpp>
-#include <hpx/execution/algorithms/run_loop.hpp>
-#include <hpx/execution_base/completion_scheduler.hpp>
-#include <hpx/execution_base/completion_signatures.hpp>
-#include <hpx/execution_base/operation_state.hpp>
-#include <hpx/execution_base/receiver.hpp>
-#include <hpx/execution_base/sender.hpp>
-#include <hpx/functional/detail/tag_priority_invoke.hpp>
-#include <hpx/functional/invoke_result.hpp>
-#include <hpx/modules/memory.hpp>
-#include <hpx/thread_support/atomic_count.hpp>
-#include <hpx/type_support/meta.hpp>
-#include <hpx/type_support/unused.hpp>
-
-#include <atomic>
-#include <cstddef>
-#include <exception>
-#include <memory>
-#include <type_traits>
-#include <utility>
-
-namespace hpx::execution::experimental {
-
-    namespace detail {
-
-        template <typename Derived, typename Sender, typename Allocator>
-        struct operation_state_holder_base
-        {
-            struct start_detached_receiver
-            {
-                hpx::intrusive_ptr<Derived> op_state;
-
-                template <typename Error>
-                [[noreturn]] friend void tag_invoke(
-                    set_error_t, start_detached_receiver&&, Error&&) noexcept
-                {
-                    HPX_ASSERT_MSG(false,
-                        "set_error was called on the receiver of "
-                        "start_detached, terminating. If you want to allow "
-                        "errors from the predecessor sender, handle them first "
-                        "with e.g. let_error.");
-                    std::terminate();
-                }
-
-                friend void tag_invoke(
-                    set_stopped_t, start_detached_receiver&& r) noexcept
-                {
-                    r.op_state->finish();
-                    r.op_state.reset();
-                };
-
-                template <typename... Ts>
-                friend void tag_invoke(
-                    set_value_t, start_detached_receiver&& r, Ts&&...) noexcept
-                {
-                    r.op_state->finish();
-                    r.op_state.reset();
-                }
-            };
-
-        protected:
-            using allocator_type = typename std::allocator_traits<
-                Allocator>::template rebind_alloc<Derived>;
-
-        private:
-            HPX_NO_UNIQUE_ADDRESS allocator_type alloc;
-            hpx::util::atomic_count count{0};
-
-            using operation_state_type =
-                connect_result_t<Sender, start_detached_receiver>;
-            std::decay_t<operation_state_type> op_state;
-
-        public:
-            template <typename Sender_>
-            explicit operation_state_holder_base(
-                Sender_&& sender, allocator_type const& alloc)
-              : alloc(alloc)
-              , op_state(connect(HPX_FORWARD(Sender_, sender),
-                    start_detached_receiver{static_cast<Derived*>(this)}))
-            {
-                hpx::execution::experimental::start(op_state);
-            }
-
-        private:
-            friend void intrusive_ptr_add_ref(
-                operation_state_holder_base* p) noexcept
-            {
-                ++p->count;
-            }
-
-            friend void intrusive_ptr_release(
-                operation_state_holder_base* p) noexcept
-            {
-                if (--p->count == 0)
-                {
-                    allocator_type other_alloc(p->alloc);
-                    std::allocator_traits<allocator_type>::destroy(
-                        other_alloc, static_cast<Derived*>(p));
-                    std::allocator_traits<allocator_type>::deallocate(
-                        other_alloc, static_cast<Derived*>(p), 1);
-                }
-            }
-        };
-
-        template <typename Sender, typename Allocator>
-        struct operation_state_holder
-          : operation_state_holder_base<
-                operation_state_holder<Sender, Allocator>, Sender, Allocator>
-        {
-            using base_type = operation_state_holder_base<
-                operation_state_holder<Sender, Allocator>, Sender, Allocator>;
-            using allocator_type = typename base_type::allocator_type;
-
-            template <typename Sender_>
-            explicit operation_state_holder(
-                Sender_&& sender, allocator_type const& alloc)
-              : base_type(HPX_FORWARD(Sender_, sender), alloc)
-            {
-            }
-
-            static constexpr void finish() noexcept {}
-        };
-
-        template <typename Sender, typename Allocator>
-        struct operation_state_holder_with_run_loop
-          : operation_state_holder_base<
-                operation_state_holder_with_run_loop<Sender, Allocator>, Sender,
-                Allocator>
-        {
-        private:
-            hpx::execution::experimental::run_loop& loop;
-
-            using base_type = operation_state_holder_base<
-                operation_state_holder_with_run_loop<Sender, Allocator>, Sender,
-                Allocator>;
-
-        public:
-            template <typename Sender_, typename Allocator_>
-            explicit operation_state_holder_with_run_loop(
-                hpx::execution::experimental::run_loop_scheduler const& sched,
-                Sender_&& sender, Allocator_ const& alloc)
-              : base_type(HPX_FORWARD(Sender_, sender), alloc)
-              , loop(sched.get_run_loop())
-            {
-                // keep ourselves alive
-                hpx::intrusive_ptr<operation_state_holder_with_run_loop> this_(
-                    this);
-                loop.run();
-            }
-
-            void finish() noexcept
-            {
-                loop.finish();
-            }
-        };
-    }    // namespace detail
-
-    // execution::start_detached is used to eagerly start a sender without the
-    // caller needing to manage the lifetimes of any objects.
-    //
-    // Like ensure_started, but does not return a value; if the provided sender
-    // sends an error instead of a value, std::terminate is called.
-    inline constexpr struct start_detached_t final
-      : hpx::functional::detail::tag_priority<start_detached_t>
-    {
-    private:
-        // clang-format off
-        template <typename Sender,
-            typename Allocator = hpx::util::internal_allocator<>,
-            HPX_CONCEPT_REQUIRES_(
-                is_sender_v<Sender> &&
-                hpx::traits::is_allocator_v<Allocator> &&
-                experimental::detail::is_completion_scheduler_tag_invocable_v<
-                    hpx::execution::experimental::set_value_t,
-                    start_detached_t, Sender, Allocator
-                >
-            )>
-        // clang-format on
-        friend constexpr HPX_FORCEINLINE auto tag_override_invoke(
-            start_detached_t, Sender&& sender,
-            Allocator const& allocator = Allocator{})
-        {
-            auto scheduler = get_completion_scheduler<
-                hpx::execution::experimental::set_value_t>(sender);
-
-            return hpx::functional::tag_invoke(start_detached_t{},
-                HPX_MOVE(scheduler), HPX_FORWARD(Sender, sender), allocator);
-        }
-
-        // clang-format off
-        template <typename Sender,
-            typename Allocator = hpx::util::internal_allocator<>,
-            HPX_CONCEPT_REQUIRES_(
-                hpx::execution::experimental::is_sender_v<Sender> &&
-                hpx::traits::is_allocator_v<Allocator>
-            )>
-        // clang-format on
-        friend constexpr HPX_FORCEINLINE auto tag_invoke(start_detached_t,
-            hpx::execution::experimental::run_loop_scheduler const& sched,
-            Sender&& sender, Allocator const& allocator = {})
-        {
-            using allocator_type = Allocator;
-            using operation_state_type =
-                detail::operation_state_holder_with_run_loop<Sender, Allocator>;
-            using other_allocator = typename std::allocator_traits<
-                allocator_type>::template rebind_alloc<operation_state_type>;
-            using allocator_traits = std::allocator_traits<other_allocator>;
-            using unique_ptr = std::unique_ptr<operation_state_type,
-                util::allocator_deleter<other_allocator>>;
-
-            other_allocator alloc(allocator);
-            unique_ptr p(allocator_traits::allocate(alloc, 1),
-                hpx::util::allocator_deleter<other_allocator>{alloc});
-
-            allocator_traits::construct(
-                alloc, p.get(), sched, HPX_FORWARD(Sender, sender), alloc);
-            HPX_UNUSED(p.release());
-        }
-
-        // clang-format off
-        template <typename Sender,
-            typename Allocator = hpx::util::internal_allocator<>,
-            HPX_CONCEPT_REQUIRES_(
-                is_sender_v<Sender> &&
-                hpx::traits::is_allocator_v<Allocator>
-            )>
-        // clang-format on
-        friend constexpr HPX_FORCEINLINE void tag_fallback_invoke(
-            start_detached_t, Sender&& sender,
-            Allocator const& allocator = Allocator{})
-        {
-            using allocator_type = Allocator;
-            using operation_state_type =
-                detail::operation_state_holder<Sender, Allocator>;
-            using other_allocator = typename std::allocator_traits<
-                allocator_type>::template rebind_alloc<operation_state_type>;
-            using allocator_traits = std::allocator_traits<other_allocator>;
-            using unique_ptr = std::unique_ptr<operation_state_type,
-                util::allocator_deleter<other_allocator>>;
-
-            other_allocator alloc(allocator);
-            unique_ptr p(allocator_traits::allocate(alloc, 1),
-                hpx::util::allocator_deleter<other_allocator>{alloc});
-
-            allocator_traits::construct(
-                alloc, p.get(), HPX_FORWARD(Sender, sender), alloc);
-            HPX_UNUSED(p.release());
-        }
-
-        // clang-format off
-        template <typename Scheduler, typename Allocator,
-            HPX_CONCEPT_REQUIRES_(
-                hpx::execution::experimental::is_scheduler_v<Scheduler> &&
-                hpx::traits::is_allocator_v<Allocator>
-            )>
-        // clang-format on
-        friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(
-            start_detached_t, Scheduler&& scheduler,
-            Allocator const& allocator = {})
-        {
-            return hpx::execution::experimental::detail::inject_scheduler<
-                start_detached_t, Scheduler, Allocator>{
-                HPX_FORWARD(Scheduler, scheduler), allocator};
-        }
-
-        // clang-format off
-        template <typename Allocator = hpx::util::internal_allocator<>,
-            HPX_CONCEPT_REQUIRES_(
-                hpx::traits::is_allocator_v<Allocator>
-            )>
-        // clang-format on
-        friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(
-            start_detached_t, Allocator const& allocator = Allocator{})
-        {
-            return detail::partial_algorithm<start_detached_t, Allocator>{
-                allocator};
-        }
-    } start_detached{};
-}    // namespace hpx::execution::experimental
-
-#endif
diff --git a/libs/core/execution/include/hpx/execution/algorithms/sync_wait.hpp b/libs/core/execution/include/hpx/execution/algorithms/sync_wait.hpp
index ee98807d718b..6ecb56340926 100644
--- a/libs/core/execution/include/hpx/execution/algorithms/sync_wait.hpp
+++ b/libs/core/execution/include/hpx/execution/algorithms/sync_wait.hpp
@@ -10,7 +10,6 @@
 
 #include <hpx/config.hpp>
 
-#if defined(HPX_HAVE_STDEXEC)
 #include <hpx/execution_base/stdexec_forward.hpp>
 
 namespace hpx::this_thread::experimental {
@@ -20,579 +19,3 @@ namespace hpx::this_thread::experimental {
     using hpx::execution::experimental::sync_wait_with_variant;
     using hpx::execution::experimental::sync_wait_with_variant_t;
 }    // namespace hpx::this_thread::experimental
-#else
-
-#include <hpx/assert.hpp>
-#include <hpx/concepts/concepts.hpp>
-#include <hpx/datastructures/optional.hpp>
-#include <hpx/datastructures/tuple.hpp>
-#include <hpx/datastructures/variant.hpp>
-#include <hpx/execution/algorithms/detail/inject_scheduler.hpp>
-#include <hpx/execution/algorithms/detail/partial_algorithm.hpp>
-#include <hpx/execution/algorithms/detail/single_result.hpp>
-#include <hpx/execution/algorithms/run_loop.hpp>
-#include <hpx/execution/queries/get_delegatee_scheduler.hpp>
-#include <hpx/execution/queries/get_scheduler.hpp>
-#include <hpx/execution_base/completion_signatures.hpp>
-#include <hpx/execution_base/operation_state.hpp>
-#include <hpx/execution_base/receiver.hpp>
-#include <hpx/execution_base/sender.hpp>
-#include <hpx/functional/detail/tag_priority_invoke.hpp>
-#include <hpx/type_support/meta.hpp>
-#include <hpx/type_support/pack.hpp>
-#include <hpx/type_support/unused.hpp>
-
-#include <atomic>
-#include <exception>
-#include <mutex>
-#include <system_error>
-#include <type_traits>
-#include <utility>
-
-namespace hpx::execution::experimental::detail {
-
-    enum class sync_wait_type
-    {
-        single,
-        variant
-    };
-
-    struct sync_wait_error_visitor
-    {
-        void operator()(std::exception_ptr ep) const
-        {
-            std::rethrow_exception(HPX_MOVE(ep));
-        }
-
-        template <typename Error>
-        void operator()(Error& error) const
-        {
-            throw error;
-        }
-    };
-
-    struct sync_wait_receiver_env
-    {
-        using type = sync_wait_receiver_env;
-        using id = sync_wait_receiver_env;
-
-        using scheduler_type =
-            decltype(std::declval<run_loop>().get_scheduler());
-
-        scheduler_type sched;
-
-        friend auto tag_invoke(hpx::execution::experimental::get_scheduler_t,
-            sync_wait_receiver_env const& env) noexcept -> scheduler_type
-        {
-            return env.sched;
-        }
-
-        friend auto tag_invoke(
-            hpx::execution::experimental::get_delegatee_scheduler_t,
-            sync_wait_receiver_env const& env) noexcept -> scheduler_type
-        {
-            return env.sched;
-        }
-    };
-
-    template <typename Pack>
-    struct make_decayed_pack;
-
-    template <template <typename...> typename Pack, typename... Ts>
-    struct make_decayed_pack<Pack<Ts...>>
-    {
-        using type = Pack<std::decay_t<Ts>...>;
-    };
-
-    template <typename Pack>
-    using make_decayed_pack_t = typename make_decayed_pack<Pack>::type;
-
-    ///////////////////////////////////////////////////////////////////////////
-    template <sync_wait_type Type, typename T>
-    struct select_result;
-
-    template <typename T>
-    struct select_result<sync_wait_type::single, T>
-    {
-        using type = hpx::variant<make_decayed_pack_t<single_variant_t<T>>>;
-    };
-
-    template <typename T>
-    struct select_result<sync_wait_type::variant, T>
-    {
-        using type = T;
-    };
-
-    template <sync_wait_type Type, typename T>
-    using select_result_t = typename select_result<Type, T>::type;
-
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename Sender, sync_wait_type Type>
-    struct sync_wait_receiver
-    {
-        struct type
-        {
-            using id = sync_wait_receiver;
-
-            // value and error_types of the predecessor sender
-            template <template <typename...> class Tuple,
-                template <typename...> class Variant>
-            using predecessor_value_types = value_types_of_t<Sender,
-                sync_wait_receiver_env, Tuple, Variant>;
-
-            template <template <typename...> class Variant>
-            using predecessor_error_types =
-                error_types_of_t<Sender, sync_wait_receiver_env, Variant>;
-
-            // forcing static_assert ensuring variant has exactly one tuple
-            //
-            // FIXME: using make_decayed_pack is a workaround for the impedance
-            // mismatch between the different techniques we use for calculating
-            // value_types for a sender. In particular, split() explicitly adds a
-            // const& to all tuple members in a way that prevent simply passing
-            // decayed_tuple to predecessor_value_types.
-
-            // The template should compute the result type of whatever returned from
-            // sync_wait or sync_wait_with_variant by checking sync_wait_type is
-            // single or variant
-            using result_type = select_result_t<Type,
-                predecessor_value_types<hpx::tuple, hpx::variant>>;
-
-            // The type of errors to store in the variant. This in itself is a
-            // variant.
-            using error_type =
-                hpx::util::detail::unique_t<hpx::util::detail::prepend_t<
-                    predecessor_error_types<hpx::variant>, std::exception_ptr>>;
-
-            using stopped_type = hpx::execution::experimental::set_stopped_t;
-
-            struct shared_state
-            {
-                hpx::variant<hpx::monostate, error_type, result_type,
-                    stopped_type>
-                    value;
-
-                auto get_value()
-                {
-                    if (hpx::holds_alternative<result_type>(value))
-                    {
-                        // pull the tuple out of the variant and wrap it into an
-                        // optional, make sure to remove the references
-                        if constexpr (Type == sync_wait_type::single)
-                        {
-                            using single_result_type = make_decayed_pack_t<
-                                single_variant_t<predecessor_value_types<
-                                    hpx::tuple, meta::pack>>>;
-
-                            return hpx::optional<single_result_type>(
-                                hpx::get<0>(
-                                    hpx::get<result_type>(HPX_MOVE(value))));
-                        }
-                        else
-                        {
-                            return hpx::optional(
-                                hpx::get<result_type>(HPX_MOVE(value)));
-                        }
-                    }
-                    else if (hpx::holds_alternative<error_type>(value))
-                    {
-                        hpx::visit(sync_wait_error_visitor{},
-                            hpx::get<error_type>(value));
-                        HPX_UNREACHABLE;
-                    }
-
-                    // Something went very wrong if this assert fired. Essentially
-                    // this means that none of set_value/set_error/set_stopped was
-                    // called.
-                    HPX_ASSERT(hpx::holds_alternative<stopped_type>(value));
-
-                    if constexpr (Type == sync_wait_type::single)
-                    {
-                        using single_result_type = make_decayed_pack_t<
-                            single_variant_t<predecessor_value_types<hpx::tuple,
-                                meta::pack>>>;
-                        return hpx::optional<single_result_type>();
-                    }
-                    else
-                    {
-                        return hpx::optional<result_type>();
-                    }
-                }
-            };
-
-            shared_state& state;
-            run_loop& loop;
-
-            template <typename Error>
-            friend void tag_invoke(
-                set_error_t, type&& r, Error&& error) noexcept
-            {
-                using error_t = std::decay_t<Error>;
-
-                if constexpr (std::is_same_v<error_t, std::exception_ptr>)
-                {
-                    r.state.value.template emplace<error_type>(
-                        HPX_FORWARD(Error, error));
-                }
-                else if constexpr (std::is_same_v<error_t, std::error_code>)
-                {
-                    r.state.value.template emplace<error_type>(
-                        std::exception_ptr(std::system_error(error)));
-                }
-                else
-                {
-                    try
-                    {
-                        throw error;
-                    }
-                    catch (...)
-                    {
-                        r.state.value.template emplace<error_type>(
-                            std::current_exception());
-                    }
-                }
-
-                r.loop.finish();
-            }
-
-            friend void tag_invoke(set_stopped_t tag, type&& r) noexcept
-            {
-                r.state.value.template emplace<stopped_type>(tag);
-                r.loop.finish();
-            }
-
-            template <typename... Us>
-            friend void tag_invoke(set_value_t, type&& r, Us&&... us) noexcept
-            {
-                r.state.value.template emplace<result_type>(
-                    hpx::forward_as_tuple(HPX_FORWARD(Us, us)...));
-                r.loop.finish();
-            }
-
-            friend sync_wait_receiver_env tag_invoke(
-                hpx::execution::experimental::get_env_t, type const& r) noexcept
-            {
-                return {r.loop.get_scheduler()};
-            }
-        };
-    };
-}    // namespace hpx::execution::experimental::detail
-
-namespace hpx::this_thread::experimental {
-
-    // this_thread::sync_wait is a sender consumer that submits the work
-    // described by the provided sender for execution, similarly to
-    // ensure_started, except that it blocks the current std::thread or thread
-    // of main until the work is completed, and returns an optional tuple of
-    // values that were sent by the provided sender on its completion of work.
-    // Where 4.20.1 execution::schedule and 4.20.3 execution::transfer_just are
-    // meant to enter the domain of senders, sync_wait is meant to exit the
-    // domain of senders, retrieving the result of the task graph.
-    //
-    // If the provided sender sends an error instead of values, sync_wait throws
-    // that error as an exception, or rethrows the original exception if the
-    // error is of type std::exception_ptr.
-    //
-    // If the provided sender sends the "stopped" signal instead of values,
-    // sync_wait returns an empty optional.
-    //
-    // For an explanation of the requires clause, see 5.8 All senders are typed.
-    // That clause also explains another sender consumer, built on top of
-    // sync_wait: sync_wait_with_variant.
-    //
-    // Note: This function is specified inside hpx::this_thread::experimental,
-    // and not inside hpx::execution::experimental. This is because sync_wait
-    // has to block the current execution agent, but determining what the
-    // current execution agent is is not reliable. Since the standard does not
-    // specify any functions on the current execution agent other than those in
-    // std::this_thread, this is the flavor of this function that is being
-    // proposed.
-
-    // this_thread::sync_wait and this_thread::sync_wait_with_variant are used
-    // to block a current thread until a sender passed into it as an argument
-    // has completed, and to obtain the values (if any) it completed with.
-    //
-    // For any receiver r created by an implementation of sync_wait and
-    // sync_wait_with_variant, the expressions get_scheduler(get_env(r)) and
-    // get_delegatee_scheduler(get_env(r)) shall be well-formed. For a receiver
-    // created by the default implementation of this_thread::sync_wait, these
-    // expressions shall return a scheduler to the same thread-safe,
-    // first-in-first-out queue of work such that tasks scheduled to the queue
-    // execute on the thread of the caller of sync_wait. [Note: The scheduler
-    // for an instance of execution::run_loop that is a local variable within
-    // sync_wait is one valid implementation. -- end note]
-    //
-    // The templates sync-wait-type and sync-wait-with-variant-type are used to
-    // determine the return types of this_thread::sync_wait and
-    // this_thread::sync_wait_with_variant. Let sync-wait-env be the type of the
-    // expression get_env(r) where r is an instance of the receiver created by
-    // the default implementation of sync_wait. Then:
-    //
-    // template<sender<sync-wait-env> S> using sync-wait-type =
-    //  optional<execution::value_types_of_t< S, sync-wait-env, decayed-tuple,
-    //  type_identity_t>>;
-    //
-    //  template<sender<sync-wait-env> S> using sync-wait-with-variant-type =
-    //  optional<execution::into-variant-type<S, sync-wait-env>>;
-    //
-    // The name this_thread::sync_wait denotes a customization point object. For
-    // some subexpression s, let S be decltype((s)). If execution::sender<S,
-    // sync-wait-env> is false, or the number of the arguments
-    // completion_signatures_of_t<S, sync-wait-env>::value_types passed into the
-    // Variant template parameter is not 1, this_thread::sync_wait is
-    // ill-formed. Otherwise, this_thread::sync_wait is expression-equivalent
-    // to:
-    //
-    // 1. tag_invoke(this_thread::sync_wait,
-    //          execution::get_completion_scheduler< execution::set_value_t>(s),
-    //          s), if this expression is valid.
-    //
-    //      - Mandates: The type of the tag_invoke expression above is
-    //                  sync-wait-type<S, sync-wait-env>.
-    //
-    // 2. Otherwise, tag_invoke(this_thread::sync_wait, s), if this expression
-    //    is valid and its type is.
-    //
-    //      - Mandates: The type of the tag_invoke expression above is
-    //                  sync-wait-type<S, sync-wait-env>.
-    //
-    // 3. Otherwise:
-    //
-    //      1. Constructs a receiver r.
-    //
-    //      2. Calls execution::connect(s, r), resulting in an operation state
-    //         op_state, then calls execution::start(op_state).
-    //
-    //      3. Blocks the current thread until a receiver completion-signal of r
-    //         is called. When it is:
-    //
-    //          1. If execution::set_value(r, ts...) has been called, returns
-    //              sync-wait-type<S, sync-wait-env>{
-    //                  decayed-tuple<decltype(ts)...>{ts...}}.
-    //              If that expression exits exceptionally, the exception is
-    //              propagated to the caller of sync_wait.
-    //
-    //          2. If execution::set_error(r, e) has been called, let E be the
-    //             decayed type of e. If E is exception_ptr, calls
-    //             std::rethrow_exception(e). Otherwise, if the E is error_code,
-    //             throws system_error(e). Otherwise, throws e.
-    //
-    //          3. If execution::set_stopped(r) has been called, returns
-    //             sync-wait-type<S, sync-wait-env>{}.
-    //
-    inline constexpr struct sync_wait_t final
-      : hpx::functional::detail::tag_priority<sync_wait_t>
-    {
-    private:
-        // clang-format off
-        template <typename Sender,
-            HPX_CONCEPT_REQUIRES_(
-                hpx::execution::experimental::is_sender_v<Sender,
-                    hpx::execution::experimental::detail::sync_wait_receiver_env> &&
-                hpx::execution::experimental::detail::
-                    is_completion_scheduler_tag_invocable_v<
-                        hpx::execution::experimental::set_value_t,
-                        Sender, sync_wait_t
-                    >
-            )>
-        // clang-format on
-        friend constexpr HPX_FORCEINLINE auto tag_override_invoke(
-            sync_wait_t, Sender&& sender)
-        {
-            auto scheduler =
-                hpx::execution::experimental::get_completion_scheduler<
-                    hpx::execution::experimental::set_value_t>(sender);
-
-            return hpx::functional::tag_invoke(sync_wait_t{},
-                HPX_MOVE(scheduler), HPX_FORWARD(Sender, sender));
-        }
-
-        // clang-format off
-        template <typename Sender,
-            HPX_CONCEPT_REQUIRES_(
-                hpx::execution::experimental::is_sender_v<Sender,
-                    hpx::execution::experimental::detail::sync_wait_receiver_env>
-            )>
-        // clang-format on
-        friend auto tag_invoke(sync_wait_t,
-            hpx::execution::experimental::run_loop_scheduler const& sched,
-            Sender&& sender)
-        {
-            using hpx::execution::experimental::detail::sync_wait_type;
-            using receiver_type = hpx::meta::type<hpx::execution::experimental::
-                    detail::sync_wait_receiver<Sender, sync_wait_type::single>>;
-            using state_type = typename receiver_type::shared_state;
-
-            hpx::execution::experimental::run_loop& loop = sched.get_run_loop();
-            state_type state{};
-            auto op_state = hpx::execution::experimental::connect(
-                HPX_FORWARD(Sender, sender), receiver_type{state, loop});
-            hpx::execution::experimental::start(op_state);
-
-            // Wait for the variant to be filled in.
-            loop.run();
-
-            return state.get_value();
-        }
-
-        // clang-format off
-        template <typename Sender,
-            HPX_CONCEPT_REQUIRES_(
-                hpx::execution::experimental::is_sender_v<Sender,
-                    hpx::execution::experimental::detail::sync_wait_receiver_env>
-            )>
-        // clang-format on
-        friend HPX_FORCEINLINE auto tag_fallback_invoke(
-            sync_wait_t, Sender&& sender)
-        {
-            using hpx::execution::experimental::detail::sync_wait_type;
-            using receiver_type = hpx::meta::type<hpx::execution::experimental::
-                    detail::sync_wait_receiver<Sender, sync_wait_type::single>>;
-            using state_type = typename receiver_type::shared_state;
-
-            hpx::execution::experimental::run_loop loop{};
-            state_type state{};
-            auto op_state = hpx::execution::experimental::connect(
-                HPX_FORWARD(Sender, sender), receiver_type{state, loop});
-            hpx::execution::experimental::start(op_state);
-
-            // Wait for the variant to be filled in.
-            loop.run();
-
-            return state.get_value();
-        }
-
-        // clang-format off
-        template <typename Scheduler,
-            HPX_CONCEPT_REQUIRES_(
-                hpx::execution::experimental::is_scheduler_v<Scheduler>
-            )>
-        // clang-format on
-        friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(
-            sync_wait_t, Scheduler&& scheduler)
-        {
-            return hpx::execution::experimental::detail::inject_scheduler<
-                sync_wait_t, Scheduler>{HPX_FORWARD(Scheduler, scheduler)};
-        }
-
-        friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(sync_wait_t)
-        {
-            return hpx::execution::experimental::detail::partial_algorithm<
-                sync_wait_t>{};
-        }
-    } sync_wait{};
-
-    ////////////////////////////////////////////////////////////////////
-    // CPO for sync_wait_with_variant
-
-    // this_thread::sync_wait_with_variant is a sender consumer that submits
-    // the work described by the provided sender for execution, similarly to
-    // ensure_started, except that it blocks the current std::thread or
-    // thread of main until the work is completed, and returns an optional
-    // of variant of tuples that were sent by the provided sender on its
-    // completion of work.
-    inline constexpr struct sync_wait_with_variant_t final
-      : hpx::functional::detail::tag_priority<sync_wait_with_variant_t>
-    {
-    private:
-        // clang-format off
-        template <typename Sender,
-            HPX_CONCEPT_REQUIRES_(
-                hpx::execution::experimental::is_sender_v<Sender> &&
-                hpx::execution::experimental::detail::
-                    is_completion_scheduler_tag_invocable_v<
-                        hpx::execution::experimental::set_value_t,
-                        Sender, sync_wait_with_variant_t
-                    >
-            )>
-        // clang-format on
-        friend constexpr HPX_FORCEINLINE auto tag_override_invoke(
-            sync_wait_with_variant_t, Sender&& sender)
-        {
-            auto scheduler =
-                hpx::execution::experimental::get_completion_scheduler<
-                    hpx::execution::experimental::set_value_t>(sender);
-
-            return hpx::functional::tag_invoke(sync_wait_with_variant_t{},
-                HPX_MOVE(scheduler), HPX_FORWARD(Sender, sender));
-        }
-
-        // clang-format off
-        template <typename Sender,
-            HPX_CONCEPT_REQUIRES_(
-                hpx::execution::experimental::is_sender_v<Sender>
-            )>
-        // clang-format on
-        friend auto tag_invoke(sync_wait_with_variant_t,
-            hpx::execution::experimental::run_loop_scheduler const& sched,
-            Sender&& sender)
-        {
-            using hpx::execution::experimental::detail::sync_wait_type;
-            using receiver_type =
-                hpx::meta::type<hpx::execution::experimental::detail::
-                        sync_wait_receiver<Sender, sync_wait_type::variant>>;
-            using state_type = typename receiver_type::shared_state;
-
-            hpx::execution::experimental::run_loop& loop = sched.get_run_loop();
-            state_type state{};
-            auto op_state = hpx::execution::experimental::connect(
-                HPX_FORWARD(Sender, sender), receiver_type{state, loop});
-            hpx::execution::experimental::start(op_state);
-
-            // Wait for the variant to be filled in.
-            loop.run();
-
-            return state.get_value();
-        }
-
-        // clang-format off
-        template <typename Sender,
-            HPX_CONCEPT_REQUIRES_(
-                hpx::execution::experimental::is_sender_v<Sender>
-            )>
-        // clang-format on
-        friend HPX_FORCEINLINE auto tag_fallback_invoke(
-            sync_wait_with_variant_t, Sender&& sender)
-        {
-            using hpx::execution::experimental::detail::sync_wait_type;
-            using receiver_type =
-                hpx::meta::type<hpx::execution::experimental::detail::
-                        sync_wait_receiver<Sender, sync_wait_type::variant>>;
-            using state_type = typename receiver_type::shared_state;
-
-            hpx::execution::experimental::run_loop loop{};
-            state_type state{};
-            auto op_state = hpx::execution::experimental::connect(
-                HPX_FORWARD(Sender, sender), receiver_type{state, loop});
-            hpx::execution::experimental::start(op_state);
-
-            // Wait for the variant to be filled in.
-            loop.run();
-
-            return state.get_value();
-        }
-
-        // clang-format off
-        template <typename Scheduler,
-            HPX_CONCEPT_REQUIRES_(
-                hpx::execution::experimental::is_scheduler_v<Scheduler>
-            )>
-        // clang-format on
-        friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(
-            sync_wait_with_variant_t, Scheduler&& scheduler)
-        {
-            return hpx::execution::experimental::detail::inject_scheduler<
-                sync_wait_with_variant_t, Scheduler>{
-                HPX_FORWARD(Scheduler, scheduler)};
-        }
-
-        friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(
-            sync_wait_with_variant_t)
-        {
-            return hpx::execution::experimental::detail::partial_algorithm<
-                sync_wait_with_variant_t>{};
-        }
-    } sync_wait_with_variant{};
-}    // namespace hpx::this_thread::experimental
-
-#endif
diff --git a/libs/core/execution/include/hpx/execution/algorithms/then.hpp b/libs/core/execution/include/hpx/execution/algorithms/then.hpp
index ae68e39f340c..87f7ecfcb500 100644
--- a/libs/core/execution/include/hpx/execution/algorithms/then.hpp
+++ b/libs/core/execution/include/hpx/execution/algorithms/then.hpp
@@ -8,243 +8,4 @@
 #pragma once
 
 #include <hpx/config.hpp>
-#if defined(HPX_HAVE_STDEXEC)
 #include <hpx/execution_base/stdexec_forward.hpp>
-#else
-
-#include <hpx/concepts/concepts.hpp>
-#include <hpx/errors/try_catch_exception_ptr.hpp>
-#include <hpx/execution/algorithms/detail/partial_algorithm.hpp>
-#include <hpx/execution_base/completion_scheduler.hpp>
-#include <hpx/execution_base/completion_signatures.hpp>
-#include <hpx/execution_base/receiver.hpp>
-#include <hpx/execution_base/sender.hpp>
-#include <hpx/functional/detail/tag_priority_invoke.hpp>
-#include <hpx/futures/future.hpp>
-#include <hpx/type_support/meta.hpp>
-#include <hpx/type_support/pack.hpp>
-
-#include <exception>
-#include <type_traits>
-#include <utility>
-
-namespace hpx::execution::experimental {
-
-    namespace detail {
-
-#if defined(HPX_GCC_VERSION) && HPX_GCC_VERSION >= 110000
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Warray-bounds"
-#endif
-        template <typename Receiver, typename F>
-        struct then_receiver
-        {
-            HPX_NO_UNIQUE_ADDRESS std::decay_t<Receiver> receiver;
-            HPX_NO_UNIQUE_ADDRESS std::decay_t<F> f;
-
-            template <typename Error>
-            friend void tag_invoke(
-                set_error_t, then_receiver&& r, Error&& error) noexcept
-            {
-                hpx::execution::experimental::set_error(
-                    HPX_MOVE(r.receiver), HPX_FORWARD(Error, error));
-            }
-
-            friend void tag_invoke(set_stopped_t, then_receiver&& r) noexcept
-            {
-                hpx::execution::experimental::set_stopped(HPX_MOVE(r.receiver));
-            }
-
-        private:
-            template <typename... Ts>
-            void set_value_helper(Ts&&... ts) && noexcept
-            {
-                using result_type = hpx::util::invoke_result_t<F, Ts...>;
-                hpx::detail::try_catch_exception_ptr(
-                    [&]() {
-                        // Certain versions of GCC with optimizations fail on
-                        // the HPX_MOVE with an internal compiler error.
-                        if constexpr (std::is_void_v<result_type>)
-                        {
-                            HPX_INVOKE(std::move(f), HPX_FORWARD(Ts, ts)...);
-                            hpx::execution::experimental::set_value(
-                                HPX_MOVE(receiver));
-                        }
-                        else
-                        {
-                            auto&& result = HPX_INVOKE(
-                                std::move(f), HPX_FORWARD(Ts, ts)...);
-                            hpx::execution::experimental::set_value(
-                                HPX_MOVE(receiver), HPX_MOVE(result));
-                        }
-                    },
-                    [&](std::exception_ptr ep) {
-                        hpx::execution::experimental::set_error(
-                            HPX_MOVE(receiver), HPX_MOVE(ep));
-                    });
-            }
-
-            // clang-format off
-            template <typename... Ts,
-                HPX_CONCEPT_REQUIRES_(
-                    hpx::is_invocable_v<F, Ts...>
-                )>
-            // clang-format on
-            friend void tag_invoke(
-                set_value_t, then_receiver&& r, Ts&&... ts) noexcept
-            {
-                // GCC 7 fails with an internal compiler error unless the actual
-                // body is in a helper function.
-                HPX_MOVE(r).set_value_helper(HPX_FORWARD(Ts, ts)...);
-            }
-        };
-#if defined(HPX_GCC_VERSION) && HPX_GCC_VERSION >= 110000
-#pragma GCC diagnostic pop
-#endif
-
-        template <typename Sender, typename F>
-        struct then_sender
-        {
-            using is_sender = void;
-
-            HPX_NO_UNIQUE_ADDRESS std::decay_t<Sender> sender;
-            HPX_NO_UNIQUE_ADDRESS std::decay_t<F> f;
-
-            template <typename Func, typename Pack>
-            struct undefined_set_value_signature;
-
-            template <typename Pack, typename Enable = void>
-            struct generate_set_value_signature
-              : undefined_set_value_signature<F, Pack>
-            {
-            };
-
-            template <template <typename...> typename Pack, typename... Ts>
-            struct generate_set_value_signature<Pack<Ts...>,
-                std::enable_if_t<hpx::is_invocable_v<F, Ts...>>>
-            {
-                using result_type = hpx::util::invoke_result_t<F, Ts...>;
-                using type = std::conditional_t<std::is_void_v<result_type>,
-                    Pack<>, Pack<result_type>>;
-            };
-
-            template <typename Pack>
-            using gen_value_signature = generate_set_value_signature<Pack>;
-
-            template <typename Env>
-            struct generate_completion_signatures
-            {
-                template <template <typename...> typename Tuple,
-                    template <typename...> typename Variant>
-                using value_types = hpx::util::detail::concat_inner_packs_t<
-                    hpx::util::detail::transform_t<
-                        value_types_of_t<Sender, Env, Tuple, Variant>,
-                        gen_value_signature>>;
-
-                template <template <typename...> typename Variant>
-                using error_types = hpx::util::detail::unique_concat_t<
-                    error_types_of_t<Sender, Env, Variant>,
-                    Variant<std::exception_ptr>>;
-
-                static constexpr bool sends_stopped =
-                    sends_stopped_of_v<Sender, Env>;
-            };
-
-            template <typename Env>
-            friend auto tag_invoke(get_completion_signatures_t,
-                then_sender const&, Env) -> generate_completion_signatures<Env>;
-
-            // clang-format off
-            template <typename CPO,
-                HPX_CONCEPT_REQUIRES_(
-                    meta::value<meta::one_of<
-                        std::decay_t<CPO>, set_value_t, set_stopped_t>> &&
-                    detail::has_completion_scheduler_v<CPO, Sender>
-                )>
-            // clang-format on
-            friend constexpr auto tag_invoke(
-                hpx::execution::experimental::get_completion_scheduler_t<CPO>
-                    tag,
-                then_sender const& s)
-            {
-                return tag(s.sender);
-            }
-
-            // TODO: add forwarding_sender_query
-
-            template <typename Receiver>
-            friend auto tag_invoke(
-                connect_t, then_sender&& s, Receiver&& receiver)
-            {
-                return hpx::execution::experimental::connect(HPX_MOVE(s.sender),
-                    then_receiver<Receiver, F>{
-                        HPX_FORWARD(Receiver, receiver), HPX_MOVE(s.f)});
-            }
-
-            template <typename Receiver>
-            friend auto tag_invoke(
-                connect_t, then_sender& s, Receiver&& receiver)
-            {
-                return hpx::execution::experimental::connect(s.sender,
-                    then_receiver<Receiver, F>{
-                        HPX_FORWARD(Receiver, receiver), s.f});
-            }
-        };
-    }    // namespace detail
-
-    // execution::then is used to attach an invocable as a continuation for the
-    // successful completion of the input sender.
-    //
-    // then returns a sender describing the task graph described by the input
-    // sender, with an added node of invoking the provided function with the
-    // values sent by the input sender as arguments.
-    //
-    // execution::then is guaranteed to not begin executing the function before
-    // the returned sender is started.
-    inline constexpr struct then_t final
-      : hpx::functional::detail::tag_priority<then_t>
-    {
-    private:
-        // clang-format off
-        template <typename Sender, typename F,
-            HPX_CONCEPT_REQUIRES_(
-                is_sender_v<Sender> &&
-                experimental::detail::is_completion_scheduler_tag_invocable_v<
-                    hpx::execution::experimental::set_value_t,
-                    Sender, then_t, F
-                >
-            )>
-        // clang-format on
-        friend constexpr HPX_FORCEINLINE auto tag_override_invoke(
-            then_t, Sender&& sender, F&& f)
-        {
-            auto scheduler =
-                hpx::execution::experimental::get_completion_scheduler<
-                    hpx::execution::experimental::set_value_t>(sender);
-
-            return hpx::functional::tag_invoke(then_t{}, HPX_MOVE(scheduler),
-                HPX_FORWARD(Sender, sender), HPX_FORWARD(F, f));
-        }
-
-        // clang-format off
-        template <typename Sender, typename F,
-            HPX_CONCEPT_REQUIRES_(
-                is_sender_v<Sender>
-            )>
-        // clang-format on
-        friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(
-            then_t, Sender&& sender, F&& f)
-        {
-            return detail::then_sender<Sender, F>{
-                HPX_FORWARD(Sender, sender), HPX_FORWARD(F, f)};
-        }
-
-        template <typename F>
-        friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(then_t, F&& f)
-        {
-            return detail::partial_algorithm<then_t, F>{HPX_FORWARD(F, f)};
-        }
-    } then{};
-}    // namespace hpx::execution::experimental
-
-#endif
diff --git a/libs/core/execution/include/hpx/execution/algorithms/transfer.hpp b/libs/core/execution/include/hpx/execution/algorithms/transfer.hpp
index 510993a8764f..87f7ecfcb500 100644
--- a/libs/core/execution/include/hpx/execution/algorithms/transfer.hpp
+++ b/libs/core/execution/include/hpx/execution/algorithms/transfer.hpp
@@ -8,87 +8,4 @@
 #pragma once
 
 #include <hpx/config.hpp>
-#if defined(HPX_HAVE_STDEXEC)
 #include <hpx/execution_base/stdexec_forward.hpp>
-#else
-
-#include <hpx/concepts/concepts.hpp>
-#include <hpx/execution/algorithms/detail/partial_algorithm.hpp>
-#include <hpx/execution/algorithms/schedule_from.hpp>
-#include <hpx/execution_base/completion_scheduler.hpp>
-#include <hpx/execution_base/completion_signatures.hpp>
-#include <hpx/execution_base/receiver.hpp>
-#include <hpx/execution_base/sender.hpp>
-#include <hpx/functional/detail/tag_priority_invoke.hpp>
-
-#include <utility>
-
-namespace hpx::execution::experimental {
-
-    // execution::transfer is used to adapt a sender into a sender with a
-    // different associated set_value completion scheduler.
-    //
-    // [Note: it results in a transition between different execution contexts
-    // when executed. --end note]
-    //
-    // Returns a sender describing the transition from the execution agent of
-    // the input sender to the execution agent of the target scheduler.
-    //
-    // The execution::on algorithm will ensure that the given sender will start
-    // in the specified context, and doesn't care where the completion signal
-    // for that sender is sent. The execution::transfer algorithm will not care
-    // where the given sender is going to be started, but will ensure that the
-    // completion signal of will be transferred to the given context.
-    //
-    inline constexpr struct transfer_t final
-      : hpx::functional::detail::tag_priority<transfer_t>
-    {
-    private:
-        // clang-format off
-        template <typename Sender, typename Scheduler,
-            HPX_CONCEPT_REQUIRES_(
-                is_sender_v<Sender> &&
-                is_scheduler_v<Scheduler> &&
-                experimental::detail::is_completion_scheduler_tag_invocable_v<
-                    hpx::execution::experimental::set_value_t, Sender,
-                    transfer_t, Scheduler
-                >
-            )>
-        // clang-format on
-        friend constexpr HPX_FORCEINLINE auto tag_override_invoke(
-            transfer_t, Sender&& sender, Scheduler&& scheduler)
-        {
-            auto completion_scheduler =
-                hpx::execution::experimental::get_completion_scheduler<
-                    hpx::execution::experimental::set_value_t>(sender);
-
-            return hpx::functional::tag_invoke(transfer_t{},
-                HPX_MOVE(completion_scheduler), HPX_FORWARD(Sender, sender),
-                HPX_FORWARD(Scheduler, scheduler));
-        }
-
-        // clang-format off
-        template <typename Sender, typename Scheduler,
-            HPX_CONCEPT_REQUIRES_(
-                is_sender_v<Sender> &&
-                is_scheduler_v<Scheduler>
-            )>
-        // clang-format on
-        friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(
-            transfer_t, Sender&& predecessor_sender, Scheduler&& scheduler)
-        {
-            return schedule_from(HPX_FORWARD(Scheduler, scheduler),
-                HPX_FORWARD(Sender, predecessor_sender));
-        }
-
-        template <typename Scheduler>
-        friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(
-            transfer_t, Scheduler&& scheduler)
-        {
-            return detail::partial_algorithm<transfer_t, Scheduler>{
-                HPX_FORWARD(Scheduler, scheduler)};
-        }
-    } transfer{};
-}    // namespace hpx::execution::experimental
-
-#endif
diff --git a/libs/core/execution/include/hpx/execution/algorithms/transfer_just.hpp b/libs/core/execution/include/hpx/execution/algorithms/transfer_just.hpp
index fc7611f01692..87f7ecfcb500 100644
--- a/libs/core/execution/include/hpx/execution/algorithms/transfer_just.hpp
+++ b/libs/core/execution/include/hpx/execution/algorithms/transfer_just.hpp
@@ -8,39 +8,4 @@
 #pragma once
 
 #include <hpx/config.hpp>
-#if defined(HPX_HAVE_STDEXEC)
 #include <hpx/execution_base/stdexec_forward.hpp>
-#else
-
-#include <hpx/execution/algorithms/just.hpp>
-#include <hpx/execution/algorithms/transfer.hpp>
-#include <hpx/functional/detail/tag_fallback_invoke.hpp>
-
-#include <utility>
-
-namespace hpx::execution::experimental {
-
-    // execution::transfer_just is used to create a sender that propagates a set
-    // of values to a connected receiver on an execution agent belonging to the
-    // associated execution context of a specified scheduler.
-    //
-    // Returns a sender whose value completion scheduler is the provided
-    // scheduler, which sends the provided values in the same manner as just.
-    //
-    // This adaptor is provided as it greatly simplifies lifting values into
-    // senders.
-    inline constexpr struct transfer_just_t final
-      : hpx::functional::detail::tag_fallback<transfer_just_t>
-    {
-    private:
-        template <typename Scheduler, typename... Ts>
-        friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(
-            transfer_just_t, Scheduler&& scheduler, Ts&&... ts)
-        {
-            return transfer(just(HPX_FORWARD(Ts, ts)...),
-                HPX_FORWARD(Scheduler, scheduler));
-        }
-    } transfer_just{};
-}    // namespace hpx::execution::experimental
-
-#endif
diff --git a/libs/core/execution/include/hpx/execution/algorithms/when_all.hpp b/libs/core/execution/include/hpx/execution/algorithms/when_all.hpp
index 5e5bafb494d3..90bbc187d3bf 100644
--- a/libs/core/execution/include/hpx/execution/algorithms/when_all.hpp
+++ b/libs/core/execution/include/hpx/execution/algorithms/when_all.hpp
@@ -10,7 +10,6 @@
 #include <hpx/config.hpp>
 #include <hpx/async_base/dataflow.hpp>
 
-#if defined(HPX_HAVE_STDEXEC)
 #include <hpx/execution_base/stdexec_forward.hpp>
 
 namespace hpx::execution::experimental {
@@ -41,576 +40,3 @@ namespace hpx::execution::experimental {
             HPX_FORWARD(F, f));
     }
 }    // namespace hpx::execution::experimental
-#else
-#include <hpx/async_base/launch_policy.hpp>
-#include <hpx/concepts/concepts.hpp>
-#include <hpx/datastructures/optional.hpp>
-#include <hpx/datastructures/variant.hpp>
-#include <hpx/execution/algorithms/detail/single_result.hpp>
-#include <hpx/execution/algorithms/transfer.hpp>
-#include <hpx/execution/queries/get_stop_token.hpp>
-#include <hpx/execution_base/completion_signatures.hpp>
-#include <hpx/execution_base/get_env.hpp>
-#include <hpx/execution_base/operation_state.hpp>
-#include <hpx/execution_base/receiver.hpp>
-#include <hpx/execution_base/sender.hpp>
-#include <hpx/functional/detail/tag_fallback_invoke.hpp>
-#include <hpx/functional/invoke_fused.hpp>
-#include <hpx/synchronization/stop_token.hpp>
-#include <hpx/type_support/meta.hpp>
-#include <hpx/type_support/pack.hpp>
-
-#include <atomic>
-#include <cstddef>
-#include <exception>
-#include <functional>
-#include <memory>
-#include <type_traits>
-#include <utility>
-
-namespace hpx::execution::experimental {
-    namespace detail {
-
-        // callback object to request cancellation
-        struct on_stop_requested
-        {
-            hpx::experimental::in_place_stop_source& stop_source_;
-            void operator()() noexcept
-            {
-                stop_source_.request_stop();
-            }
-        };
-
-        // This is a receiver to be connected to the ith predecessor sender
-        // passed to when_all. When set_value is called, it will emplace the
-        // values sent into the appropriate position in the pack used to store
-        // values from all predecessor senders.
-        template <typename OperationState>
-        struct when_all_receiver
-        {
-            std::decay_t<OperationState>& op_state;
-
-            explicit when_all_receiver(
-                std::decay_t<OperationState>& op_state) noexcept
-              : op_state(op_state)
-            {
-            }
-
-            template <typename Error>
-            friend void tag_invoke(
-                set_error_t, when_all_receiver&& r, Error&& error) noexcept
-            {
-                if (!r.op_state.set_stopped_error_called.exchange(true))
-                {
-                    r.op_state.stop_source_.request_stop();
-                    try
-                    {
-                        r.op_state.error = HPX_FORWARD(Error, error);
-                    }
-                    catch (...)
-                    {
-                        // NOLINTNEXTLINE(bugprone-throw-keyword-missing)
-                        r.op_state.error = std::current_exception();
-                    }
-                }
-                r.op_state.finish();
-            }
-
-            friend void tag_invoke(
-                set_stopped_t, when_all_receiver&& r) noexcept
-            {
-                // request stop only if we're not in error state
-                if (!r.op_state.set_stopped_error_called.exchange(true))
-                {
-                    r.op_state.stop_source_.request_stop();
-                }
-                r.op_state.finish();
-            };
-
-            template <typename... Ts, std::size_t... Is>
-            auto set_value_helper(hpx::util::index_pack<Is...>, Ts&&... ts)
-            // MSVC sometimes invalidly rejects valid invocations
-            // clang-format off
-#if !defined(HPX_MSVC)
-                -> decltype(
-                    (std::declval<
-                         typename OperationState::value_types_storage_type>()
-                            .template get<OperationState::i_storage_offset +
-                                Is>()
-                            .emplace(HPX_FORWARD(Ts, ts)),
-                        ...),
-                    void())
-#endif
-            // clang-format on
-            {
-                // op_state.ts holds values from all predecessor senders. We
-                // emplace the values using the offset calculated while
-                // constructing the operation state.
-                (op_state.ts
-                        .template get<OperationState::i_storage_offset + Is>()
-                        .emplace(HPX_FORWARD(Ts, ts)),
-                    ...);
-            }
-
-            static constexpr std::size_t sender_pack_size =
-                OperationState::sender_pack_size;
-            using index_pack_type =
-                hpx::util::make_index_pack_t<sender_pack_size>;
-
-            // different versions of clang-format disagree
-            // clang-format off
-            template <typename... Ts>
-            auto set_value(Ts&&... ts) noexcept -> decltype(
-                set_value_helper(index_pack_type{}, HPX_FORWARD(Ts, ts)...))
-            // clang-format on
-            {
-                if constexpr (sender_pack_size > 0)
-                {
-                    if (!op_state.set_stopped_error_called)
-                    {
-                        try
-                        {
-                            set_value_helper(
-                                index_pack_type{}, HPX_FORWARD(Ts, ts)...);
-                        }
-                        catch (...)
-                        {
-                            if (!op_state.set_stopped_error_called.exchange(
-                                    true))
-                            {
-                                // NOLINTNEXTLINE(bugprone-throw-keyword-missing)
-                                op_state.error = std::current_exception();
-                            }
-                        }
-                    }
-                }
-
-                op_state.finish();
-            }
-
-            friend auto tag_invoke(get_env_t, when_all_receiver const& r)
-                -> make_env_t<get_stop_token_t,
-                    hpx::experimental::in_place_stop_token,
-                    env_of_t<typename OperationState::receiver_type>>
-            {
-                return make_env<get_stop_token_t>(
-                    r.op_state.stop_source_.get_token(),
-                    hpx::execution::experimental::get_env(r.op_state.receiver));
-            }
-        };
-
-        // Due to what appears to be a bug in clang this is not a hidden friend
-        // of when_all_receiver. The trailing decltype for SFINAE in the member
-        // set_value would give an error about accessing an incomplete type, if
-        // the member set_value were a hidden friend tag_invoke overload
-        // instead.
-        template <typename OperationState, typename... Ts>
-        auto tag_invoke(set_value_t, when_all_receiver<OperationState>&& r,
-            Ts&&... ts) noexcept
-            -> decltype(r.set_value(HPX_FORWARD(Ts, ts)...), void())
-        {
-            r.set_value(HPX_FORWARD(Ts, ts)...);
-        }
-
-        template <typename... Senders>
-        struct when_all_sender
-        {
-            using is_sender = void;
-            using senders_type =
-                hpx::util::member_pack_for<std::decay_t<Senders>...>;
-            senders_type senders;
-
-            template <typename... Senders_>
-            explicit constexpr when_all_sender(Senders_&&... senders)
-              : senders(
-                    std::piecewise_construct, HPX_FORWARD(Senders_, senders)...)
-            {
-            }
-
-            template <typename Env>
-            struct generate_completion_signatures
-            {
-                template <template <typename...> typename Tuple,
-                    template <typename...> typename Variant>
-                using value_types = hpx::util::detail::concat_inner_packs_t<
-                    hpx::util::detail::concat_t<
-                        value_types_of_t<Senders, Env, Tuple, Variant>...>>;
-
-                template <template <typename...> typename Variant>
-                using error_types = hpx::util::detail::unique_concat_t<
-                    error_types_of_t<Senders, Env, Variant>...,
-                    Variant<std::exception_ptr>>;
-
-                static constexpr bool sends_stopped = true;
-            };
-
-            // clang-format off
-            template <typename Env>
-            friend auto tag_invoke(get_completion_signatures_t,
-                when_all_sender const&,
-                Env) noexcept -> generate_completion_signatures<Env>;
-            // clang-format on
-
-            static constexpr std::size_t num_predecessors = sizeof...(Senders);
-            static_assert(num_predecessors > 0,
-                "when_all expects at least one predecessor sender");
-
-            template <std::size_t I>
-            static constexpr std::size_t sender_pack_size_at_index =
-                single_variant_tuple_size_v<
-                    value_types_of_t<hpx::util::at_index_t<I, Senders...>,
-                        empty_env, meta::pack, meta::pack>>;
-
-            template <typename Receiver, typename SendersPack,
-                std::size_t I = num_predecessors - 1>
-            struct operation_state;
-
-#if defined(HPX_GCC_VERSION) && HPX_GCC_VERSION >= 110000
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Warray-bounds"
-#endif
-            template <typename Receiver, typename SendersPack>
-            struct operation_state<Receiver, SendersPack, 0>
-            {
-                using receiver_type = std::decay_t<Receiver>;
-
-                // The index of the sender that this operation state handles.
-                static constexpr std::size_t i = 0;
-                // The offset at which we start to emplace values sent by the
-                // ith predecessor sender.
-                static constexpr std::size_t i_storage_offset = 0;
-#if !defined(HPX_CUDA_VERSION)
-                // The number of values sent by the ith predecessor sender.
-                static constexpr std::size_t sender_pack_size =
-                    sender_pack_size_at_index<0>;
-#else
-                // nvcc does not like using the helper sender_pack_size_at_index
-                // here and complains about incomplete types. Lifting the helper
-                // explicitly in here works.
-                static constexpr std::size_t sender_pack_size =
-                    single_variant_tuple_size_v<
-                        value_types_of_t<hpx::util::at_index_t<0, Senders...>,
-                            empty_env, meta::pack, meta::pack>>;
-#endif
-
-                // Number of predecessor senders that have not yet called any of
-                // the set signals.
-                std::atomic<std::size_t> predecessors_remaining =
-                    num_predecessors;
-
-                // Values sent by all predecessor senders are stored here in the
-                // base-case operation state. They are stored in a
-                // member_pack<optional<T0>, ..., optional<Tn>>, where T0, ...,
-                // Tn are the types of the values sent by all predecessor
-                // senders.
-                template <typename T>
-                struct add_optional
-                {
-                    using type = hpx::optional<std::decay_t<T>>;
-                };
-                using value_types = typename generate_completion_signatures<
-                    empty_env>::template value_types<meta::pack, meta::pack>;
-                using value_types_storage_type =
-                    hpx::util::detail::change_pack_t<hpx::util::member_pack_for,
-                        hpx::util::detail::transform_t<
-                            hpx::util::detail::concat_pack_of_packs_t<
-                                value_types>,
-                            add_optional>>;
-                value_types_storage_type ts;
-
-                using error_types = typename generate_completion_signatures<
-                    empty_env>::template error_types<hpx::variant>;
-                hpx::optional<error_types> error;
-                std::atomic<bool> set_stopped_error_called{false};
-                HPX_NO_UNIQUE_ADDRESS receiver_type receiver;
-
-                hpx::experimental::in_place_stop_source stop_source_{};
-
-                using stop_token_t = stop_token_of_t<env_of_t<receiver_type>&>;
-                hpx::optional<typename stop_token_t::template callback_type<
-                    on_stop_requested>>
-                    on_stop_{};
-
-                using operation_state_type =
-                    std::decay_t<decltype(hpx::execution::experimental::connect(
-                        std::declval<SendersPack>().template get<i>(),
-                        when_all_receiver<operation_state>(
-                            std::declval<std::decay_t<operation_state>&>())))>;
-                operation_state_type op_state;
-
-                template <typename Receiver_, typename Senders_>
-                operation_state(Receiver_&& receiver, Senders_&& senders)
-                  : receiver(HPX_FORWARD(Receiver_, receiver))
-                  , op_state(hpx::execution::experimental::connect(
-#if defined(HPX_CUDA_VERSION)
-                        std::forward<Senders_>(senders).template get<i>(),
-#else
-                        HPX_FORWARD(Senders_, senders).template get<i>(),
-#endif
-                        when_all_receiver<operation_state>(*this)))
-                {
-                }
-
-                operation_state(operation_state&&) = delete;
-                operation_state& operator=(operation_state&&) = delete;
-                operation_state(operation_state const&) = delete;
-                operation_state& operator=(operation_state const&) = delete;
-
-                void start() & noexcept
-                {
-                    hpx::execution::experimental::start(op_state);
-                }
-
-                template <std::size_t... Is, typename... Ts>
-                void set_value_helper(
-                    hpx::util::member_pack<hpx::util::index_pack<Is...>, Ts...>&
-                        t) noexcept
-                {
-                    hpx::execution::experimental::set_value(
-                        HPX_MOVE(receiver), HPX_MOVE(*t.template get<Is>())...);
-                }
-
-                void finish() noexcept
-                {
-                    if (--predecessors_remaining == 0)
-                    {
-                        // Stop callback is no longer needed. Destroy it.
-                        on_stop_.reset();
-
-                        if (!set_stopped_error_called)
-                        {
-                            set_value_helper(ts);
-                        }
-                        else if (error)
-                        {
-                            hpx::visit(
-                                [this](auto&& error) {
-                                    hpx::execution::experimental::set_error(
-                                        HPX_MOVE(receiver),
-                                        HPX_FORWARD(decltype(error), error));
-                                },
-                                HPX_MOVE(error.value()));
-                        }
-                        else
-                        {
-                            hpx::execution::experimental::set_stopped(
-                                HPX_MOVE(receiver));
-                        }
-                    }
-                }
-            };
-
-            template <typename Receiver, typename SendersPack, std::size_t I>
-            struct operation_state
-              : operation_state<Receiver, SendersPack, I - 1>
-            {
-                using base_type = operation_state<Receiver, SendersPack, I - 1>;
-                using receiver_type = std::decay_t<Receiver>;
-
-                // The index of the sender that this operation state handles.
-                static constexpr std::size_t i = I;
-
-#if !defined(HPX_CUDA_VERSION)
-                // The number of values sent by the ith predecessor sender.
-                static constexpr std::size_t sender_pack_size =
-                    sender_pack_size_at_index<i>;
-#else
-                // nvcc does not like using the helper sender_pack_size_at_index
-                // here and complains about incomplete types. Lifting the helper
-                // explicitly in here works.
-                static constexpr std::size_t sender_pack_size =
-                    single_variant_tuple_size_v<
-                        value_types_of_t<hpx::util::at_index_t<i, Senders...>,
-                            empty_env, meta::pack, meta::pack>>;
-#endif
-                // The offset at which we start to emplace values sent by the
-                // ith predecessor sender.
-                static constexpr std::size_t i_storage_offset =
-                    base_type::i_storage_offset + base_type::sender_pack_size;
-
-                using operation_state_type =
-                    std::decay_t<decltype(hpx::execution::experimental::connect(
-                        std::declval<SendersPack>().template get<i>(),
-                        when_all_receiver<operation_state>(
-                            std::declval<std::decay_t<operation_state>&>())))>;
-                operation_state_type op_state;
-
-                template <typename Receiver_, typename SendersPack_>
-                operation_state(Receiver_&& receiver, SendersPack_&& senders)
-                  : base_type(HPX_FORWARD(Receiver_, receiver),
-                        HPX_FORWARD(SendersPack, senders))
-                  , op_state(hpx::execution::experimental::connect(
-#if defined(HPX_CUDA_VERSION)
-                        std::forward<SendersPack_>(senders).template get<i>(),
-#else
-                        HPX_FORWARD(SendersPack_, senders).template get<i>(),
-#endif
-                        when_all_receiver<operation_state>(*this)))
-                {
-                }
-
-                operation_state(operation_state&&) = delete;
-                operation_state& operator=(operation_state&&) = delete;
-                operation_state(operation_state const&) = delete;
-                operation_state& operator=(operation_state const&) = delete;
-
-                void start() & noexcept
-                {
-                    base_type::start();
-                    hpx::execution::experimental::start(op_state);
-                }
-            };
-#if defined(HPX_GCC_VERSION) && HPX_GCC_VERSION >= 110000
-#pragma GCC diagnostic pop
-#endif
-
-            template <typename Receiver, typename SendersPack>
-            friend void tag_invoke(start_t,
-                operation_state<Receiver, SendersPack, num_predecessors - 1>&
-                    os) noexcept
-            {
-                // register stop callback
-                os.on_stop_.emplace(
-                    hpx::execution::experimental::get_stop_token(
-                        hpx::execution::experimental::get_env(os.receiver)),
-                    on_stop_requested{os.stop_source_});
-
-                // If a stop has already been requested. Don't bother starting
-                // the child operations.
-                if (os.stop_source_.stop_requested())
-                {
-                    hpx::execution::experimental::set_stopped(
-                        HPX_FORWARD(Receiver, os.receiver));
-                }
-                else
-                {
-                    os.start();
-                }
-            }
-
-            template <typename Receiver>
-            friend auto tag_invoke(
-                connect_t, when_all_sender&& s, Receiver&& receiver)
-            {
-                return operation_state<Receiver, senders_type&&,
-                    num_predecessors - 1>(
-                    HPX_FORWARD(Receiver, receiver), HPX_MOVE(s.senders));
-            }
-
-            template <typename Receiver>
-            friend auto tag_invoke(
-                connect_t, when_all_sender& s, Receiver&& receiver)
-            {
-                return operation_state<Receiver, senders_type&,
-                    num_predecessors - 1>(
-                    HPX_FORWARD(Receiver, receiver), s.senders);
-            }
-        };
-    }    // namespace detail
-
-    // execution::when_all is used to join multiple sender chains and create a
-    // sender whose execution is dependent on all of the input senders that only
-    // send a single set of values. execution::when_all_with_variant is used to
-    // join multiple sender chains and create a sender whose execution is
-    // dependent on all of the input senders, each of which may have one or more
-    // sets of sent values.
-    //
-    // when_all returns a sender that completes once all of the input senders
-    // have completed. It is constrained to only accept senders that can
-    // complete with a single set of values (_i.e._, it only calls one overload
-    // of set_value on its receiver). The values sent by this sender are the
-    // values sent by each of the input senders, in order of the arguments
-    // passed to when_all. It completes inline on the execution context on which
-    // the last input sender completes, unless stop is requested before when_all
-    // is started, in which case it completes inline within the call to start.
-    //
-    // The returned sender has no completion schedulers.
-    inline constexpr struct when_all_t final
-      : hpx::functional::detail::tag_fallback<when_all_t>
-    {
-    private:
-        // clang-format off
-        template <typename... Senders,
-            HPX_CONCEPT_REQUIRES_(
-                hpx::util::all_of_v<is_sender<Senders>...>
-            )>
-        // clang-format on
-        friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(
-            when_all_t, Senders&&... senders)
-        {
-            return detail::when_all_sender<Senders...>{
-                HPX_FORWARD(Senders, senders)...};
-        }
-    } when_all{};
-
-    // TODO:
-    // execution::when_all_with_variant is used to join multiple sender chains
-    // and create a sender whose execution is dependent on all of the input
-    // senders, each of which may have one or more sets of sent values.
-    inline constexpr struct when_all_with_variant_t final
-      : hpx::functional::tag<when_all_with_variant_t>
-    {
-    } when_all_with_variant{};
-
-    // execution::transfer_when_all is used to join multiple sender chains
-    // and create a sender whose execution is dependent on all of the input
-    // senders that only send a single set of values each, while also making
-    // sure that they complete on the specified scheduler.
-    inline constexpr struct transfer_when_all_t final
-      : hpx::functional::detail::tag_fallback<transfer_when_all_t>
-    {
-    private:
-        // clang-format off
-        template <typename Sched, typename... Senders,
-            HPX_CONCEPT_REQUIRES_(
-                is_scheduler_v<Sched> &&
-                hpx::util::all_of_v<is_sender<Senders>...>
-            )>
-        // clang-format on
-        friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(
-            transfer_when_all_t, Sched&& sched, Senders&&... senders)
-        {
-            return hpx::execution::experimental::transfer(
-                hpx::execution::experimental::when_all(
-                    HPX_FORWARD(Senders, senders)...),
-                HPX_FORWARD(Sched, sched));
-        }
-    } transfer_when_all{};
-
-    // TODO:
-    // execution::transfer_when_all_with_variant is used to join multiple
-    // sender chains and create a sender whose execution is dependent on all
-    // of the input senders, which may have one or more sets of sent values.
-    inline constexpr struct transfer_when_all_with_variant_t final
-      : hpx::functional::tag<transfer_when_all_with_variant_t>
-    {
-    } transfer_when_all_with_variant{};
-
-    // the following enables directly using dataflow() with senders
-
-    template <typename F, typename Sender, typename... Senders>
-    constexpr HPX_FORCEINLINE auto tag_invoke(
-        hpx::detail::dataflow_t, F&& f, Sender&& sender, Senders&&... senders)
-        -> decltype(then(when_all(HPX_FORWARD(Sender, sender),
-                             HPX_FORWARD(Senders, senders)...),
-            HPX_FORWARD(F, f)))
-    {
-        return then(when_all(HPX_FORWARD(Sender, sender),
-                        HPX_FORWARD(Senders, senders)...),
-            HPX_FORWARD(F, f));
-    }
-
-    template <typename F, typename Sender, typename... Senders>
-    constexpr HPX_FORCEINLINE auto tag_invoke(hpx::detail::dataflow_t,
-        hpx::launch, F&& f, Sender&& sender, Senders&&... senders)
-        -> decltype(then(when_all(HPX_FORWARD(Sender, sender),
-                             HPX_FORWARD(Senders, senders)...),
-            HPX_FORWARD(F, f)))
-    {
-        return then(when_all(HPX_FORWARD(Sender, sender),
-                        HPX_FORWARD(Senders, senders)...),
-            HPX_FORWARD(F, f));
-    }
-}    // namespace hpx::execution::experimental
-
-#endif
diff --git a/libs/core/execution/include/hpx/execution/algorithms/when_all_vector.hpp b/libs/core/execution/include/hpx/execution/algorithms/when_all_vector.hpp
index a753d9c76885..7590627ce0fd 100644
--- a/libs/core/execution/include/hpx/execution/algorithms/when_all_vector.hpp
+++ b/libs/core/execution/include/hpx/execution/algorithms/when_all_vector.hpp
@@ -10,9 +10,7 @@
 
 #include <hpx/config.hpp>
 
-#if defined(HPX_HAVE_STDEXEC)
 #include <hpx/execution_base/stdexec_forward.hpp>
-#endif
 
 #include <hpx/assert.hpp>
 #include <hpx/concepts/concepts.hpp>
@@ -67,9 +65,7 @@ namespace hpx::when_all_vector_detail {
     struct when_all_vector_sender_impl<Sender>::when_all_vector_sender_type
     {
         using is_sender = void;
-#if defined(HPX_HAVE_STDEXEC)
         using sender_concept = hpx::execution::experimental::sender_t;
-#endif
         using senders_type = std::vector<Sender>;
         senders_type senders;
 
@@ -99,7 +95,6 @@ namespace hpx::when_all_vector_detail {
         {
         };
 
-#if defined(HPX_HAVE_STDEXEC)
         // Dummy parameter introduced to please GCC11 which enforces
         // explicit specialization in non-namespace scope as an error.
         // Reference: https://cplusplus.com/forum/general/58906/#msg318049
@@ -134,53 +129,17 @@ namespace hpx::when_all_vector_detail {
                 hpxexec::completion_signatures<hpxexec::set_error_t(
                     std::exception_ptr)>,
                 transformed_comp_sigs_identity, decay_set_error>;
-#else
-        // This sender sends a single vector of the type sent by the
-        // predecessor senders or nothing if the predecessor senders send
-        // nothing
-        template <typename Env>
-        struct generate_completion_signatures
-        {
-            template <template <typename...> class Tuple,
-                template <typename...> class Variant>
-            using value_types = Variant<std::conditional_t<is_void_value_type,
-                Tuple<>, Tuple<std::vector<element_value_type>>>>;
-
-            // This sender sends any error types sent by the predecessor senders
-            // or std::exception_ptr
-            template <template <typename...> class Variant>
-            using error_types = hpx::util::detail::unique_concat_t<
-                hpx::util::detail::transform_t<
-                    hpxexec::error_types_of_t<Sender, Env, Variant>,
-                    std::decay>,
-                Variant<std::exception_ptr>>;
-
-            static constexpr bool sends_stopped = true;
-        };
-
-        // clang-format off
-        template <typename Env>
-        friend auto tag_invoke(
-            hpxexec::get_completion_signatures_t,
-            when_all_vector_sender_type const&,
-            Env) noexcept -> generate_completion_signatures<Env>;
-        // clang-format on
-#endif
 
         template <typename Receiver>
         struct operation_state
         {
             using receiver_type = std::decay_t<Receiver>;
-#if defined(HPX_HAVE_STDEXEC)
             using operation_state_concept =
                 hpx::execution::experimental::operation_state_t;
-#endif
 
             struct when_all_vector_receiver
             {
-#if defined(HPX_HAVE_STDEXEC)
                 using receiver_concept = hpxexec::receiver_t;
-#endif
                 operation_state& op_state;
                 std::size_t const i;
 
@@ -252,7 +211,6 @@ namespace hpx::when_all_vector_detail {
                 // TODO: Make this a method
                 friend auto tag_invoke(hpxexec::get_env_t,
                     when_all_vector_receiver const& r)
-#if defined(HPX_HAVE_STDEXEC)
                     noexcept
                     -> hpxexec::env<
                         hpxexec::env_of_t<receiver_type>,
@@ -275,21 +233,6 @@ namespace hpx::when_all_vector_detail {
                     return hpxexec::env(
                         std::move(e), std::move(p));
                 }
-#else
-                    -> hpxexec::make_env_t<
-                        hpxexec::get_stop_token_t,
-                        hpx::experimental::in_place_stop_token,
-                        hpxexec::env_of_t<receiver_type>>
-                {
-                    /* The old calling convention is:
-                     * make_env<tag>(val, old_env) */
-                    return hpxexec::make_env<
-                        hpxexec::get_stop_token_t>(
-                        r.op_state.stop_source_.get_token(),
-                        hpxexec::get_env(
-                            r.op_state.receiver));
-                }
-#endif
                 // clang-format on
             };
 
@@ -318,15 +261,10 @@ namespace hpx::when_all_vector_detail {
 
             // The first error sent by any predecessor sender is stored in a
             // optional of a variant of the error_types
-#if defined(HPX_HAVE_STDEXEC)
             using error_types = typename hpxexec::error_types_of_t<
                 when_all_vector_sender_impl<
                     Sender>::when_all_vector_sender_type,
                 hpxexec::empty_env, hpx::variant>;
-#else
-            using error_types = typename generate_completion_signatures<
-                hpxexec::empty_env>::template error_types<hpx::variant>;
-#endif
             std::optional<error_types> error;
 
             // Set to true when set_stopped or set_error has been called
@@ -409,7 +347,8 @@ namespace hpx::when_all_vector_detail {
                                 values.push_back(HPX_MOVE(t.value()));
 #endif
                             }
-                            hpxexec::set_value(HPX_MOVE(receiver), HPX_MOVE(values));
+                            hpxexec::set_value(
+                                HPX_MOVE(receiver), HPX_MOVE(values));
                         }
                     }
                     else if (error)
@@ -423,23 +362,20 @@ namespace hpx::when_all_vector_detail {
                     }
                     else
                     {
-#if defined(HPX_HAVE_STDEXEC)
                         if constexpr (hpxexec::sends_stopped<Sender>)
                         {
-#endif
                             hpxexec::set_stopped(HPX_MOVE(receiver));
-#if defined(HPX_HAVE_STDEXEC)
                         }
                         else
                         {
                             HPX_UNREACHABLE;
                         }
-#endif
                     }
                 }
             }
 
-            friend void tag_invoke(hpxexec::start_t, operation_state& os) noexcept
+            friend void tag_invoke(
+                hpxexec::start_t, operation_state& os) noexcept
             {
                 // register stop callback
                 os.on_stop_.emplace(
@@ -485,16 +421,16 @@ namespace hpx::when_all_vector_detail {
         };
 
         template <typename Receiver>
-        friend auto tag_invoke(
-            hpxexec::connect_t, when_all_vector_sender_type&& s, Receiver&& receiver)
+        friend auto tag_invoke(hpxexec::connect_t,
+            when_all_vector_sender_type&& s, Receiver&& receiver)
         {
             return operation_state<Receiver>(
                 HPX_FORWARD(Receiver, receiver), HPX_MOVE(s.senders));
         }
 
         template <typename Receiver>
-        friend auto tag_invoke(
-            hpxexec::connect_t, when_all_vector_sender_type& s, Receiver&& receiver)
+        friend auto tag_invoke(hpxexec::connect_t,
+            when_all_vector_sender_type& s, Receiver&& receiver)
         {
             return operation_state<Receiver>(receiver, s.senders);
         }
diff --git a/libs/core/execution/include/hpx/execution/queries/get_allocator.hpp b/libs/core/execution/include/hpx/execution/queries/get_allocator.hpp
index 68385a07a4a8..e0528d661c30 100644
--- a/libs/core/execution/include/hpx/execution/queries/get_allocator.hpp
+++ b/libs/core/execution/include/hpx/execution/queries/get_allocator.hpp
@@ -7,46 +7,4 @@
 #pragma once
 
 #include <hpx/config.hpp>
-#if defined(HPX_HAVE_STDEXEC)
 #include <hpx/execution_base/stdexec_forward.hpp>
-#else
-
-#include <hpx/execution/queries/read.hpp>
-#include <hpx/execution_base/get_env.hpp>
-#include <hpx/functional/detail/tag_fallback_invoke.hpp>
-
-namespace hpx::execution::experimental {
-
-    // 1. execution::get_allocator is used to ask an object for its associated
-    //    allocator.
-    //
-    // 2. The name execution::get_allocator denotes a customization point object.
-    //     For some subexpression r, if the type of r is (possibly cv-qualified)
-    //     no_env, then execution::get_allocator(r) is ill-formed.
-    //     Otherwise, it is expression equivalent to:
-    //
-    //    1. tag_invoke(execution::get_allocator, as_const(r)), if this expression
-    //       is well formed.
-    //          Mandates: The tag_invoke expression above is not potentially-
-    //          throwing and its type satisfies Allocator.
-    //
-    //    2. Otherwise, execution::get_allocator(r) is ill-formed.
-    //
-    // 3. execution::get_allocator() (with no arguments) is expression-equivalent
-    //    to execution::read(execution::get_allocator).
-    //
-    inline constexpr struct get_allocator_t final
-      : hpx::functional::detail::tag_fallback<get_allocator_t>
-    {
-    private:
-        friend inline constexpr auto tag_fallback_invoke(
-            get_allocator_t) noexcept;
-
-    } get_allocator{};
-
-    constexpr auto tag_fallback_invoke(get_allocator_t) noexcept
-    {
-        return hpx::execution::experimental::read(get_allocator);
-    }
-}    // namespace hpx::execution::experimental
-#endif
diff --git a/libs/core/execution/include/hpx/execution/queries/get_delegatee_scheduler.hpp b/libs/core/execution/include/hpx/execution/queries/get_delegatee_scheduler.hpp
index 7cc3e1cdf1c8..e0528d661c30 100644
--- a/libs/core/execution/include/hpx/execution/queries/get_delegatee_scheduler.hpp
+++ b/libs/core/execution/include/hpx/execution/queries/get_delegatee_scheduler.hpp
@@ -7,48 +7,4 @@
 #pragma once
 
 #include <hpx/config.hpp>
-#if defined(HPX_HAVE_STDEXEC)
 #include <hpx/execution_base/stdexec_forward.hpp>
-#else
-#include <hpx/execution/queries/read.hpp>
-#include <hpx/execution_base/get_env.hpp>
-#include <hpx/functional/detail/tag_fallback_invoke.hpp>
-
-namespace hpx::execution::experimental {
-
-    // 1. execution::get_delegatee_scheduler is used to ask an object for a
-    //    scheduler that may be used to delegate work to for the purpose of
-    //    forward progress delegation.
-    //
-    // 2. The name execution::get_scheduler denotes a customization point
-    //    object.
-    //    For some subexpression r, if the type of r is (possibly cv-qualified)
-    //    no_env, then execution::get_delegatee_scheduler(r) is ill-formed.
-    //    Otherwise, it is expression equivalent to:
-    //
-    //    1. tag_invoke(execution::get_delegatee_scheduler, as_const(r)), if
-    //       this expression is well formed.
-    //          Mandates: The tag_invoke expression above is not potentially-
-    //          throwing and its type satisfies execution::scheduler.
-    //
-    //    2. Otherwise, execution::get_delegatee_scheduler(r) is ill-formed.
-    //
-    // 3. execution::get_delegatee_scheduler() (with no arguments) is expression-
-    //    equivalent to execution::read(execution::get_delegatee_scheduler).
-    //
-    inline constexpr struct get_delegatee_scheduler_t final
-      : hpx::functional::detail::tag_fallback<get_delegatee_scheduler_t>
-    {
-    private:
-        friend inline constexpr auto tag_fallback_invoke(
-            get_delegatee_scheduler_t) noexcept;
-
-    } get_delegatee_scheduler{};
-
-    constexpr auto tag_fallback_invoke(get_delegatee_scheduler_t) noexcept
-    {
-        return hpx::execution::experimental::read(get_delegatee_scheduler);
-    }
-}    // namespace hpx::execution::experimental
-
-#endif
diff --git a/libs/core/execution/include/hpx/execution/queries/get_scheduler.hpp b/libs/core/execution/include/hpx/execution/queries/get_scheduler.hpp
index 42fe150da1e8..6b113d961c20 100644
--- a/libs/core/execution/include/hpx/execution/queries/get_scheduler.hpp
+++ b/libs/core/execution/include/hpx/execution/queries/get_scheduler.hpp
@@ -8,139 +8,4 @@
 
 #include <hpx/config.hpp>
 
-#if defined(HPX_HAVE_STDEXEC)
 #include <hpx/execution_base/stdexec_forward.hpp>
-#else
-
-#include <hpx/execution/queries/read.hpp>
-#include <hpx/execution_base/get_env.hpp>
-#include <hpx/functional/detail/tag_fallback_invoke.hpp>
-#include <hpx/functional/tag_invoke.hpp>
-
-namespace hpx::execution::experimental {
-
-    // [exec.sched_queries.forwarding_scheduler_query]
-    //
-    // 1. `execution::forwarding_scheduler_query` is used to ask a customization
-    //    point object whether it is a scheduler query that should be forwarded
-    //    through scheduler adaptors.
-    //
-    //
-    // 2. The name `execution::forwarding_scheduler_query` denotes a
-    //    customization point object. For some subexpression `t`,
-    //    `execution::forwarding_scheduler_query(t)` is expression equivalent
-    //    to:
-    //
-    //      1. `tag_invoke(execution::forwarding_scheduler_query, t)`,
-    //         contextually converted to bool, if the tag_invoke expression is
-    //         well formed.
-    //
-    //          - Mandates: The tag_invoke expression is indeed
-    //                      contextually convertible to bool, that expression
-    //                      and the contextual conversion are not potentially-
-    //                      throwing and are core constant expressions if t is
-    //                      a core constant expression.
-    //
-    //     2. Otherwise, false.
-    //
-    HPX_HOST_DEVICE_INLINE_CONSTEXPR_VARIABLE struct
-        forwarding_scheduler_query_t final
-      : hpx::functional::detail::tag_fallback_noexcept<
-            forwarding_scheduler_query_t,
-            detail::contextually_convertible_to_bool<
-                forwarding_scheduler_query_t>>
-    {
-    private:
-        template <typename T>
-        friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(
-            forwarding_scheduler_query_t, T&&) noexcept
-        {
-            return false;
-        }
-    } forwarding_scheduler_query{};
-
-    enum class forward_progress_guarantee
-    {
-        concurrent,
-        parallel,
-        weakly_parallel
-    };
-
-    // 1. `execution::get_forward_progress_guarantee` is used to ask a scheduler
-    //    about the forward progress guarantees of execution agents created by
-    //    that scheduler.
-    //
-    // 2. The name `execution::get_forward_progress_guarantee` denotes a
-    //    customization point object. For some subexpression s, let S be
-    //    decltype((s)).
-    //
-    //      1. If S does not satisfy execution::scheduler,
-    //         execution::get_forward_progress_guarantee is ill-formed. Otherwise,
-    //         execution::get_forward_progress_guarantee(s) is expression equivalent to:
-    //      2. `tag_invoke(execution::get_forward_progress_guarantee, as_const(s))`,
-    //         if this expression is well formed.
-    //
-    //          - Mandates: The tag_invoke expression above is not
-    //                      potentially throwing and its type is
-    //                      execution::forward_progress_guarantee.
-    //
-    //          Otherwise, execution::forward_progress_guarantee::weakly_parallel.
-    //
-    // 3. If `execution::get_forward_progress_guarantee(s)` for some scheduler s
-    //    returns `execution::forward_progress_guarantee::concurrent`, all
-    //    execution agents created by that scheduler shall provide the
-    //    concurrent forward progress guarantee. If it returns
-    //    `execution::forward_progress_guarantee::parallel`, all execution
-    //    agents created by that scheduler shall provide at least the parallel
-    //    forward progress guarantee.
-    //
-    HPX_HOST_DEVICE_INLINE_CONSTEXPR_VARIABLE struct
-        get_forward_progress_guarantee_t final
-      : hpx::functional::detail::tag_fallback_noexcept<
-            get_forward_progress_guarantee_t>
-    {
-        template <typename T>
-        friend constexpr HPX_FORCEINLINE forward_progress_guarantee
-        tag_fallback_invoke(get_forward_progress_guarantee_t,
-            hpx::util::unwrap_reference<T> const&) noexcept
-        {
-            return forward_progress_guarantee::weakly_parallel;
-        }
-    } get_forward_progress_guarantee{};
-
-    // 1. execution::get_scheduler is used to ask an object for its associated
-    //    scheduler.
-    //
-    // 2. The name execution::get_scheduler denotes a customization point object.
-    //    For some subexpression r, if the type of r is (possibly cv-qualified)
-    //    no_env, then execution::get_scheduler(r) is ill-formed.
-    //
-    //    Otherwise, it is expression equivalent to:
-    //
-    //    1. tag_invoke(execution::get_scheduler, as_const(r)), if this expression
-    //       is well formed.
-    //
-    //       Mandates: The tag_invoke expression above is not potentially-
-    //                 throwing and its type satisfies execution::scheduler.
-    //
-    //    2. Otherwise, execution::get_scheduler(r) is ill-formed.
-    //
-    // 3. execution::get_scheduler() (with no arguments) is expression-equivalent
-    //    to execution::read(execution::get_scheduler).
-    //
-    inline constexpr struct get_scheduler_t final
-      : hpx::functional::detail::tag_fallback<get_scheduler_t>
-    {
-    private:
-        friend inline constexpr auto tag_fallback_invoke(
-            get_scheduler_t) noexcept;
-
-    } get_scheduler{};
-
-    constexpr auto tag_fallback_invoke(get_scheduler_t) noexcept
-    {
-        return hpx::execution::experimental::read(get_scheduler);
-    }
-}    // namespace hpx::execution::experimental
-
-#endif
diff --git a/libs/core/execution/include/hpx/execution/queries/get_stop_token.hpp b/libs/core/execution/include/hpx/execution/queries/get_stop_token.hpp
index 3dc010b00a34..e0528d661c30 100644
--- a/libs/core/execution/include/hpx/execution/queries/get_stop_token.hpp
+++ b/libs/core/execution/include/hpx/execution/queries/get_stop_token.hpp
@@ -7,65 +7,4 @@
 #pragma once
 
 #include <hpx/config.hpp>
-#if defined(HPX_HAVE_STDEXEC)
 #include <hpx/execution_base/stdexec_forward.hpp>
-#else
-#include <hpx/execution/queries/read.hpp>
-#include <hpx/execution_base/get_env.hpp>
-#include <hpx/functional/detail/tag_fallback_invoke.hpp>
-#include <hpx/synchronization/stop_token.hpp>
-
-#include <type_traits>
-#include <utility>
-
-namespace hpx::execution::experimental {
-
-    // 1. execution::get_stop_token is used to ask an object for an
-    //    associated stop token.
-    //
-    // 2. The name execution::get_stop_token denotes a customization
-    //    point object. For some subexpression r, if the type of r is
-    //    (possibly cv-qualified) no_env, then execution::get_stop_token(r)
-    //    is ill-formed.
-    //    Otherwise, it is expression equivalent to:
-    //
-    //    1. tag_invoke(execution::get_stop_token, as_const(r)), if this
-    //       expression is well formed.
-    //
-    //          Mandates: The tag_invoke expression above is not potentially
-    //          -throwing and its type satisfies stoppable_token.
-    //
-    //    2. Otherwise, never_stop_token{}.
-    //
-    // 3.  execution::get_stop_token() (with no arguments) is expression-
-    //     equivalent to execution::read(execution::get_stop_token).
-    //
-    HPX_HOST_DEVICE_INLINE_CONSTEXPR_VARIABLE struct get_stop_token_t final
-      : hpx::functional::detail::tag_fallback<get_stop_token_t>
-    {
-    private:
-        template <typename Env>
-        friend inline constexpr auto tag_fallback_invoke(
-            get_stop_token_t, Env&&) noexcept
-        {
-            return hpx::experimental::never_stop_token();
-        }
-
-        friend inline constexpr auto tag_fallback_invoke(
-            get_stop_token_t) noexcept;
-
-    } get_stop_token{};
-
-    constexpr auto tag_fallback_invoke(get_stop_token_t) noexcept
-    {
-        return hpx::execution::experimental::read(get_stop_token);
-    }
-
-    // Helper template allowing to extract the type of a stop_token extracted
-    // from a receiver environment.
-    template <typename T>
-    using stop_token_of_t = std::remove_cv_t<
-        std::remove_reference_t<decltype(get_stop_token(std::declval<T>()))>>;
-}    // namespace hpx::execution::experimental
-
-#endif
diff --git a/libs/core/execution/include/hpx/execution/queries/read.hpp b/libs/core/execution/include/hpx/execution/queries/read.hpp
index 220674a95d14..6b113d961c20 100644
--- a/libs/core/execution/include/hpx/execution/queries/read.hpp
+++ b/libs/core/execution/include/hpx/execution/queries/read.hpp
@@ -8,163 +8,4 @@
 
 #include <hpx/config.hpp>
 
-#if defined(HPX_HAVE_STDEXEC)
 #include <hpx/execution_base/stdexec_forward.hpp>
-#else
-
-#include <hpx/errors/try_catch_exception_ptr.hpp>
-#include <hpx/execution_base/completion_signatures.hpp>
-#include <hpx/execution_base/get_env.hpp>
-#include <hpx/execution_base/receiver.hpp>
-#include <hpx/execution_base/sender.hpp>
-#include <hpx/functional/invoke_result.hpp>
-#include <hpx/functional/tag_invoke.hpp>
-#include <hpx/functional/traits/is_invocable.hpp>
-#include <hpx/type_support/pack.hpp>
-
-#include <cstddef>
-#include <exception>
-#include <stdexcept>
-#include <utility>
-
-namespace hpx::execution::experimental {
-
-    namespace detail {
-
-        template <typename Tag>
-        struct read_sender
-        {
-            constexpr read_sender() = default;
-
-            read_sender(read_sender&&) = default;
-            read_sender(read_sender const&) = default;
-            read_sender& operator=(read_sender&&) = default;
-            read_sender& operator=(read_sender const&) = default;
-
-            template <typename Receiver>
-            struct operation_state
-            {
-                HPX_NO_UNIQUE_ADDRESS std::decay_t<Receiver> receiver;
-
-                template <typename Receiver_>
-                explicit operation_state(Receiver_&& receiver) noexcept
-                  : receiver(HPX_FORWARD(Receiver_, receiver))
-                {
-                }
-
-                operation_state(operation_state&&) = delete;
-                operation_state& operator=(operation_state&&) = delete;
-                operation_state(operation_state const&) = delete;
-                operation_state& operator=(operation_state const&) = delete;
-
-                friend void tag_invoke(start_t, operation_state& os) noexcept
-                {
-                    hpx::detail::try_catch_exception_ptr(
-                        [&]() {
-                            auto env = hpx::execution::experimental::get_env(
-                                os.receiver);
-                            hpx::execution::experimental::set_value(
-                                HPX_MOVE(os.receiver), Tag()(HPX_MOVE(env)));
-                        },
-                        [&](std::exception_ptr ep) {
-                            hpx::execution::experimental::set_error(
-                                HPX_MOVE(os.receiver), HPX_MOVE(ep));
-                        });
-                }
-            };
-
-            template <typename Receiver>
-            friend auto tag_invoke(
-                connect_t, read_sender&&, Receiver&& receiver) noexcept
-            {
-                return operation_state<Receiver>{
-                    HPX_FORWARD(Receiver, receiver)};
-            }
-
-            template <typename Receiver>
-            friend auto tag_invoke(
-                connect_t, read_sender&, Receiver&& receiver) noexcept
-            {
-                return operation_state<Receiver>{
-                    HPX_FORWARD(Receiver, receiver)};
-            }
-
-            // clang-format off
-            template <typename Tag1>
-            friend auto tag_invoke(get_completion_signatures_t,
-                read_sender<Tag1>,
-                no_env) -> dependent_completion_signatures<no_env>;
-
-            template <typename Env>
-            friend auto tag_invoke(get_completion_signatures_t, read_sender, Env)
-            {
-                if constexpr (hpx::is_nothrow_invocable_v<Tag, Env>)
-                {
-                    using result_type =
-                        completion_signatures<
-                            set_value_t(hpx::util::invoke_result<Tag, Env>)>;
-                    return result_type{};
-                }
-                else if constexpr (hpx::is_invocable_v<Tag, Env>)
-                {
-                    using result_type =
-                        completion_signatures<
-                            set_value_t(hpx::util::invoke_result<Tag, Env>),
-                            set_error_t(std::exception_ptr)>;
-                    return result_type{};
-                }
-                else
-                {
-                    return dependent_completion_signatures<Env>{};
-                }
-            }
-            // clang-format on
-        };
-    }    // namespace detail
-
-    // execution::read is used to create a sender that retrieves a value from
-    // the receiver's associated environment and sends it back to the receiver
-    // through the value channel.
-    //
-    // execution::read is a customization point object of an unspecified class
-    // type
-    //
-    // Returns a sender that reaches into a receiver's environment and pulls out
-    // the current value associated with the customization point denoted by Tag.
-    // It then sends the value read back to the receiver through the value
-    // channel. For instance, get_scheduler() (with no arguments) is a sender
-    // that asks the receiver for the currently suggested scheduler and passes
-    // it to the receiver's set_value completion-signal.
-    //
-    // This can be useful when scheduling nested dependent work. The following
-    // sender pulls the current scheduler into the value channel and then
-    // schedules more work onto it. E.g.
-    //
-    //  execution::sender auto task =
-    //      execution::get_scheduler()
-    //        | execution::let_value(
-    //              [](auto sched) {
-    //                  return execution::on(sched, some nested work here);
-    //              });
-    //
-    //  this_thread::sync_wait(std::move(task));    // wait for it to finish
-    //
-    // This code uses the fact that sync_wait associates a scheduler with the
-    // receiver that it connects with task. get_scheduler() reads that scheduler
-    // out of the receiver, and passes it to let_value's receiver's set_value
-    // function, which in turn passes it to the lambda. That lambda returns a
-    // new sender that uses the scheduler to schedule some nested work onto
-    // sync_wait's scheduler.
-    //
-    inline constexpr struct read_t final : hpx::functional::tag<read_t>
-    {
-    private:
-        template <typename Tag>
-        friend constexpr auto tag_invoke(read_t, Tag) noexcept
-        {
-            return detail::read_sender<Tag>{};
-        }
-    } read{};
-}    // namespace hpx::execution::experimental
-
-#endif
diff --git a/libs/core/execution/src/run_loop.cpp b/libs/core/execution/src/run_loop.cpp
index 6d3cde73eef1..a57fab2d6027 100644
--- a/libs/core/execution/src/run_loop.cpp
+++ b/libs/core/execution/src/run_loop.cpp
@@ -5,22 +5,3 @@
 //  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include <hpx/execution/algorithms/run_loop.hpp>
-
-#if !defined(HPX_HAVE_STDEXEC)
-///////////////////////////////////////////////////////////////////////////////
-namespace hpx::execution::experimental::detail {
-
-    void intrusive_ptr_add_ref(run_loop_data* p) noexcept
-    {
-        ++p->count_;
-    }
-
-    void intrusive_ptr_release(run_loop_data* p) noexcept
-    {
-        if (0 == --p->count_)
-        {
-            delete p;
-        }
-    }
-}    // namespace hpx::execution::experimental::detail
-#endif
diff --git a/libs/core/execution/tests/unit/algorithm_as_sender.cpp b/libs/core/execution/tests/unit/algorithm_as_sender.cpp
index 79f65232fa86..cff9a777e4ec 100644
--- a/libs/core/execution/tests/unit/algorithm_as_sender.cpp
+++ b/libs/core/execution/tests/unit/algorithm_as_sender.cpp
@@ -30,11 +30,7 @@ int hpx_main()
         auto s = ex::as_sender(std::move(fut));
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<int>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
@@ -54,11 +50,7 @@ int hpx_main()
         auto s = ex::as_sender(std::move(fut));
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
@@ -78,11 +70,7 @@ int hpx_main()
         auto s = ex::as_sender(sf);
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<int>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
@@ -102,11 +90,7 @@ int hpx_main()
         auto s = ex::as_sender(sf);
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
@@ -128,11 +112,7 @@ int hpx_main()
         auto s = ex::as_sender(std::move(fut));
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<int>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
@@ -155,11 +135,7 @@ int hpx_main()
         auto s = ex::as_sender(std::move(fut));
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<int>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
diff --git a/libs/core/execution/tests/unit/algorithm_bulk.cpp b/libs/core/execution/tests/unit/algorithm_bulk.cpp
index 9a271530f6f4..4551cf50b802 100644
--- a/libs/core/execution/tests/unit/algorithm_bulk.cpp
+++ b/libs/core/execution/tests/unit/algorithm_bulk.cpp
@@ -59,11 +59,7 @@ int main()
         });
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
@@ -87,11 +83,7 @@ int main()
         });
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<int>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
@@ -117,11 +109,7 @@ int main()
             });
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<
             hpx::variant<hpx::tuple<custom_type_non_default_constructible>>>(s);
@@ -147,11 +135,7 @@ int main()
             });
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<
             hpx::tuple<custom_type_non_default_constructible_non_copyable>>>(s);
@@ -172,11 +156,7 @@ int main()
         auto s1 = ex::bulk(ex::just(42), 10, [](int, int x) { return ++x; });
 
         static_assert(ex::is_sender_v<decltype(s1)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s1), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s1), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<int>>>(s1);
         check_error_types<hpx::variant<std::exception_ptr>>(s1);
@@ -186,11 +166,7 @@ int main()
         auto s2 = ex::bulk(std::move(s1), 10, f);
 
         static_assert(ex::is_sender_v<decltype(s2)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s2), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s2), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<int>>>(s2);
         check_error_types<hpx::variant<std::exception_ptr>>(s2);
@@ -199,11 +175,7 @@ int main()
         auto s3 = ex::bulk(std::move(s2), 10, f);
 
         static_assert(ex::is_sender_v<decltype(s3)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s3), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s3), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<int>>>(s3);
         check_error_types<hpx::variant<std::exception_ptr>>(s3);
@@ -212,11 +184,7 @@ int main()
         auto s4 = ex::bulk(std::move(s3), 10, f);
 
         static_assert(ex::is_sender_v<decltype(s4)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s4), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s4), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<int>>>(s4);
         check_error_types<hpx::variant<std::exception_ptr>>(s4);
@@ -239,11 +207,7 @@ int main()
             ex::bulk(10, f) | ex::bulk(10, f);
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<int>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
@@ -269,11 +233,7 @@ int main()
                 false});
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
@@ -296,11 +256,7 @@ int main()
             ex::just(), 0, [](int) { throw std::runtime_error("error"); });
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
@@ -321,11 +277,7 @@ int main()
         });
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
@@ -352,11 +304,7 @@ int main()
             ex::bulk(std::move(s3), 10, [](int, int) { HPX_TEST(false); });
 
         static_assert(ex::is_sender_v<decltype(s4)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s4), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s4), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<int>>>(s4);
         check_error_types<hpx::variant<std::exception_ptr>>(s4);
@@ -380,11 +328,7 @@ int main()
                 true});
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
diff --git a/libs/core/execution/tests/unit/algorithm_ensure_started.cpp b/libs/core/execution/tests/unit/algorithm_ensure_started.cpp
index a0e665bb2a6d..c119f558dacf 100644
--- a/libs/core/execution/tests/unit/algorithm_ensure_started.cpp
+++ b/libs/core/execution/tests/unit/algorithm_ensure_started.cpp
@@ -38,11 +38,7 @@ int main()
         auto s1 = ex::then(void_sender{}, [&]() { started = true; });
         auto s2 = ex::ensure_started(std::move(s1));
         static_assert(ex::is_sender_v<decltype(s2)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s2), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s2), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s2);
         check_error_types<hpx::variant<std::exception_ptr>>(s2);
@@ -65,18 +61,10 @@ int main()
         });
         auto s2 = ex::ensure_started(std::move(s1));
         static_assert(ex::is_sender_v<decltype(s2)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s2), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s2), ex::empty_env>);
-#endif
 
-#if defined(HPX_HAVE_STDEXEC)
         // Passes by value
         check_value_types<hpx::variant<hpx::tuple<int>>>(s2);
-#else
-        check_value_types<hpx::variant<hpx::tuple<int const&>>>(s2);
-#endif
         check_error_types<hpx::variant<std::exception_ptr>>(s2);
         check_sends_stopped<true>(s2);
 
@@ -98,20 +86,11 @@ int main()
             });
         auto s2 = ex::ensure_started(std::move(s1));
         static_assert(ex::is_sender_v<decltype(s2)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s2), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s2), ex::empty_env>);
-#endif
 
-#if defined(HPX_HAVE_STDEXEC)
         check_value_types<
             hpx::variant<hpx::tuple<custom_type_non_default_constructible>>>(
             s2);
-#else
-        check_value_types<hpx::variant<
-            hpx::tuple<custom_type_non_default_constructible const&>>>(s2);
-#endif
         check_error_types<hpx::variant<std::exception_ptr>>(s2);
         check_sends_stopped<true>(s2);
 
@@ -134,33 +113,19 @@ int main()
             });
         auto s2 = ex::ensure_started(std::move(s1));
         static_assert(ex::is_sender_v<decltype(s2)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s2), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s2), ex::empty_env>);
-#endif
 
-#if defined(HPX_HAVE_STDEXEC)
         // custom_type_non_default_constructible_non_copyable Will be move constructed
         check_value_types<hpx::variant<
             hpx::tuple<custom_type_non_default_constructible_non_copyable>>>(
             s2);
         check_error_types<hpx::variant<std::exception_ptr>>(s2);
-#else
-        check_value_types<hpx::variant<hpx::tuple<
-            custom_type_non_default_constructible_non_copyable const&>>>(s2);
-        check_error_types<hpx::variant<std::exception_ptr>>(s2);
-#endif
         check_sends_stopped<true>(s2);
 
         HPX_TEST(started);
         auto f = [](auto& x) { HPX_TEST_EQ(x.x, 42); };
         auto r = callback_receiver<decltype(f)>{f, set_value_called};
-#if defined(HPX_HAVE_STDEXEC)
         auto os = ex::connect(std::move(s2) | ex::split(), std::move(r));
-#else
-        auto os = ex::connect(std::move(s2), std::move(r));
-#endif
         ex::start(os);
         HPX_TEST(set_value_called);
     }
@@ -170,11 +135,7 @@ int main()
         std::atomic<bool> set_value_called{false};
         auto s = void_sender{} | ex::ensure_started();
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
@@ -194,11 +155,7 @@ int main()
         auto s = custom_sender_tag_invoke{tag_invoke_overload_called} |
             ex::ensure_started();
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         // custom_sender_tag_invoke implements tag_invoke(split_t, ...)
         // returning an instance of void_sender
@@ -219,11 +176,7 @@ int main()
         std::atomic<bool> set_error_called{false};
         auto s = error_sender{} | ex::ensure_started();
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
@@ -241,11 +194,7 @@ int main()
         auto s = error_sender{} | ex::ensure_started() | ex::ensure_started() |
             ex::ensure_started();
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
@@ -263,28 +212,15 @@ int main()
         std::atomic<bool> receiver_set_value_called{false};
         auto s1 = ex::just() | ex::ensure_started();
         static_assert(ex::is_sender_v<decltype(s1)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s1), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s1), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s1);
         check_error_types<hpx::variant<std::exception_ptr>>(s1);
         check_sends_stopped<true>(s1);
 
-#if defined(HPX_HAVE_STDEXEC)
         auto s2 = ex::ensure_started(std::move(s1));
-#else
-        auto s2 = ex::ensure_started(s1);
-        HPX_TEST_EQ(s1.state, s2.state);
-#endif
         static_assert(ex::is_sender_v<decltype(s2)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s2), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s2), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s2);
         check_error_types<hpx::variant<std::exception_ptr>>(s2);
@@ -292,12 +228,7 @@ int main()
 
         auto s3 = ex::ensure_started(std::move(s2));
         static_assert(ex::is_sender_v<decltype(s3)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s3), ex::empty_env>);
-#else
-        HPX_TEST_EQ(s1.state, s3.state);
-        static_assert(ex::is_sender_v<decltype(s3), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s3);
         check_error_types<hpx::variant<std::exception_ptr>>(s3);
@@ -314,51 +245,24 @@ int main()
         std::atomic<bool> receiver_set_value_called{false};
         auto s1 = ex::just(42) | ex::ensure_started();
         static_assert(ex::is_sender_v<decltype(s1)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s1), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s1), ex::empty_env>);
-#endif
 
-#if defined(HPX_HAVE_STDEXEC)
         check_value_types<hpx::variant<hpx::tuple<int>>>(s1);
-#else
-        check_value_types<hpx::variant<hpx::tuple<int const&>>>(s1);
-#endif
         check_error_types<hpx::variant<std::exception_ptr>>(s1);
         check_sends_stopped<true>(s1);
 
-#if defined(HPX_HAVE_STDEXEC)
         auto s2 = ex::ensure_started(std::move(s1));
-#else
-        auto s2 = ex::ensure_started(s1);
-        HPX_TEST_EQ(s1.state, s2.state);
-#endif
         static_assert(ex::is_sender_v<decltype(s2)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s2), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s2), ex::empty_env>);
-#endif
 
-#if defined(HPX_HAVE_STDEXEC)
         check_value_types<hpx::variant<hpx::tuple<int>>>(s2);
-#else
-        check_value_types<hpx::variant<hpx::tuple<int const&>>>(s2);
-#endif
         check_error_types<hpx::variant<std::exception_ptr>>(s2);
         check_sends_stopped<true>(s2);
 
         auto s3 = ex::ensure_started(std::move(s2));
         static_assert(ex::is_sender_v<decltype(s3)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s3), ex::empty_env>);
         check_value_types<hpx::variant<hpx::tuple<int>>>(s3);
-#else
-        static_assert(ex::is_sender_v<decltype(s3), ex::empty_env>);
-        HPX_TEST_EQ(s1.state, s3.state);
-        check_value_types<hpx::variant<hpx::tuple<int const&>>>(s3);
-#endif
 
         check_error_types<hpx::variant<std::exception_ptr>>(s3);
         check_sends_stopped<true>(s3);
diff --git a/libs/core/execution/tests/unit/algorithm_execute.cpp b/libs/core/execution/tests/unit/algorithm_execute.cpp
index 077ac7e7b14f..91f791d1ac69 100644
--- a/libs/core/execution/tests/unit/algorithm_execute.cpp
+++ b/libs/core/execution/tests/unit/algorithm_execute.cpp
@@ -8,9 +8,7 @@
 #include <hpx/execution/algorithms/execute.hpp>
 #include <hpx/modules/testing.hpp>
 
-#if defined(HPX_HAVE_STDEXEC)
 #include "algorithm_test_utils.hpp"
-#endif
 
 #include <cstddef>
 #include <exception>
@@ -21,12 +19,9 @@ namespace ex = hpx::execution::experimental;
 static std::size_t friend_tag_invoke_schedule_calls = 0;
 static std::size_t tag_invoke_execute_calls = 0;
 
-#if defined(HPX_HAVE_STDEXEC)
 template <typename Scheduler>
-#endif
 struct execute_example_sender
 {
-#if defined(HPX_HAVE_STDEXEC)
     using is_sender = void;
 
     friend env_with_scheduler<Scheduler> tag_invoke(
@@ -34,7 +29,6 @@ struct execute_example_sender
     {
         return {};
     }
-#endif
 
     // clang-format off
     template <typename Env>
@@ -58,11 +52,7 @@ struct execute_example_sender
 
 struct scheduler_1
 {
-#if defined(HPX_HAVE_STDEXEC)
     using my_sender = execute_example_sender<scheduler_1>;
-#else
-    using my_sender = execute_example_sender;
-#endif
 
     friend my_sender tag_invoke(ex::schedule_t, scheduler_1)
     {
@@ -83,11 +73,7 @@ struct scheduler_1
 
 struct scheduler_2
 {
-#if defined(HPX_HAVE_STDEXEC)
     using my_sender = execute_example_sender<scheduler_2>;
-#else
-    using my_sender = execute_example_sender;
-#endif
 
     bool operator==(scheduler_2 const&) const noexcept
     {
@@ -99,13 +85,11 @@ struct scheduler_2
         return false;
     }
 };
-#if defined(HPX_HAVE_STDEXEC)
 scheduler_2::my_sender tag_invoke(ex::schedule_t, scheduler_2)
 {
     ++friend_tag_invoke_schedule_calls;
     return {};
 }
-#endif
 
 template <typename F>
 void tag_invoke(ex::execute_t, scheduler_2, F&&)
diff --git a/libs/core/execution/tests/unit/algorithm_just.cpp b/libs/core/execution/tests/unit/algorithm_just.cpp
index dbc3a78a2526..bb8104d0aa6b 100644
--- a/libs/core/execution/tests/unit/algorithm_just.cpp
+++ b/libs/core/execution/tests/unit/algorithm_just.cpp
@@ -9,11 +9,7 @@
 
 #include <hpx/modules/datastructures.hpp>
 
-#if defined(HPX_HAVE_STDEXEC)
 #include <hpx/execution/algorithms/just.hpp>
-#else
-#include <hpx/modules/execution.hpp>
-#endif
 #include <hpx/modules/testing.hpp>
 
 #include "algorithm_test_utils.hpp"
@@ -33,19 +29,11 @@ int main()
         auto s = ex::just();
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s);
-#if defined(HPX_HAVE_STDEXEC)
         // the just sender does not produce errors in STDEXEC
         check_error_types<hpx::variant<>>(s);
-#else
-        check_error_types<hpx::variant<std::exception_ptr>>(s);
-#endif
         check_sends_stopped<false>(s);
 
         auto f = [] {};
@@ -60,18 +48,10 @@ int main()
         auto s = ex::just(3);
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<int>>>(s);
-#if defined(HPX_HAVE_STDEXEC)
         check_error_types<hpx::variant<>>(s);
-#else
-        check_error_types<hpx::variant<std::exception_ptr>>(s);
-#endif
         check_sends_stopped<false>(s);
 
         auto f = [](int x) { HPX_TEST_EQ(x, 3); };
@@ -87,21 +67,12 @@ int main()
         auto s = ex::just(x);
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
-#if defined(HPX_HAVE_STDEXEC)
         // the just sender decay-copies the value in STDEXEC instead of
         // storing a reference
         check_value_types<hpx::variant<hpx::tuple<int>>>(s);
         check_error_types<hpx::variant<>>(s);
-#else
-        check_value_types<hpx::variant<hpx::tuple<int&>>>(s);
-        check_error_types<hpx::variant<std::exception_ptr>>(s);
-#endif
         check_sends_stopped<false>(s);
 
         auto f = [](int x) { HPX_TEST_EQ(x, 3); };
@@ -116,19 +87,11 @@ int main()
         auto s = ex::just(custom_type_non_default_constructible{42});
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<
             hpx::variant<hpx::tuple<custom_type_non_default_constructible>>>(s);
-#if defined(HPX_HAVE_STDEXEC)
         check_error_types<hpx::variant<>>(s);
-#else
-        check_error_types<hpx::variant<std::exception_ptr>>(s);
-#endif
         check_sends_stopped<false>(s);
 
         auto f = [](auto x) { HPX_TEST_EQ(x.x, 42); };
@@ -144,22 +107,11 @@ int main()
         auto s = ex::just(x);
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
-#if defined(HPX_HAVE_STDEXEC)
         check_value_types<
             hpx::variant<hpx::tuple<custom_type_non_default_constructible>>>(s);
         check_error_types<hpx::variant<>>(s);
-#else
-        check_value_types<
-            hpx::variant<hpx::tuple<custom_type_non_default_constructible&>>>(
-            s);
-        check_error_types<hpx::variant<std::exception_ptr>>(s);
-#endif
         check_sends_stopped<false>(s);
 
         auto f = [](auto x) { HPX_TEST_EQ(x.x, 42); };
@@ -175,19 +127,11 @@ int main()
             ex::just(custom_type_non_default_constructible_non_copyable{42});
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<
             hpx::tuple<custom_type_non_default_constructible_non_copyable>>>(s);
-#if defined(HPX_HAVE_STDEXEC)
         check_error_types<hpx::variant<>>(s);
-#else
-        check_error_types<hpx::variant<std::exception_ptr>>(s);
-#endif
         check_sends_stopped<false>(s);
 
         auto f = [](auto x) { HPX_TEST_EQ(x.x, 42); };
@@ -203,19 +147,11 @@ int main()
         auto s = ex::just(std::move(x));
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<
             hpx::tuple<custom_type_non_default_constructible_non_copyable>>>(s);
-#if defined(HPX_HAVE_STDEXEC)
         check_error_types<hpx::variant<>>(s);
-#else
-        check_error_types<hpx::variant<std::exception_ptr>>(s);
-#endif
         check_sends_stopped<false>(s);
 
         auto f = [](auto x) { HPX_TEST_EQ(x.x, 42); };
@@ -230,18 +166,10 @@ int main()
         auto s = ex::just(std::string("hello"), 3);
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<std::string, int>>>(s);
-#if defined(HPX_HAVE_STDEXEC)
         check_error_types<hpx::variant<>>(s);
-#else
-        check_error_types<hpx::variant<std::exception_ptr>>(s);
-#endif
         check_sends_stopped<false>(s);
 
         auto f = [](std::string s, int x) {
@@ -261,19 +189,10 @@ int main()
         auto s = ex::just(str, x);
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
-#if defined(HPX_HAVE_STDEXEC)
         check_value_types<hpx::variant<hpx::tuple<std::string, int>>>(s);
         check_error_types<hpx::variant<>>(s);
-#else
-        check_value_types<hpx::variant<hpx::tuple<std::string&, int&>>>(s);
-        check_error_types<hpx::variant<std::exception_ptr>>(s);
-#endif
         check_sends_stopped<false>(s);
 
         auto f = [](std::string str, int x) {
diff --git a/libs/core/execution/tests/unit/algorithm_just_error.cpp b/libs/core/execution/tests/unit/algorithm_just_error.cpp
index ba796372d2a9..96b83b9fcdf5 100644
--- a/libs/core/execution/tests/unit/algorithm_just_error.cpp
+++ b/libs/core/execution/tests/unit/algorithm_just_error.cpp
@@ -7,11 +7,7 @@
 
 #include <hpx/config.hpp>
 
-#if defined(HPX_HAVE_STDEXEC)
 #include <hpx/execution/algorithms/just.hpp>
-#else
-#include <hpx/modules/execution.hpp>
-#endif
 
 #include <hpx/modules/testing.hpp>
 
@@ -32,20 +28,11 @@ int main()
         auto s = ex::just_error(std::runtime_error("error"));
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<>>(s);
-#if defined(HPX_HAVE_STDEXEC)
         // no longer throws exceptions in the form std::exception_ptr in STDEXEC
         check_error_types<hpx::variant<std::runtime_error>>(s);
-#else
-        check_error_types<hpx::variant<std::exception_ptr, std::runtime_error>>(
-            s);
-#endif
         check_sends_stopped<false>(s);
 
         auto r = error_callback_receiver<check_exception_ptr>{
diff --git a/libs/core/execution/tests/unit/algorithm_just_stopped.cpp b/libs/core/execution/tests/unit/algorithm_just_stopped.cpp
index dfd0dca84957..6c2655d34314 100644
--- a/libs/core/execution/tests/unit/algorithm_just_stopped.cpp
+++ b/libs/core/execution/tests/unit/algorithm_just_stopped.cpp
@@ -6,11 +6,7 @@
 //  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include <hpx/config.hpp>
-#if defined(HPX_HAVE_STDEXEC)
 #include <hpx/execution/algorithms/just.hpp>
-#else
-#include <hpx/modules/execution.hpp>
-#endif
 #include <hpx/modules/testing.hpp>
 
 #include "algorithm_test_utils.hpp"
@@ -30,18 +26,10 @@ int main()
         auto s = ex::just_stopped();
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<>>(s);
-#if defined(HPX_HAVE_STDEXEC)
         check_error_types<hpx::variant<>>(s);
-#else
-        check_error_types<hpx::variant<std::exception_ptr>>(s);
-#endif
         check_sends_stopped<true>(s);
 
         auto r = expect_stopped_receiver{set_stopped_called};
diff --git a/libs/core/execution/tests/unit/algorithm_let_error.cpp b/libs/core/execution/tests/unit/algorithm_let_error.cpp
index d8e61324a973..90cddccb5c86 100644
--- a/libs/core/execution/tests/unit/algorithm_let_error.cpp
+++ b/libs/core/execution/tests/unit/algorithm_let_error.cpp
@@ -42,11 +42,7 @@ int main()
         });
 
         static_assert(ex::is_sender_v<decltype(s2)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s2), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s2), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s2);
         check_error_types<hpx::variant<std::exception_ptr>>(s2);
@@ -71,19 +67,11 @@ int main()
         });
 
         static_assert(ex::is_sender_v<decltype(s2)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s2), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s2), ex::empty_env>);
-#endif
 
-#if defined(HPX_HAVE_STDEXEC)
         /*TODO: the following is unclear: https://rentry.org/4rzhctgx
          * So this is volatile to internal stdexec changes, and is thus disabled
          * check_value_types<hpx::variant<hpx::tuple<>, hpx::tuple<int>>>(s2);*/
-#else
-        check_value_types<hpx::variant<hpx::tuple<int>, hpx::tuple<>>>(s2);
-#endif
         check_error_types<hpx::variant<std::exception_ptr>>(s2);
         check_sends_stopped<false>(s2);
 
@@ -107,21 +95,11 @@ int main()
         });
 
         static_assert(ex::is_sender_v<decltype(s2)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s2), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s2), ex::empty_env>);
-#endif
 
-#if defined(HPX_HAVE_STDEXEC)
         /* Disabled due to ambiguous order
          * check_value_types<hpx::variant<hpx::tuple<>,
          *   hpx::tuple<custom_type_non_default_constructible>>>(s2); */
-#else
-        check_value_types<hpx::variant<
-            hpx::tuple<custom_type_non_default_constructible>, hpx::tuple<>>>(
-            s2);
-#endif
         check_error_types<hpx::variant<std::exception_ptr>>(s2);
         check_sends_stopped<false>(s2);
 
@@ -146,22 +124,12 @@ int main()
         });
 
         static_assert(ex::is_sender_v<decltype(s2)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s2), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s2), ex::empty_env>);
-#endif
 
-#if defined(HPX_HAVE_STDEXEC)
         /* Disabled due to ambiguous order
          * check_value_types<hpx::variant<hpx::tuple<>,
          *   hpx::tuple<custom_type_non_default_constructible_non_copyable>>>(
          *   s2); */
-#else
-        check_value_types<hpx::variant<
-            hpx::tuple<custom_type_non_default_constructible_non_copyable>,
-            hpx::tuple<>>>(s2);
-#endif
         check_error_types<hpx::variant<std::exception_ptr>>(s2);
         check_sends_stopped<false>(s2);
 
@@ -185,11 +153,7 @@ int main()
         });
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
@@ -213,18 +177,10 @@ int main()
         });
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
-#if defined(HPX_HAVE_STDEXEC)
         /* Disabled due to ambiguous order
          * check_value_types<hpx::variant<hpx::tuple<>, hpx::tuple<int>>>(s); */
-#else
-        check_value_types<hpx::variant<hpx::tuple<int>, hpx::tuple<>>>(s);
-#endif
         check_error_types<hpx::variant<std::exception_ptr>>(s);
         check_sends_stopped<false>(s);
 
@@ -245,11 +201,7 @@ int main()
         HPX_TEST(tag_invoke_overload_called);
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s);
         check_error_types<hpx::variant<>>(s);
@@ -267,19 +219,11 @@ int main()
         });
 
         static_assert(ex::is_sender_v<decltype(s2)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s2), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s2), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<int>>>(s2);
-#if defined(HPX_HAVE_STDEXEC)
         // the returned sender does not throw any errors
         check_error_types<hpx::variant<>>(s2);
-#else
-        check_error_types<hpx::variant<std::exception_ptr>>(s2);
-#endif
         check_sends_stopped<false>(s2);
 
         auto f = [](int x) { HPX_TEST_EQ(x, 42); };
@@ -301,20 +245,12 @@ int main()
         });
 
         static_assert(ex::is_sender_v<decltype(s2)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s2), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s2), ex::empty_env>);
-#endif
 
         check_value_types<
             hpx::variant<hpx::tuple<custom_type_non_default_constructible>>>(
             s2);
-#if defined(HPX_HAVE_STDEXEC)
         check_error_types<hpx::variant<>>(s2);
-#else
-        check_error_types<hpx::variant<std::exception_ptr>>(s2);
-#endif
         check_sends_stopped<false>(s2);
 
         auto f = [](auto x) { HPX_TEST_EQ(x.x, 42); };
@@ -338,20 +274,12 @@ int main()
         });
 
         static_assert(ex::is_sender_v<decltype(s2)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s2), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s2), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<
             hpx::tuple<custom_type_non_default_constructible_non_copyable>>>(
             s2);
-#if defined(HPX_HAVE_STDEXEC)
         check_error_types<hpx::variant<>>(s2);
-#else
-        check_error_types<hpx::variant<std::exception_ptr>>(s2);
-#endif
         check_sends_stopped<false>(s2);
 
         auto f = [](auto x) { HPX_TEST_EQ(x.x, 42); };
diff --git a/libs/core/execution/tests/unit/algorithm_let_stopped.cpp b/libs/core/execution/tests/unit/algorithm_let_stopped.cpp
index f9375e8ea3ad..cc610bd52679 100644
--- a/libs/core/execution/tests/unit/algorithm_let_stopped.cpp
+++ b/libs/core/execution/tests/unit/algorithm_let_stopped.cpp
@@ -41,11 +41,7 @@ int main()
         });
 
         static_assert(ex::is_sender_v<decltype(s2)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s2), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s2), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s2);
         check_error_types<hpx::variant<std::exception_ptr>>(s2);
@@ -69,11 +65,7 @@ int main()
         });
 
         static_assert(ex::is_sender_v<decltype(s2)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s2), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s2), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<>>(s2);
         check_error_types<hpx::variant<std::exception_ptr>>(s2);
@@ -96,11 +88,7 @@ int main()
         });
 
         static_assert(ex::is_sender_v<decltype(s2)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s2), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s2), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<int>>>(s2);
         check_error_types<hpx::variant<std::exception_ptr>>(s2);
@@ -125,11 +113,7 @@ int main()
         });
 
         static_assert(ex::is_sender_v<decltype(s2)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s2), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s2), ex::empty_env>);
-#endif
 
         check_value_types<
             hpx::variant<hpx::tuple<custom_type_non_default_constructible>>>(
@@ -157,11 +141,7 @@ int main()
         });
 
         static_assert(ex::is_sender_v<decltype(s2)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s2), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s2), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<
             hpx::tuple<custom_type_non_default_constructible_non_copyable>>>(
@@ -188,11 +168,7 @@ int main()
         });
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
@@ -215,11 +191,7 @@ int main()
         });
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<int>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
@@ -242,11 +214,7 @@ int main()
         HPX_TEST(tag_invoke_overload_called);
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s);
         check_error_types<hpx::variant<>>(s);
@@ -264,18 +232,10 @@ int main()
         });
 
         static_assert(ex::is_sender_v<decltype(s2)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s2), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s2), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<int>>>(s2);
-#if defined(HPX_HAVE_STDEXEC)
         check_error_types<hpx::variant<>>(s2);
-#else
-        check_error_types<hpx::variant<std::exception_ptr>>(s2);
-#endif
         check_sends_stopped<false>(s2);
 
         auto f = [](int x) { HPX_TEST_EQ(x, 42); };
@@ -297,20 +257,12 @@ int main()
         });
 
         static_assert(ex::is_sender_v<decltype(s2)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s2), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s2), ex::empty_env>);
-#endif
 
         check_value_types<
             hpx::variant<hpx::tuple<custom_type_non_default_constructible>>>(
             s2);
-#if defined(HPX_HAVE_STDEXEC)
         check_error_types<hpx::variant<>>(s2);
-#else
-        check_error_types<hpx::variant<std::exception_ptr>>(s2);
-#endif
         check_sends_stopped<false>(s2);
 
         auto f = [](auto x) { HPX_TEST_EQ(x.x, 42); };
@@ -334,20 +286,12 @@ int main()
         });
 
         static_assert(ex::is_sender_v<decltype(s2)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s2), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s2), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<
             hpx::tuple<custom_type_non_default_constructible_non_copyable>>>(
             s2);
-#if defined(HPX_HAVE_STDEXEC)
         check_error_types<hpx::variant<>>(s2);
-#else
-        check_error_types<hpx::variant<std::exception_ptr>>(s2);
-#endif
         check_sends_stopped<false>(s2);
 
         auto f = [](auto x) { HPX_TEST_EQ(x.x, 42); };
diff --git a/libs/core/execution/tests/unit/algorithm_let_value.cpp b/libs/core/execution/tests/unit/algorithm_let_value.cpp
index 5c4ac967bda3..25692de8061b 100644
--- a/libs/core/execution/tests/unit/algorithm_let_value.cpp
+++ b/libs/core/execution/tests/unit/algorithm_let_value.cpp
@@ -44,11 +44,7 @@ int main()
         });
 
         static_assert(ex::is_sender_v<decltype(s2)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s2), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s2), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s2);
         check_error_types<hpx::variant<std::exception_ptr>>(s2);
@@ -73,11 +69,7 @@ int main()
         });
 
         static_assert(ex::is_sender_v<decltype(s2)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s2), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s2), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<int>>>(s2);
         check_error_types<hpx::variant<std::exception_ptr>>(s2);
@@ -102,11 +94,7 @@ int main()
         });
 
         static_assert(ex::is_sender_v<decltype(s2)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s2), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s2), ex::empty_env>);
-#endif
 
         check_value_types<
             hpx::variant<hpx::tuple<custom_type_non_default_constructible>>>(
@@ -134,11 +122,7 @@ int main()
         });
 
         static_assert(ex::is_sender_v<decltype(s2)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s2), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s2), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<
             hpx::tuple<custom_type_non_default_constructible_non_copyable>>>(
@@ -164,11 +148,7 @@ int main()
         });
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
@@ -192,11 +172,7 @@ int main()
         });
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<int>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
@@ -218,11 +194,7 @@ int main()
         HPX_TEST(tag_invoke_overload_called);
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s);
         check_error_types<hpx::variant<>>(s);
@@ -240,11 +212,7 @@ int main()
         });
 
         static_assert(ex::is_sender_v<decltype(s2)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s2), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s2), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s2);
         check_error_types<hpx::variant<std::exception_ptr>>(s2);
@@ -283,11 +251,7 @@ int main()
         });
 
         static_assert(ex::is_sender_v<decltype(s2)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s2), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s2), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<int>>>(s2);
         check_error_types<hpx::variant<std::exception_ptr>>(s2);
diff --git a/libs/core/execution/tests/unit/algorithm_split.cpp b/libs/core/execution/tests/unit/algorithm_split.cpp
index 06ef9bd73c25..a0c64b2f4ee7 100644
--- a/libs/core/execution/tests/unit/algorithm_split.cpp
+++ b/libs/core/execution/tests/unit/algorithm_split.cpp
@@ -37,19 +37,11 @@ int main()
         auto s1 = void_sender{};
         auto s2 = ex::split(std::move(s1));
         static_assert(ex::is_sender_v<decltype(s2)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s2), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s2), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s2);
-#if defined(HPX_HAVE_STDEXEC)
         // In p2300R8 split's error channel returns a const& of an exception_ptr
         check_error_types<hpx::variant<std::exception_ptr const&>>(s2);
-#else
-        check_error_types<hpx::variant<std::exception_ptr>>(s2);
-#endif
         check_sends_stopped<true>(s2);
 
         auto f = [] {};
@@ -63,30 +55,18 @@ int main()
         std::atomic<bool> set_value_called{false};
         auto s1 = ex::just(0);
         static_assert(ex::is_sender_v<decltype(s1)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s1), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s1), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<int>>>(s1);
-#if defined(HPX_HAVE_STDEXEC)
         // In p2300R8 just does not have an error channel
         check_error_types<hpx::variant<>>(s1);
-#else
-        check_error_types<hpx::variant<std::exception_ptr>>(s1);
-#endif
         check_sends_stopped<false>(s1);
 
         auto s2 = ex::split(std::move(s1));
         static_assert(ex::is_sender_v<decltype(s2)>);
 
         check_value_types<hpx::variant<hpx::tuple<int const&>>>(s2);
-#if defined(HPX_HAVE_STDEXEC)
         check_error_types<hpx::variant<std::exception_ptr const&>>(s2);
-#else
-        check_error_types<hpx::variant<std::exception_ptr>>(s2);
-#endif
         check_sends_stopped<true>(s2);
 
         auto f = [](int x) { HPX_TEST_EQ(x, 0); };
@@ -100,37 +80,21 @@ int main()
         std::atomic<bool> set_value_called{false};
         auto s1 = ex::just(custom_type_non_default_constructible{42});
         static_assert(ex::is_sender_v<decltype(s1)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s1), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s1), ex::empty_env>);
-#endif
 
         check_value_types<
             hpx::variant<hpx::tuple<custom_type_non_default_constructible>>>(
             s1);
-#if defined(HPX_HAVE_STDEXEC)
         check_error_types<hpx::variant<>>(s1);
-#else
-        check_error_types<hpx::variant<std::exception_ptr>>(s1);
-#endif
         check_sends_stopped<false>(s1);
 
         auto s2 = ex::split(std::move(s1));
         static_assert(ex::is_sender_v<decltype(s2)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s2), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s2), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<
             hpx::tuple<custom_type_non_default_constructible const&>>>(s2);
-#if defined(HPX_HAVE_STDEXEC)
         check_error_types<hpx::variant<std::exception_ptr const&>>(s2);
-#else
-        check_error_types<hpx::variant<std::exception_ptr>>(s2);
-#endif
         check_sends_stopped<true>(s2);
 
         auto f = [](auto x) { HPX_TEST_EQ(x.x, 42); };
@@ -145,37 +109,21 @@ int main()
         auto s1 =
             ex::just(custom_type_non_default_constructible_non_copyable{42});
         static_assert(ex::is_sender_v<decltype(s1)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s1), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s1), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<
             hpx::tuple<custom_type_non_default_constructible_non_copyable>>>(
             s1);
-#if defined(HPX_HAVE_STDEXEC)
         check_error_types<hpx::variant<>>(s1);
-#else
-        check_error_types<hpx::variant<std::exception_ptr>>(s1);
-#endif
         check_sends_stopped<false>(s1);
 
         auto s2 = ex::split(std::move(s1));
         static_assert(ex::is_sender_v<decltype(s2)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s2), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s2), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<
             custom_type_non_default_constructible_non_copyable const&>>>(s2);
-#if defined(HPX_HAVE_STDEXEC)
         check_error_types<hpx::variant<std::exception_ptr const&>>(s2);
-#else
-        check_error_types<hpx::variant<std::exception_ptr>>(s2);
-#endif
         check_sends_stopped<true>(s2);
 
         auto f = [](auto& x) { HPX_TEST_EQ(x.x, 42); };
@@ -190,18 +138,10 @@ int main()
         std::atomic<bool> set_value_called{false};
         auto s = void_sender{} | ex::split();
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s);
-#if defined(HPX_HAVE_STDEXEC)
         check_error_types<hpx::variant<std::exception_ptr const&>>(s);
-#else
-        check_error_types<hpx::variant<std::exception_ptr>>(s);
-#endif
         check_sends_stopped<true>(s);
 
         auto f = [] {};
@@ -218,11 +158,7 @@ int main()
         auto s =
             custom_sender_tag_invoke{tag_invoke_overload_called} | ex::split();
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         // custom_sender_tag_invoke implements tag_invoke(split_t, ...)
         // returning an instance of void_sender
@@ -243,18 +179,10 @@ int main()
         std::atomic<bool> set_error_called{false};
         auto s = error_sender{} | ex::split();
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s);
-#if defined(HPX_HAVE_STDEXEC)
         check_error_types<hpx::variant<std::exception_ptr const&>>(s);
-#else
-        check_error_types<hpx::variant<std::exception_ptr>>(s);
-#endif
         check_sends_stopped<true>(s);
 
         auto r = error_callback_receiver<check_exception_ptr>{
@@ -268,18 +196,10 @@ int main()
         std::atomic<bool> set_error_called{false};
         auto s = error_sender{} | ex::split() | ex::split() | ex::split();
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s);
-#if defined(HPX_HAVE_STDEXEC)
         check_error_types<hpx::variant<std::exception_ptr const&>>(s);
-#else
-        check_error_types<hpx::variant<std::exception_ptr>>(s);
-#endif
         check_sends_stopped<true>(s);
 
         auto r = error_callback_receiver<check_exception_ptr>{
@@ -294,58 +214,28 @@ int main()
         std::atomic<bool> receiver_set_value_called{false};
         auto s1 = ex::just() | ex::split();
         static_assert(ex::is_sender_v<decltype(s1)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s1), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s1), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s1);
-#if defined(HPX_HAVE_STDEXEC)
         check_error_types<hpx::variant<std::exception_ptr const&>>(s1);
-#else
-        check_error_types<hpx::variant<std::exception_ptr>>(s1);
-#endif
         check_sends_stopped<true>(s1);
 
         auto s2 = ex::split(s1);
         static_assert(ex::is_sender_v<decltype(s2)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s2), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s2), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s2);
-#if defined(HPX_HAVE_STDEXEC)
         check_error_types<hpx::variant<std::exception_ptr const&>>(s2);
-#else
-        check_error_types<hpx::variant<std::exception_ptr>>(s2);
-#endif
         check_sends_stopped<true>(s2);
 
-#if !defined(HPX_HAVE_STDEXEC)
-        HPX_TEST_EQ(s1.state, s2.state);
-#endif
         auto s3 = ex::split(std::move(s2));
         static_assert(ex::is_sender_v<decltype(s3)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s3), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s3), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s3);
-#if defined(HPX_HAVE_STDEXEC)
         check_error_types<hpx::variant<std::exception_ptr const&>>(s3);
-#else
-        check_error_types<hpx::variant<std::exception_ptr>>(s3);
-#endif
         check_sends_stopped<true>(s3);
 
-#if !defined(HPX_HAVE_STDEXEC)
-        HPX_TEST_EQ(s1.state, s3.state);
-#endif
         auto f = [] {};
         auto r = callback_receiver<decltype(f)>{f, receiver_set_value_called};
         auto os = ex::connect(std::move(s3), std::move(r));
@@ -357,58 +247,28 @@ int main()
         std::atomic<bool> receiver_set_value_called{false};
         auto s1 = ex::just(42) | ex::split();
         static_assert(ex::is_sender_v<decltype(s1)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s1), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s1), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<int const&>>>(s1);
-#if defined(HPX_HAVE_STDEXEC)
         check_error_types<hpx::variant<std::exception_ptr const&>>(s1);
-#else
-        check_error_types<hpx::variant<std::exception_ptr>>(s1);
-#endif
         check_sends_stopped<true>(s1);
 
         auto s2 = ex::split(s1);
         static_assert(ex::is_sender_v<decltype(s2)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s2), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s2), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<int const&>>>(s2);
-#if defined(HPX_HAVE_STDEXEC)
         check_error_types<hpx::variant<std::exception_ptr const&>>(s2);
-#else
-        check_error_types<hpx::variant<std::exception_ptr>>(s2);
-#endif
         check_sends_stopped<true>(s2);
 
-#if !defined(HPX_HAVE_STDEXEC)
-        HPX_TEST_EQ(s1.state, s2.state);
-#endif
         auto s3 = ex::split(std::move(s2));
         static_assert(ex::is_sender_v<decltype(s3)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s3), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s3), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<int const&>>>(s3);
-#if defined(HPX_HAVE_STDEXEC)
         check_error_types<hpx::variant<std::exception_ptr const&>>(s3);
-#else
-        check_error_types<hpx::variant<std::exception_ptr>>(s3);
-#endif
         check_sends_stopped<true>(s3);
 
-#if !defined(HPX_HAVE_STDEXEC)
-        HPX_TEST_EQ(s1.state, s3.state);
-#endif
         auto f = [](int x) { HPX_TEST_EQ(x, 42); };
         auto r = callback_receiver<decltype(f)>{f, receiver_set_value_called};
         auto os = ex::connect(std::move(s3), std::move(r));
diff --git a/libs/core/execution/tests/unit/algorithm_start_detached.cpp b/libs/core/execution/tests/unit/algorithm_start_detached.cpp
index 10b0d029686c..624d53a4c03f 100644
--- a/libs/core/execution/tests/unit/algorithm_start_detached.cpp
+++ b/libs/core/execution/tests/unit/algorithm_start_detached.cpp
@@ -77,23 +77,7 @@ int main()
     }
 
     // operator| overload
-    {
-#if !defined(HPX_HAVE_STDEXEC)
-        // in P2300R8 start detached does not have an operator| as it is a
-        // sender consumer and not a sender adaptor, and only sender adaptors
-        // have operator| overloads
-
-        std::atomic<bool> start_called{false};
-        std::atomic<bool> connect_called{false};
-        std::atomic<bool> tag_invoke_overload_called{false};
-        custom_sender{
-            start_called, connect_called, tag_invoke_overload_called} |
-            ex::start_detached();
-        HPX_TEST(start_called);
-        HPX_TEST(connect_called);
-        HPX_TEST(!tag_invoke_overload_called);
-#endif
-    }
+    {}
 
     // tag_invoke overload
     {
diff --git a/libs/core/execution/tests/unit/algorithm_sync_wait.cpp b/libs/core/execution/tests/unit/algorithm_sync_wait.cpp
index df6f4f91d39c..ca7e40ef1c4e 100644
--- a/libs/core/execution/tests/unit/algorithm_sync_wait.cpp
+++ b/libs/core/execution/tests/unit/algorithm_sync_wait.cpp
@@ -92,25 +92,15 @@ int hpx_main()
         std::atomic<bool> start_called{false};
         std::atomic<bool> connect_called{false};
         std::atomic<bool> tag_invoke_overload_called{false};
-#if defined(HPX_HAVE_STDEXEC)
         tt::sync_wait(custom_sender{
             start_called, connect_called, tag_invoke_overload_called});
-#else
-        custom_sender{
-            start_called, connect_called, tag_invoke_overload_called} |
-            tt::sync_wait();
-#endif
         HPX_TEST(start_called);
         HPX_TEST(connect_called);
         HPX_TEST(!tag_invoke_overload_called);
     }
 
     {
-#if defined(HPX_HAVE_STDEXEC)
         HPX_TEST_EQ(hpx::get<0>(*tt::sync_wait(ex::just(3))), 3);
-#else
-        HPX_TEST_EQ(hpx::get<0>(*(ex::just(3) | tt::sync_wait())), 3);
-#endif
     }
 
     // tag_invoke overload
@@ -118,13 +108,8 @@ int hpx_main()
         std::atomic<bool> start_called{false};
         std::atomic<bool> connect_called{false};
         std::atomic<bool> tag_invoke_overload_called{false};
-#if defined(HPX_HAVE_STDEXEC)
         tt::sync_wait(custom_sender2{custom_sender{
             start_called, connect_called, tag_invoke_overload_called}});
-#else
-        tt::sync_wait(custom_sender2{custom_sender{
-            start_called, connect_called, tag_invoke_overload_called}});
-#endif
         HPX_TEST(!start_called);
         HPX_TEST(!connect_called);
         HPX_TEST(tag_invoke_overload_called);
@@ -148,11 +133,7 @@ int hpx_main()
 
     // cancellation path
     {
-#if defined(HPX_HAVE_STDEXEC)
         auto result = tt::sync_wait(stopped_sender_with_value_type{});
-#else
-        auto result = stopped_sender_with_value_type{} | tt::sync_wait();
-#endif
         HPX_TEST(!result);    // returned optional should be empty
     }
 
diff --git a/libs/core/execution/tests/unit/algorithm_sync_wait_with_variant.cpp b/libs/core/execution/tests/unit/algorithm_sync_wait_with_variant.cpp
index 0528be950e8d..d30c3ded0810 100644
--- a/libs/core/execution/tests/unit/algorithm_sync_wait_with_variant.cpp
+++ b/libs/core/execution/tests/unit/algorithm_sync_wait_with_variant.cpp
@@ -33,13 +33,8 @@ std::optional<std::variant<std::tuple<>>> tag_invoke(
 
 int hpx_main()
 {
-#if defined(HPX_HAVE_STDEXEC)
     using std::tuple;
     using std::variant;
-#else
-    using hpx::tuple;
-    using hpx::variant;
-#endif
     // Success path
     {
         std::atomic<bool> start_called{false};
@@ -71,11 +66,7 @@ int hpx_main()
     }
 
     {
-#if defined(HPX_HAVE_STDEXEC)
         auto result = tt::sync_wait_with_variant(ex::just(3, 4.0));
-#else
-        auto result = ex::just(3, 4.0) | tt::sync_wait_with_variant();
-#endif
 
         auto v = *result;
         static_assert(std::is_same_v<decltype(v), variant<tuple<int, double>>>);
@@ -194,25 +185,16 @@ int hpx_main()
 
         // variant
         auto v = *result;
-#if defined(HPX_HAVE_STDEXEC)
         // just(3) does not have a set_error_r(std::exception_ptr) completion
         // so the just(std::string) completion is never materialized into the
         // let_error's completions
         static_assert(std::is_same_v<decltype(v), variant<tuple<int>>>);
-#else
-        static_assert(std::is_same_v<decltype(v),
-            variant<tuple<std::string>, tuple<int>>>);
-#endif
 
         HPX_TEST(hpx::holds_alternative<tuple<int>>(v));
 
         // tuple
-#if defined(HPX_HAVE_STDEXEC)
         // Now v is just a variant<tuple<int>>
         auto t = hpx::get<0>(v);
-#else
-        auto t = hpx::get<1>(v);
-#endif
         static_assert(std::is_same_v<decltype(t), tuple<int>>);
 
         auto i = hpx::get<0>(t);
@@ -250,25 +232,15 @@ int hpx_main()
         std::atomic<bool> start_called{false};
         std::atomic<bool> connect_called{false};
         std::atomic<bool> tag_invoke_overload_called{false};
-#if defined(HPX_HAVE_STDEXEC)
         tt::sync_wait_with_variant(custom_sender{
             start_called, connect_called, tag_invoke_overload_called});
-#else
-        custom_sender{
-            start_called, connect_called, tag_invoke_overload_called} |
-            tt::sync_wait_with_variant();
-#endif
         HPX_TEST(start_called);
         HPX_TEST(connect_called);
         HPX_TEST(!tag_invoke_overload_called);
     }
 
     {
-#if defined(HPX_HAVE_STDEXEC)
         auto result = tt::sync_wait_with_variant(ex::just(3));
-#else
-        auto result = ex::just(3) | tt::sync_wait_with_variant();
-#endif
 
         auto v = *result;
         static_assert(std::is_same_v<decltype(v), variant<tuple<int>>>);
@@ -313,13 +285,8 @@ int hpx_main()
 
     // cancellation path
     {
-#if defined(HPX_HAVE_STDEXEC)
         auto result =
             tt::sync_wait_with_variant(stopped_sender_with_value_type{});
-#else
-        auto result =
-            (stopped_sender_with_value_type{} | tt::sync_wait_with_variant());
-#endif
         HPX_TEST(!result);    // returned optional should be empty
     }
 
diff --git a/libs/core/execution/tests/unit/algorithm_then.cpp b/libs/core/execution/tests/unit/algorithm_then.cpp
index d21434466036..6d9fdb909ab3 100644
--- a/libs/core/execution/tests/unit/algorithm_then.cpp
+++ b/libs/core/execution/tests/unit/algorithm_then.cpp
@@ -153,11 +153,7 @@ int hpx_main()
         std::atomic<bool> set_value_called{false};
         auto s = ex::then(ex::just(), [] {});
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
@@ -174,11 +170,7 @@ int hpx_main()
         std::atomic<bool> set_value_called{false};
         auto s = ex::then(ex::just(0), [](int x) { return ++x; });
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<int>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
@@ -199,11 +191,7 @@ int hpx_main()
                 return x;
             });
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<
             hpx::variant<hpx::tuple<custom_type_non_default_constructible>>>(s);
@@ -226,11 +214,7 @@ int hpx_main()
                 return std::move(x);
             });
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<
             hpx::tuple<custom_type_non_default_constructible_non_copyable>>>(s);
@@ -248,11 +232,7 @@ int hpx_main()
         std::atomic<bool> set_value_called{false};
         auto s1 = ex::then(ex::just(0), [](int x) { return ++x; });
         static_assert(ex::is_sender_v<decltype(s1)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s1), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s1), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<int>>>(s1);
         check_error_types<hpx::variant<std::exception_ptr>>(s1);
@@ -260,11 +240,7 @@ int hpx_main()
 
         auto s2 = ex::then(std::move(s1), [](int x) { return ++x; });
         static_assert(ex::is_sender_v<decltype(s2)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s2), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s2), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<int>>>(s2);
         check_error_types<hpx::variant<std::exception_ptr>>(s2);
@@ -272,11 +248,7 @@ int hpx_main()
 
         auto s3 = ex::then(std::move(s2), [](int x) { return ++x; });
         static_assert(ex::is_sender_v<decltype(s3)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s3), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s3), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<int>>>(s3);
         check_error_types<hpx::variant<std::exception_ptr>>(s3);
@@ -284,11 +256,7 @@ int hpx_main()
 
         auto s4 = ex::then(std::move(s3), [](int x) { return ++x; });
         static_assert(ex::is_sender_v<decltype(s4)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s4), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s4), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<int>>>(s4);
         check_error_types<hpx::variant<std::exception_ptr>>(s4);
@@ -305,11 +273,7 @@ int hpx_main()
         std::atomic<bool> set_value_called{false};
         auto s1 = ex::then(ex::just(), []() { return 3; });
         static_assert(ex::is_sender_v<decltype(s1)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s1), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s1), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<int>>>(s1);
         check_error_types<hpx::variant<std::exception_ptr>>(s1);
@@ -317,11 +281,7 @@ int hpx_main()
 
         auto s2 = ex::then(std::move(s1), [](int x) { return x / 1.5; });
         static_assert(ex::is_sender_v<decltype(s2)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s2), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s2), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<double>>>(s2);
         check_error_types<hpx::variant<std::exception_ptr>>(s2);
@@ -330,11 +290,7 @@ int hpx_main()
         auto s3 =
             ex::then(std::move(s2), [](double x) -> int { return int(x / 2); });
         static_assert(ex::is_sender_v<decltype(s3)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s3), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s3), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<int>>>(s3);
         check_error_types<hpx::variant<std::exception_ptr>>(s3);
@@ -343,11 +299,7 @@ int hpx_main()
         auto s4 =
             ex::then(std::move(s3), [](int x) { return std::to_string(x); });
         static_assert(ex::is_sender_v<decltype(s4)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s4), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s4), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<std::string>>>(s4);
         check_error_types<hpx::variant<std::exception_ptr>>(s4);
@@ -368,11 +320,7 @@ int hpx_main()
             ex::then([](double x) -> int { return int(x / 2); }) |
             ex::then([](int x) { return std::to_string(x); });
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<std::string>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
@@ -394,11 +342,7 @@ int hpx_main()
             custom_transformer{tag_invoke_overload_called,
                 custom_transformer_call_operator_called, false});
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
@@ -419,11 +363,7 @@ int hpx_main()
         auto s =
             ex::then(ex::just(), [] { throw std::runtime_error("error"); });
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
@@ -440,44 +380,28 @@ int hpx_main()
         std::atomic<bool> set_error_called{false};
         auto s1 = ex::then(ex::just(0), [](int x) { return ++x; });
         static_assert(ex::is_sender_v<decltype(s1)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s1), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s1), ex::empty_env>);
-#endif
 
         auto s2 = ex::then(std::move(s1), [](int x) {
             throw std::runtime_error("error");
             return ++x;
         });
         static_assert(ex::is_sender_v<decltype(s2)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s2), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s2), ex::empty_env>);
-#endif
 
         auto s3 = ex::then(std::move(s2), [](int x) {
             HPX_TEST(false);
             return ++x;
         });
         static_assert(ex::is_sender_v<decltype(s3)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s3), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s3), ex::empty_env>);
-#endif
 
         auto s4 = ex::then(std::move(s3), [](int x) {
             HPX_TEST(false);
             return ++x;
         });
         static_assert(ex::is_sender_v<decltype(s4)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s4), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s4), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<int>>>(s4);
         check_error_types<hpx::variant<std::exception_ptr>>(s4);
@@ -498,11 +422,7 @@ int hpx_main()
             custom_transformer{tag_invoke_overload_called,
                 custom_transformer_call_operator_called, true});
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
diff --git a/libs/core/execution/tests/unit/algorithm_transfer.cpp b/libs/core/execution/tests/unit/algorithm_transfer.cpp
index 4549448936d1..0eedd7b9067f 100644
--- a/libs/core/execution/tests/unit/algorithm_transfer.cpp
+++ b/libs/core/execution/tests/unit/algorithm_transfer.cpp
@@ -68,7 +68,6 @@ struct sender_with_completion_scheduler : void_sender
     {
     }
 
-#if defined(HPX_HAVE_STDEXEC)
     struct my_env
     {
         scheduler_transfer const& sched;
@@ -86,14 +85,6 @@ struct sender_with_completion_scheduler : void_sender
     {
         return {s.sched};
     }
-#else
-    friend scheduler_transfer tag_invoke(
-        ex::get_completion_scheduler_t<ex::set_value_t>,
-        sender_with_completion_scheduler s)
-    {
-        return s.sched;
-    }
-#endif
 
     template <typename Env>
     friend auto tag_invoke(
@@ -115,11 +106,7 @@ int main()
             example_scheduler{scheduler_schedule_called,
                 scheduler_execute_called, tag_invoke_overload_called});
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
@@ -144,11 +131,7 @@ int main()
             example_scheduler{scheduler_schedule_called,
                 scheduler_execute_called, tag_invoke_overload_called});
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<int>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
@@ -174,11 +157,7 @@ int main()
                 example_scheduler{scheduler_schedule_called,
                     scheduler_execute_called, tag_invoke_overload_called});
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<
             hpx::variant<hpx::tuple<custom_type_non_default_constructible>>>(s);
@@ -205,11 +184,7 @@ int main()
             example_scheduler{scheduler_schedule_called,
                 scheduler_execute_called, tag_invoke_overload_called});
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
         check_value_types<hpx::variant<
             hpx::tuple<custom_type_non_default_constructible_non_copyable>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
@@ -234,11 +209,7 @@ int main()
             example_scheduler{scheduler_schedule_called,
                 scheduler_execute_called, tag_invoke_overload_called});
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<std::string, int>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
@@ -267,11 +238,7 @@ int main()
             ex::transfer(example_scheduler{scheduler_schedule_called,
                 scheduler_execute_called, tag_invoke_overload_called});
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<std::string, int>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
@@ -300,11 +267,7 @@ int main()
             scheduler_schedule_from{example_scheduler{scheduler_schedule_called,
                 scheduler_execute_called, tag_invoke_overload_called}});
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
@@ -342,11 +305,7 @@ int main()
             sender_with_completion_scheduler{std::move(source_scheduler)},
             destination_scheduler);
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
@@ -387,11 +346,7 @@ int main()
             sender_with_completion_scheduler{std::move(source_scheduler)},
             destination_scheduler);
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
@@ -420,11 +375,7 @@ int main()
             example_scheduler{scheduler_schedule_called,
                 scheduler_execute_called, tag_invoke_overload_called});
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
@@ -436,12 +387,8 @@ int main()
         ex::start(os);
         HPX_TEST(set_error_called);
         HPX_TEST(!tag_invoke_overload_called);
-#if defined(HPX_HAVE_STDEXEC)
         // schedule is called anyways
         HPX_TEST(scheduler_schedule_called);
-#else
-        HPX_TEST(!scheduler_schedule_called);
-#endif
         HPX_TEST(!scheduler_execute_called);
     }
 
diff --git a/libs/core/execution/tests/unit/algorithm_transfer_just.cpp b/libs/core/execution/tests/unit/algorithm_transfer_just.cpp
index 781a96f96e6c..ce131662f53b 100644
--- a/libs/core/execution/tests/unit/algorithm_transfer_just.cpp
+++ b/libs/core/execution/tests/unit/algorithm_transfer_just.cpp
@@ -39,11 +39,7 @@ int main()
         auto s = ex::transfer_just(example_scheduler{scheduler_schedule_called,
             scheduler_execute_called, tag_invoke_overload_called});
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
@@ -69,11 +65,7 @@ int main()
                 scheduler_execute_called, tag_invoke_overload_called},
             3);
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<int>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
@@ -100,17 +92,9 @@ int main()
                 scheduler_execute_called, tag_invoke_overload_called},
             x);
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
-#if defined(HPX_HAVE_STDEXEC)
         check_value_types<hpx::variant<hpx::tuple<int>>>(s);
-#else
-        check_value_types<hpx::variant<hpx::tuple<int&>>>(s);
-#endif
         check_error_types<hpx::variant<std::exception_ptr>>(s);
         check_sends_stopped<false>(s);
 
@@ -134,11 +118,7 @@ int main()
                 scheduler_execute_called, tag_invoke_overload_called},
             custom_type_non_default_constructible{42});
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<
             hpx::variant<hpx::tuple<custom_type_non_default_constructible>>>(s);
@@ -166,19 +146,9 @@ int main()
                 scheduler_execute_called, tag_invoke_overload_called},
             x);
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
-#if defined(HPX_HAVE_STDEXEC)
         check_value_types<
             hpx::variant<hpx::tuple<custom_type_non_default_constructible>>>(s);
-#else
-        check_value_types<
-            hpx::variant<hpx::tuple<custom_type_non_default_constructible&>>>(
-            s);
-#endif
         check_error_types<hpx::variant<std::exception_ptr>>(s);
         check_sends_stopped<false>(s);
 
@@ -202,11 +172,7 @@ int main()
                 scheduler_execute_called, tag_invoke_overload_called},
             custom_type_non_default_constructible_non_copyable{42});
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<
             hpx::tuple<custom_type_non_default_constructible_non_copyable>>>(s);
@@ -234,11 +200,7 @@ int main()
                 scheduler_execute_called, tag_invoke_overload_called},
             std::move(x));
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<
             hpx::tuple<custom_type_non_default_constructible_non_copyable>>>(s);
@@ -265,11 +227,7 @@ int main()
                 scheduler_execute_called, tag_invoke_overload_called},
             std::string("hello"), 3);
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<std::string, int>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
@@ -300,17 +258,9 @@ int main()
                 scheduler_execute_called, tag_invoke_overload_called},
             str, x);
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
-#if defined(HPX_HAVE_STDEXEC)
         check_value_types<hpx::variant<hpx::tuple<std::string, int>>>(s);
-#else
-        check_value_types<hpx::variant<hpx::tuple<std::string&, int&>>>(s);
-#endif
         check_error_types<hpx::variant<std::exception_ptr>>(s);
         check_sends_stopped<false>(s);
 
@@ -338,11 +288,7 @@ int main()
                 scheduler_execute_called, tag_invoke_overload_called}},
             3);
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<int>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
@@ -369,17 +315,9 @@ int main()
                 scheduler_execute_called, tag_invoke_overload_called}},
             x);
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
-#if defined(HPX_HAVE_STDEXEC)
         check_value_types<hpx::variant<hpx::tuple<int>>>(s);
-#else
-        check_value_types<hpx::variant<hpx::tuple<int&>>>(s);
-#endif
         check_error_types<hpx::variant<std::exception_ptr>>(s);
         check_sends_stopped<false>(s);
 
diff --git a/libs/core/execution/tests/unit/algorithm_transfer_when_all.cpp b/libs/core/execution/tests/unit/algorithm_transfer_when_all.cpp
index a0d22ef6a193..465656dc2e5f 100644
--- a/libs/core/execution/tests/unit/algorithm_transfer_when_all.cpp
+++ b/libs/core/execution/tests/unit/algorithm_transfer_when_all.cpp
@@ -44,12 +44,8 @@ int main()
         static_assert(ex::is_sender_v<decltype(s)>,
             "transfer_when_all must return a sender");
 
-#if defined(HPX_HAVE_STDEXEC)
         auto csch =
             ex::get_completion_scheduler<ex::set_value_t>(ex::get_env(s));
-#else
-        auto csch = ex::get_completion_scheduler<ex::set_value_t>(s);
-#endif
         HPX_TEST(sched == csch);
 
         auto f = [](int x) { HPX_TEST_EQ(x, 42); };
@@ -75,12 +71,8 @@ int main()
         static_assert(ex::is_sender_v<decltype(s)>,
             "transfer_when_all must return a sender");
 
-#if defined(HPX_HAVE_STDEXEC)
         auto csch =
             ex::get_completion_scheduler<ex::set_value_t>(ex::get_env(s));
-#else
-        auto csch = ex::get_completion_scheduler<ex::set_value_t>(s);
-#endif
         HPX_TEST(sched == csch);
 
         auto f = [](int x, std::string y, double z) {
@@ -110,12 +102,8 @@ int main()
         static_assert(ex::is_sender_v<decltype(s)>,
             "transfer_when_all must return a sender");
 
-#if defined(HPX_HAVE_STDEXEC)
         auto csch =
             ex::get_completion_scheduler<ex::set_value_t>(ex::get_env(s));
-#else
-        auto csch = ex::get_completion_scheduler<ex::set_value_t>(s);
-#endif
         HPX_TEST(sched == csch);
 
         auto f = [](std::string y, double z) {
@@ -148,11 +136,7 @@ int main()
 
         HPX_TEST(set_error_called);
         HPX_TEST(!tag_invoke_overload_called);
-#if defined(HPX_HAVE_STDEXEC)
         HPX_TEST(scheduler_schedule_called);
-#else
-        HPX_TEST(!scheduler_schedule_called);
-#endif
         HPX_TEST(!scheduler_execute_called);
     }
 
diff --git a/libs/core/execution/tests/unit/algorithm_when_all.cpp b/libs/core/execution/tests/unit/algorithm_when_all.cpp
index 1705d90b851f..d5e1781f6f8f 100644
--- a/libs/core/execution/tests/unit/algorithm_when_all.cpp
+++ b/libs/core/execution/tests/unit/algorithm_when_all.cpp
@@ -15,11 +15,9 @@
 #include <hpx/modules/execution.hpp>
 #include <hpx/modules/testing.hpp>
 
-#if defined(HPX_HAVE_STDEXEC)
 // TODO: Figure out why this is necessary for stdexec
 // but causes dataflow to be unresolvable without stdexec
 #include <hpx/execution/algorithms/when_all.hpp>
-#endif
 
 #include "algorithm_test_utils.hpp"
 
@@ -49,19 +47,11 @@ int main()
         auto s = ex::when_all(ex::just(42));
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<int>>>(s);
-#if defined(HPX_HAVE_STDEXEC)
         // everything is noexcept and no errors can be made here
         check_error_types<hpx::variant<>>(s);
-#else
-        check_error_types<hpx::variant<std::exception_ptr>>(s);
-#endif
         check_sends_stopped<true>(s);
 
         auto f = [](int x) { HPX_TEST_EQ(x, 42); };
@@ -77,19 +67,11 @@ int main()
             ex::just(42), ex::just(std::string("hello")), ex::just(3.14));
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<int, std::string, double>>>(
             s);
-#if defined(HPX_HAVE_STDEXEC)
         check_error_types<hpx::variant<>>(s);
-#else
-        check_error_types<hpx::variant<std::exception_ptr>>(s);
-#endif
         check_sends_stopped<true>(s);
 
         auto f = [](int x, std::string y, double z) {
@@ -109,18 +91,10 @@ int main()
             ex::just(), ex::just(std::string("hello")), ex::just(3.14));
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<std::string, double>>>(s);
-#if defined(HPX_HAVE_STDEXEC)
         check_error_types<hpx::variant<>>(s);
-#else
-        check_error_types<hpx::variant<std::exception_ptr>>(s);
-#endif
         check_sends_stopped<true>(s);
 
         auto f = [](std::string y, double z) {
@@ -138,18 +112,10 @@ int main()
         auto s = ex::when_all(ex::just(42), ex::just(), ex::just(3.14));
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<int, double>>>(s);
-#if defined(HPX_HAVE_STDEXEC)
         check_error_types<hpx::variant<>>(s);
-#else
-        check_error_types<hpx::variant<std::exception_ptr>>(s);
-#endif
         check_sends_stopped<true>(s);
 
         auto f = [](int x, double z) {
@@ -167,18 +133,10 @@ int main()
         auto s = ex::when_all(ex::just(), ex::just(), ex::just());
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s);
-#if defined(HPX_HAVE_STDEXEC)
         check_error_types<hpx::variant<>>(s);
-#else
-        check_error_types<hpx::variant<std::exception_ptr>>(s);
-#endif
         check_sends_stopped<true>(s);
 
         auto f = []() {};
@@ -194,18 +152,10 @@ int main()
             ex::just(42), ex::just(std::string("hello")), ex::just());
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<int, std::string>>>(s);
-#if defined(HPX_HAVE_STDEXEC)
         check_error_types<hpx::variant<>>(s);
-#else
-        check_error_types<hpx::variant<std::exception_ptr>>(s);
-#endif
         check_sends_stopped<true>(s);
 
         auto f = [](int x, std::string y) {
@@ -223,19 +173,11 @@ int main()
         auto s = ex::when_all(ex::just(42, std::string("hello"), 3.14));
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<int, std::string, double>>>(
             s);
-#if defined(HPX_HAVE_STDEXEC)
         check_error_types<hpx::variant<>>(s);
-#else
-        check_error_types<hpx::variant<std::exception_ptr>>(s);
-#endif
         check_sends_stopped<true>(s);
 
         auto f = [](int x, std::string y, double z) {
@@ -255,19 +197,11 @@ int main()
             ex::when_all(ex::just(42, std::string("hello")), ex::just(3.14));
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<int, std::string, double>>>(
             s);
-#if defined(HPX_HAVE_STDEXEC)
         check_error_types<hpx::variant<>>(s);
-#else
-        check_error_types<hpx::variant<std::exception_ptr>>(s);
-#endif
         check_sends_stopped<true>(s);
 
         auto f = [](int x, std::string y, double z) {
@@ -287,18 +221,10 @@ int main()
             ex::just(), ex::just(3.14), ex::just());
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
         check_value_types<hpx::variant<hpx::tuple<int, std::string, double>>>(
             s);
-#if defined(HPX_HAVE_STDEXEC)
         check_error_types<hpx::variant<>>(s);
-#else
-        check_error_types<hpx::variant<std::exception_ptr>>(s);
-#endif
         check_sends_stopped<true>(s);
 
         auto f = [](int x, std::string y, double z) {
@@ -318,18 +244,10 @@ int main()
             ex::when_all(ex::just(custom_type_non_default_constructible(42)));
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
         check_value_types<
             hpx::variant<hpx::tuple<custom_type_non_default_constructible>>>(s);
-#if defined(HPX_HAVE_STDEXEC)
         check_error_types<hpx::variant<>>(s);
-#else
-        check_error_types<hpx::variant<std::exception_ptr>>(s);
-#endif
         check_sends_stopped<true>(s);
 
         auto f = [](auto x) { HPX_TEST_EQ(x.x, 42); };
@@ -345,18 +263,10 @@ int main()
             ex::just(custom_type_non_default_constructible_non_copyable(42)));
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
         check_value_types<hpx::variant<
             hpx::tuple<custom_type_non_default_constructible_non_copyable>>>(s);
-#if defined(HPX_HAVE_STDEXEC)
         check_error_types<hpx::variant<>>(s);
-#else
-        check_error_types<hpx::variant<std::exception_ptr>>(s);
-#endif
         check_sends_stopped<true>(s);
 
         auto f = [](auto x) { HPX_TEST_EQ(x.x, 42); };
@@ -373,17 +283,9 @@ int main()
             custom_sender_tag_invoke{tag_invoke_overload_called}, ex::just(42));
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
         check_value_types<hpx::variant<hpx::tuple<int>>>(s);
-#if defined(HPX_HAVE_STDEXEC)
         check_error_types<hpx::variant<>>(s);
-#else
-        check_error_types<hpx::variant<std::exception_ptr>>(s);
-#endif
         check_sends_stopped<true>(s);
 
         auto f = [](int x) { HPX_TEST_EQ(x, 42); };
@@ -400,11 +302,7 @@ int main()
         auto s = ex::when_all(error_typed_sender<double>{});
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
         check_value_types<hpx::variant<hpx::tuple<double>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
         check_sends_stopped<true>(s);
@@ -421,11 +319,7 @@ int main()
         auto s = ex::when_all(ex::just(42), error_typed_sender<double>{});
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<int, double>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
@@ -443,11 +337,7 @@ int main()
         auto s = ex::when_all(error_typed_sender<double>{}, ex::just(42));
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<double, int>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
@@ -460,129 +350,6 @@ int main()
         HPX_TEST(set_error_called);
     }
 
-#if !defined(HPX_HAVE_STDEXEC)
-    // Dataflow success path
-    {
-        std::atomic<bool> set_value_called{false};
-        std::atomic<bool> then_called{false};
-        auto s = hpx::dataflow(
-            [&](int x) {
-                then_called = true;
-                HPX_TEST_EQ(x, 42);
-                return x;
-            },
-            ex::just(42));
-
-        static_assert(ex::is_sender_v<decltype(s)>);
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-
-        check_value_types<hpx::variant<hpx::tuple<int>>>(s);
-        check_error_types<hpx::variant<std::exception_ptr>>(s);
-        check_sends_stopped<true>(s);
-
-        auto f = [](int x) { HPX_TEST_EQ(x, 42); };
-        auto r = callback_receiver<decltype(f)>{f, set_value_called};
-        auto os = ex::connect(std::move(s), std::move(r));
-        tag_invoke(ex::start, os);
-        HPX_TEST(then_called);
-        HPX_TEST(set_value_called);
-    }
-
-    {
-        std::atomic<bool> set_value_called{false};
-        std::atomic<bool> then_called{false};
-        auto s = hpx::dataflow(
-            [&](int x, std::string y, double z) {
-                then_called = true;
-                HPX_TEST_EQ(x, 42);
-                HPX_TEST_EQ(y, std::string("hello"));
-                HPX_TEST_EQ(z, 3.14);
-                return hpx::make_tuple(x, y, z);
-            },
-            ex::just(42), ex::just(std::string("hello")), ex::just(3.14));
-
-        static_assert(ex::is_sender_v<decltype(s)>);
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-
-        check_value_types<
-            hpx::variant<hpx::tuple<hpx::tuple<int, std::string, double>>>>(s);
-        check_error_types<hpx::variant<std::exception_ptr>>(s);
-        check_sends_stopped<true>(s);
-
-        auto f = [](hpx::tuple<int, std::string, double> t) {
-            HPX_TEST_EQ(t.get<0>(), 42);
-            HPX_TEST_EQ(t.get<1>(), std::string("hello"));
-            HPX_TEST_EQ(t.get<2>(), 3.14);
-        };
-        auto r = callback_receiver<decltype(f)>{f, set_value_called};
-        auto os = ex::connect(std::move(s), std::move(r));
-        ex::start(os);
-        HPX_TEST(then_called);
-        HPX_TEST(set_value_called);
-    }
-
-    {
-        std::atomic<bool> set_value_called{false};
-        std::atomic<bool> then_called{false};
-        auto s = hpx::dataflow(
-            [&](std::string y, double z) {
-                then_called = true;
-                HPX_TEST_EQ(y, std::string("hello"));
-                HPX_TEST_EQ(z, 3.14);
-                return hpx::make_tuple(y, z);
-            },
-            ex::just(), ex::just(std::string("hello")), ex::just(3.14));
-
-        static_assert(ex::is_sender_v<decltype(s)>);
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-
-        check_value_types<
-            hpx::variant<hpx::tuple<hpx::tuple<std::string, double>>>>(s);
-        check_error_types<hpx::variant<std::exception_ptr>>(s);
-        check_sends_stopped<true>(s);
-
-        auto f = [](hpx::tuple<std::string, double> t) {
-            HPX_TEST_EQ(t.get<0>(), std::string("hello"));
-            HPX_TEST_EQ(t.get<1>(), 3.14);
-        };
-        auto r = callback_receiver<decltype(f)>{f, set_value_called};
-        auto os = ex::connect(std::move(s), std::move(r));
-        ex::start(os);
-        HPX_TEST(then_called);
-        HPX_TEST(set_value_called);
-    }
-
-    {
-        std::atomic<bool> set_value_called{false};
-        std::atomic<bool> then_called{false};
-        auto s = hpx::dataflow(
-            [&](int x, double z) {
-                then_called = true;
-                HPX_TEST_EQ(x, 42);
-                HPX_TEST_EQ(z, 3.14);
-                return hpx::make_tuple(x, z);
-            },
-            ex::just(42), ex::just(), ex::just(3.14));
-
-        static_assert(ex::is_sender_v<decltype(s)>);
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-
-        check_value_types<hpx::variant<hpx::tuple<hpx::tuple<int, double>>>>(s);
-        check_error_types<hpx::variant<std::exception_ptr>>(s);
-        check_sends_stopped<true>(s);
-
-        auto f = [](hpx::tuple<int, double> t) {
-            HPX_TEST_EQ(t.get<0>(), 42);
-            HPX_TEST_EQ(t.get<1>(), 3.14);
-        };
-        auto r = callback_receiver<decltype(f)>{f, set_value_called};
-        auto os = ex::connect(std::move(s), std::move(r));
-        ex::start(os);
-        HPX_TEST(then_called);
-        HPX_TEST(set_value_called);
-    }
-#endif
-
     return hpx::util::report_errors();
 }
 #else
diff --git a/libs/core/execution/tests/unit/algorithm_when_all_vector.cpp b/libs/core/execution/tests/unit/algorithm_when_all_vector.cpp
index f46489d36606..6f0558ca8811 100644
--- a/libs/core/execution/tests/unit/algorithm_when_all_vector.cpp
+++ b/libs/core/execution/tests/unit/algorithm_when_all_vector.cpp
@@ -35,20 +35,12 @@ int main()
         auto s = ex::when_all_vector(std::vector<decltype(ex::just())>{});
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
-#if defined(HPX_HAVE_STDEXEC)
         // In P2300 just does not send stopped so this does not either
         check_sends_stopped<false>(s);
-#else
-        check_sends_stopped<true>(s);
-#endif
 
         auto f = [] {};
         auto r = callback_receiver<decltype(f)>{f, set_value_called};
@@ -62,19 +54,11 @@ int main()
         auto s = ex::when_all_vector(std::vector<decltype(ex::just(42))>{});
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<std::vector<int>>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
-#if defined(HPX_HAVE_STDEXEC)
         check_sends_stopped<false>(s);
-#else
-        check_sends_stopped<true>(s);
-#endif
 
         auto f = [](std::vector<int> v) {
             HPX_TEST_EQ(v.size(), std::size_t(0));
@@ -90,19 +74,11 @@ int main()
         auto s = ex::when_all_vector(std::vector{ex::just(42)});
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<std::vector<int>>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
-#if defined(HPX_HAVE_STDEXEC)
         check_sends_stopped<false>(s);
-#else
-        check_sends_stopped<true>(s);
-#endif
 
         auto f = [](std::vector<int> v) {
             HPX_TEST_EQ(v.size(), std::size_t(1));
@@ -121,19 +97,11 @@ int main()
             ex::when_all_vector(std::vector{const_reference_sender<int>{x}});
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<std::vector<int>>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
-#if defined(HPX_HAVE_STDEXEC)
         check_sends_stopped<false>(s);
-#else
-        check_sends_stopped<true>(s);
-#endif
 
         auto f = [](std::vector<int> v) {
             HPX_TEST_EQ(v.size(), std::size_t(1));
@@ -151,19 +119,11 @@ int main()
             std::vector{ex::just(42), ex::just(43), ex::just(44)});
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<std::vector<int>>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
-#if defined(HPX_HAVE_STDEXEC)
         check_sends_stopped<false>(s);
-#else
-        check_sends_stopped<true>(s);
-#endif
 
         auto f = [](std::vector<int> v) {
             HPX_TEST_EQ(v.size(), std::size_t(3));
@@ -186,19 +146,11 @@ int main()
         auto s = ex::when_all_vector(std::move(senders));
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<std::vector<int>>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
-#if defined(HPX_HAVE_STDEXEC)
         check_sends_stopped<false>(s);
-#else
-        check_sends_stopped<true>(s);
-#endif
 
         auto f = [](std::vector<int> v) {
             HPX_TEST_EQ(v.size(), std::size_t(3));
@@ -221,19 +173,11 @@ int main()
         auto s = ex::when_all_vector(std::move(senders));
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<std::vector<double>>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
-#if defined(HPX_HAVE_STDEXEC)
         check_sends_stopped<false>(s);
-#else
-        check_sends_stopped<true>(s);
-#endif
 
         auto f = [](std::vector<double> v) {
             HPX_TEST_EQ(v.size(), std::size_t(3));
@@ -252,19 +196,11 @@ int main()
         auto s = ex::when_all_vector(std::vector{ex::just()});
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
-#if defined(HPX_HAVE_STDEXEC)
         check_sends_stopped<false>(s);
-#else
-        check_sends_stopped<true>(s);
-#endif
 
         auto f = []() {};
         auto r = callback_receiver<decltype(f)>{f, set_value_called};
@@ -279,19 +215,11 @@ int main()
             std::vector{ex::just(), ex::just(), ex::just()});
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
-#if defined(HPX_HAVE_STDEXEC)
         check_sends_stopped<false>(s);
-#else
-        check_sends_stopped<true>(s);
-#endif
 
         auto f = []() {};
         auto r = callback_receiver<decltype(f)>{f, set_value_called};
@@ -309,19 +237,11 @@ int main()
         auto s = ex::when_all_vector(std::move(senders));
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
-#if defined(HPX_HAVE_STDEXEC)
         check_sends_stopped<false>(s);
-#else
-        check_sends_stopped<true>(s);
-#endif
 
         auto f = []() {};
         auto r = callback_receiver<decltype(f)>{f, set_value_called};
@@ -339,19 +259,11 @@ int main()
         auto s = ex::when_all_vector(std::move(senders));
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
-#if defined(HPX_HAVE_STDEXEC)
         check_sends_stopped<false>(s);
-#else
-        check_sends_stopped<true>(s);
-#endif
 
         auto f = []() {};
         auto r = callback_receiver<decltype(f)>{f, set_value_called};
@@ -373,20 +285,12 @@ int main()
         auto s = ex::when_all_vector(std::move(senders));
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<
             hpx::tuple<std::vector<custom_type_non_default_constructible>>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
-#if defined(HPX_HAVE_STDEXEC)
         check_sends_stopped<false>(s);
-#else
-        check_sends_stopped<true>(s);
-#endif
 
         auto f = [](std::vector<custom_type_non_default_constructible> v) {
             HPX_TEST_EQ(v.size(), std::size_t(3));
@@ -414,21 +318,13 @@ int main()
         auto s = ex::when_all_vector(std::move(senders));
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<
             std::vector<custom_type_non_default_constructible_non_copyable>>>>(
             s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
-#if defined(HPX_HAVE_STDEXEC)
         check_sends_stopped<false>(s);
-#else
-        check_sends_stopped<true>(s);
-#endif
 
         auto f =
             [](std::vector<custom_type_non_default_constructible_non_copyable>
@@ -467,11 +363,7 @@ int main()
             ex::when_all_vector(std::move(senders3)));
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<
             hpx::variant<hpx::tuple<std::vector<double>, std::vector<int>>>>(s);
@@ -502,19 +394,11 @@ int main()
         auto s = ex::when_all_vector(std::vector{error_sender<double>{}});
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<std::vector<double>>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
-#if defined(HPX_HAVE_STDEXEC)
         check_sends_stopped<false>(s);
-#else
-        check_sends_stopped<true>(s);
-#endif
 
         auto r = error_callback_receiver<check_exception_ptr>{
             check_exception_ptr{}, set_error_called};
@@ -529,19 +413,11 @@ int main()
             ex::when_all_vector(std::vector{const_reference_error_sender{}});
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
-#if defined(HPX_HAVE_STDEXEC)
         check_sends_stopped<false>(s);
-#else
-        check_sends_stopped<true>(s);
-#endif
 
         auto r = error_callback_receiver<check_exception_ptr>{
             check_exception_ptr{}, set_error_called};
@@ -560,19 +436,11 @@ int main()
         auto s = ex::when_all_vector(std::move(senders));
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<std::vector<double>>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
-#if defined(HPX_HAVE_STDEXEC)
         check_sends_stopped<false>(s);
-#else
-        check_sends_stopped<true>(s);
-#endif
 
         auto r = error_callback_receiver<check_exception_ptr>{
             check_exception_ptr{}, set_error_called};
@@ -591,19 +459,11 @@ int main()
         auto s = ex::when_all_vector(std::move(senders));
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<std::vector<double>>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
-#if defined(HPX_HAVE_STDEXEC)
         check_sends_stopped<false>(s);
-#else
-        check_sends_stopped<true>(s);
-#endif
 
         auto r = error_callback_receiver<check_exception_ptr>{
             check_exception_ptr{}, set_error_called};
@@ -622,19 +482,11 @@ int main()
         auto s = ex::when_all_vector(std::move(senders));
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<std::vector<double>>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
-#if defined(HPX_HAVE_STDEXEC)
         check_sends_stopped<false>(s);
-#else
-        check_sends_stopped<true>(s);
-#endif
 
         auto r = error_callback_receiver<check_exception_ptr>{
             check_exception_ptr{}, set_error_called};
@@ -653,19 +505,11 @@ int main()
         auto s = ex::when_all_vector(std::move(senders));
 
         static_assert(ex::is_sender_v<decltype(s)>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<decltype(s), ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<decltype(s), ex::empty_env>);
-#endif
 
         check_value_types<hpx::variant<hpx::tuple<std::vector<double>>>>(s);
         check_error_types<hpx::variant<std::exception_ptr>>(s);
-#if defined(HPX_HAVE_STDEXEC)
         check_sends_stopped<false>(s);
-#else
-        check_sends_stopped<true>(s);
-#endif
 
         auto r = error_callback_receiver<check_exception_ptr>{
             check_exception_ptr{}, set_error_called};
diff --git a/libs/core/execution/tests/unit/environment_queries.cpp b/libs/core/execution/tests/unit/environment_queries.cpp
index f6c3cbcb924f..d0cd3126f6bb 100644
--- a/libs/core/execution/tests/unit/environment_queries.cpp
+++ b/libs/core/execution/tests/unit/environment_queries.cpp
@@ -29,51 +29,24 @@ namespace ex = hpx::execution::experimental;
 
 namespace mylib {
 
-#if defined(HPX_HAVE_STDEXEC)
     using sched = my_namespace::my_scheduler;
-#else
-    struct sched
-    {
-    };
-#endif
 
-#if defined(HPX_HAVE_STDEXEC)
     using sched_env_t = ex::prop<ex::get_scheduler_t, sched>;
-#else
-    using sched_env_t = ex::make_env_t<ex::get_scheduler_t, sched>;
-#endif
 
-#if defined(HPX_HAVE_STDEXEC)
     using delegatee_sched = my_namespace::my_scheduler_template<0>;
-#else
-    struct delegatee_sched
-    {
-    };
-#endif
 
-#if defined(HPX_HAVE_STDEXEC)
     using delegatee_sched_env_t = ex::env<sched_env_t,
         ex::prop<ex::get_delegatee_scheduler_t, delegatee_sched>>;
-#else
-    using delegatee_sched_env_t = ex::make_env_t<ex::get_delegatee_scheduler_t,
-        delegatee_sched, sched_env_t>;
-#endif
 
     struct allocator
     {
     };
 
-#if defined(HPX_HAVE_STDEXEC)
     using allocator_env_t = ex::env<delegatee_sched_env_t,
         ex::prop<ex::get_allocator_t, allocator>>;
-#else
-    using allocator_env_t =
-        ex::make_env_t<ex::get_allocator_t, allocator, delegatee_sched_env_t>;
-#endif
 
     struct stop_token
     {
-#if defined(HPX_HAVE_STDEXEC)
         // TODO: Find out the correct type for this alias.
         // Based on:
         // https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/
@@ -95,24 +68,16 @@ namespace mylib {
         {
             return false;
         }
-#endif
     };
 
-#if defined(HPX_HAVE_STDEXEC)
     // clang-format off
     using stop_token_env_t = ex::env<allocator_env_t,
         ex::prop<ex::get_stop_token_t, stop_token>>;
     // clang-format on
-#else
-    using stop_token_env_t =
-        ex::make_env_t<ex::get_stop_token_t, stop_token, allocator_env_t>;
-#endif
 
     struct receiver_1
     {
-#if defined(HPX_HAVE_STDEXEC)
         using receiver_concept = ex::receiver_t;
-#endif
         friend void tag_invoke(ex::set_stopped_t, receiver_1&&) noexcept {}
 
         friend void tag_invoke(
@@ -145,42 +110,21 @@ namespace mylib {
 
         friend auto tag_invoke(ex::get_env_t, receiver_1) noexcept
         {
-#if defined(HPX_HAVE_STDEXEC)
             auto sched_env = ex::prop(ex::get_scheduler_t{}, sched());
-#else
-            auto sched_env = ex::make_env<ex::get_scheduler_t>(sched());
-#endif
             static_assert(std::is_same_v<decltype(sched_env), sched_env_t>,
                 "must return sched_env");
-#if defined(HPX_HAVE_STDEXEC)
             auto delegatee_sched_env = ex::env(std::move(sched_env),
                 ex::prop(ex::get_delegatee_scheduler_t{}, delegatee_sched()));
-#else
-            auto delegatee_sched_env =
-                ex::make_env<ex::get_delegatee_scheduler_t>(
-                    delegatee_sched(), sched_env);
-
-#endif
             static_assert(std::is_same_v<decltype(delegatee_sched_env),
                               delegatee_sched_env_t>,
                 "must return delegatee_sched_env");
-#if defined(HPX_HAVE_STDEXEC)
             auto allocator_env = ex::env(std::move(delegatee_sched_env),
                 ex::prop(ex::get_allocator_t{}, allocator()));
-#else
-            auto allocator_env = ex::make_env<ex::get_allocator_t>(
-                allocator(), delegatee_sched_env);
-#endif
             static_assert(
                 std::is_same_v<decltype(allocator_env), allocator_env_t>,
                 "must return allocator_env");
-#if defined(HPX_HAVE_STDEXEC)
             auto stop_token_env = ex::env(std::move(allocator_env),
                 ex::prop(ex::get_stop_token_t{}, stop_token()));
-#else
-            auto stop_token_env =
-                ex::make_env<ex::get_stop_token_t>(stop_token(), allocator_env);
-#endif
             static_assert(
                 std::is_same_v<decltype(stop_token_env), stop_token_env_t>,
                 "must return stop_token_env");
diff --git a/libs/core/execution/tests/unit/forwarding_env_query.cpp b/libs/core/execution/tests/unit/forwarding_env_query.cpp
index 1031be4a8510..9ed0959f2033 100644
--- a/libs/core/execution/tests/unit/forwarding_env_query.cpp
+++ b/libs/core/execution/tests/unit/forwarding_env_query.cpp
@@ -16,22 +16,16 @@
 
 namespace mylib {
 
-#if defined(HPX_HAVE_STDEXEC)
     struct derived_forwarding_query_t
       : hpx::execution::experimental::forwarding_query_t
     {
     } derived_forwarding_query{};
-#endif
 
     inline constexpr struct non_query_t final
       : hpx::functional::tag<non_query_t>
     {
         friend constexpr auto tag_invoke(
-#if defined(HPX_HAVE_STDEXEC)
             hpx::execution::experimental::forwarding_query_t,
-#else
-            hpx::execution::experimental::forwarding_env_query_t,
-#endif
             non_query_t) noexcept
         {
             return true;
@@ -42,31 +36,18 @@ namespace mylib {
 
 int main()
 {
-#if defined(HPX_HAVE_STDEXEC)
     static_assert(hpx::execution::experimental::forwarding_query(
                       mylib::non_query) == true,
-#else
-    static_assert(hpx::execution::experimental::forwarding_env_query(
-                      mylib::non_query) == true,
-#endif
         "non_query CPO is user implemented that returns true");
-#if defined(HPX_HAVE_STDEXEC)
     // P2300R8: "forwarding_query(execution::get_scheduler) is a core constant
     // expression and has value true."
     static_assert(hpx::execution::experimental::forwarding_query(
                       hpx::execution::experimental::get_scheduler) == true,
         "get scheduler is a forwarding query");
-#else
-    static_assert(hpx::execution::experimental::forwarding_env_query(
-                      hpx::execution::experimental::get_scheduler) == false,
-        "environmental query falls back to false");
-#endif
 
-#if defined(HPX_HAVE_STDEXEC)
     static_assert(hpx::execution::experimental::forwarding_query(
                       mylib::derived_forwarding_query) == true,
         "derived_forwarding_query is a forwarding query");
-#endif
 
     return hpx::util::report_errors();
 }
diff --git a/libs/core/execution/tests/unit/forwarding_scheduler_query.cpp b/libs/core/execution/tests/unit/forwarding_scheduler_query.cpp
index 2aea8ff6037e..74970c613bb2 100644
--- a/libs/core/execution/tests/unit/forwarding_scheduler_query.cpp
+++ b/libs/core/execution/tests/unit/forwarding_scheduler_query.cpp
@@ -19,11 +19,7 @@ namespace mylib {
       : hpx::functional::tag<non_query_t>
     {
         friend constexpr auto tag_invoke(
-#if defined(HPX_HAVE_STDEXEC)
             hpx::execution::experimental::forwarding_query_t,
-#else
-            hpx::execution::experimental::forwarding_scheduler_query_t,
-#endif
             non_query_t) noexcept
         {
             return true;
@@ -34,19 +30,9 @@ namespace mylib {
 
 int main()
 {
-#if defined(HPX_HAVE_STDEXEC)
     static_assert(hpx::execution::experimental::forwarding_query(
-#else
-    static_assert(hpx::execution::experimental::forwarding_scheduler_query(
-#endif
                       mylib::non_query) == true,
         "non_query CPO is user implemented to return true");
 
-#if !defined(HPX_HAVE_STDEXEC)
-    static_assert(hpx::execution::experimental::forwarding_scheduler_query(
-                      hpx::execution::experimental::get_scheduler) == false,
-        "invokes tag_fallback which returns false by default");
-#endif
-
     return hpx::util::report_errors();
 }
diff --git a/libs/core/execution/tests/unit/forwarding_sender_query.cpp b/libs/core/execution/tests/unit/forwarding_sender_query.cpp
index c5d185148fc2..b7046ece9976 100644
--- a/libs/core/execution/tests/unit/forwarding_sender_query.cpp
+++ b/libs/core/execution/tests/unit/forwarding_sender_query.cpp
@@ -21,11 +21,7 @@ namespace mylib {
     inline constexpr struct query_t final : hpx::functional::tag<query_t>
     {
         friend constexpr auto tag_invoke(
-#if defined(HPX_HAVE_STDEXEC)
             ex::forwarding_query_t, query_t) noexcept
-#else
-            ex::forwarding_sender_query_t, query_t) noexcept
-#endif
         {
             return true;
         }
@@ -39,41 +35,21 @@ namespace mylib {
 
 int main()
 {
-#if defined(HPX_HAVE_STDEXEC)
     static_assert(ex::forwarding_query(mylib::query) == true,
-#else
-    static_assert(ex::forwarding_sender_query(mylib::query) == true,
-#endif
         "non_query CPO is user implemented to return true");
 
-#if defined(HPX_HAVE_STDEXEC)
     static_assert(ex::forwarding_query(mylib::non_query) == false,
-#else
-    static_assert(ex::forwarding_sender_query(mylib::non_query) == false,
-#endif
         "invokes tag_fallback which returns false by default");
 
-#if defined(HPX_HAVE_STDEXEC)
     static_assert(ex::forwarding_query(
-#else
-    static_assert(ex::forwarding_sender_query(
-#endif
                       ex::get_completion_scheduler<ex::set_value_t>) == true,
         "invokes CPO specialization that returns true");
 
-#if defined(HPX_HAVE_STDEXEC)
     static_assert(ex::forwarding_query(
-#else
-    static_assert(ex::forwarding_sender_query(
-#endif
                       ex::get_completion_scheduler<ex::set_error_t>) == true,
         "invokes CPO specialization that returns true");
 
-#if defined(HPX_HAVE_STDEXEC)
     static_assert(ex::forwarding_query(
-#else
-    static_assert(ex::forwarding_sender_query(
-#endif
                       ex::get_completion_scheduler<ex::set_stopped_t>) == true,
         "invokes CPO specialization that returns true");
 
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 550f0269b6b3..20ea47eb65f4 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
@@ -784,20 +784,10 @@ namespace hpx::execution::experimental {
         unique_any_sender& operator=(unique_any_sender&&) = default;
         unique_any_sender& operator=(unique_any_sender const&) = delete;
 
-#if defined(HPX_HAVE_STDEXEC)
         // TODO: Remove this
         using completion_signatures =
             hpxexec::completion_signatures<set_value_t(Ts...),
                 set_error_t(std::exception_ptr)>;
-#else
-        // clang-format off
-        template <typename Env>
-        friend auto tag_invoke(get_completion_signatures_t,
-            unique_any_sender const&,
-            Env) noexcept -> completion_signatures<set_value_t(Ts...),
-                              set_error_t(std::exception_ptr)>;
-        // clang-format on
-#endif
 
         template <typename R>
         friend detail::any_operation_state tag_invoke(
@@ -870,19 +860,10 @@ namespace hpx::execution::experimental {
         any_sender& operator=(any_sender&&) = default;
         any_sender& operator=(any_sender const&) = default;
 
-#if defined(HPX_HAVE_STDEXEC)
         // TODO: Remove this
         using completion_signatures =
             hpxexec::completion_signatures<set_value_t(Ts...),
                 set_error_t(std::exception_ptr)>;
-#else
-        // clang-format off
-        template <typename Env>
-        friend auto tag_invoke(get_completion_signatures_t, any_sender const&,
-            Env) noexcept -> completion_signatures<set_value_t(Ts...),
-                              set_error_t(std::exception_ptr)>;
-        // clang-format on
-#endif
 
         template <typename R>
         friend detail::any_operation_state tag_invoke(
diff --git a/libs/core/execution_base/include/hpx/execution_base/completion_scheduler.hpp b/libs/core/execution_base/include/hpx/execution_base/completion_scheduler.hpp
index 97d2a4230d1a..70f6e487141f 100644
--- a/libs/core/execution_base/include/hpx/execution_base/completion_scheduler.hpp
+++ b/libs/core/execution_base/include/hpx/execution_base/completion_scheduler.hpp
@@ -10,7 +10,6 @@
 #include <hpx/config.hpp>
 #include <hpx/functional/tag_invoke.hpp>
 
-#if defined(HPX_HAVE_STDEXEC)
 #include <hpx/execution_base/stdexec_forward.hpp>
 #include <utility>
 
@@ -36,158 +35,3 @@ namespace hpx::execution::experimental { namespace detail {
     };
     // clang-format on
 }}    // namespace hpx::execution::experimental::detail
-
-#else
-
-#include <hpx/concepts/concepts.hpp>
-#include <hpx/execution_base/get_env.hpp>
-#include <hpx/execution_base/receiver.hpp>
-#include <hpx/execution_base/sender.hpp>
-#include <hpx/functional/detail/tag_fallback_invoke.hpp>
-
-#include <type_traits>
-
-namespace hpx::execution::experimental {
-
-    // 1. execution::forwarding_sender_query is used to ask a customization
-    //    point object whether it is a sender query that should be forwarded
-    //    through sender adaptors.
-    //
-    // 2. execution::forwarding_sender_query is used to ask a customization
-    //    point object whether it is a sender query that should be forwarded
-    //    through sender adaptors.
-    //
-    //      1. tag_invoke(execution::forwarding_sender_query, t) contextually
-    //         converted to bool, if the tag_invoke expression is well formed.
-    //
-    //          - Mandates: The tag_invoke expression is indeed contextually
-    //            convertible to bool, that expression and the contextual
-    //            conversion are not potentially-throwing and are core constant
-    //            expressions if t is a core constant expression.
-    //
-    //      2. Otherwise, false.
-    //
-    inline constexpr struct forwarding_sender_query_t final
-      : hpx::functional::detail::tag_fallback_noexcept<
-            forwarding_sender_query_t,
-            detail::contextually_convertible_to_bool<forwarding_sender_query_t>>
-    {
-    private:
-        template <typename Tag>
-        friend constexpr bool tag_fallback_invoke(
-            forwarding_sender_query_t, Tag) noexcept
-        {
-            return false;
-        }
-    } forwarding_sender_query{};
-
-    // execution::get_completion_scheduler is used to ask a sender object for
-    // the completion scheduler for one of its signals.
-    //
-    // The name execution::get_completion_scheduler denotes a customization
-    // point object template. For some subexpression s, let S be decltype((s)).
-    // If S does not satisfy execution::sender,
-    // execution::get_completion_scheduler<CPO>(s) is ill-formed for all
-    // template arguments CPO. If the template argument CPO in
-    // execution::get_completion_scheduler<CPO> is not one of
-    // execution::set_value_t, execution::set_error_t, or
-    // execution::set_stopped_t, execution::get_completion_scheduler<CPO> is
-    // ill-formed. Otherwise, execution::get_completion_scheduler<CPO>(s) is
-    // expression-equivalent to:
-    //
-    //    1. tag_invoke(execution::get_completion_scheduler<CPO>, as_const(s))
-    //       if this expression is well formed.
-    //
-    //       - Mandates: The tag_invoke expression above is not potentially
-    //         throwing and its type satisfies execution::scheduler.
-    //
-    //    2.   Otherwise, execution::get_completion_scheduler<CPO>(s) is
-    //         ill-formed.
-    //
-    // clang-format off
-    template <typename CPO,
-            HPX_CONCEPT_REQUIRES_(
-                    hpx::execution::experimental::detail::is_receiver_cpo_v<CPO>
-            )>
-    // clang-format on
-    struct get_completion_scheduler_t final
-      : hpx::functional::tag<get_completion_scheduler_t<CPO>>
-    {
-    private:
-        friend constexpr bool tag_invoke(forwarding_sender_query_t,
-            get_completion_scheduler_t const&) noexcept
-        {
-            return true;
-        }
-    };
-
-    template <typename CPO>
-    inline constexpr get_completion_scheduler_t<CPO> get_completion_scheduler{};
-
-    namespace detail {
-
-        template <bool TagInvocable, typename CPO, typename Sender>
-        struct has_completion_scheduler_impl : std::false_type
-        {
-        };
-
-        template <typename CPO, typename Sender>
-        struct has_completion_scheduler_impl<true, CPO, Sender>
-          : hpx::execution::experimental::is_scheduler<hpx::functional::
-                    tag_invoke_result_t<get_completion_scheduler_t<CPO>,
-                        std::decay_t<Sender> const&>>
-        {
-        };
-
-        template <typename CPO, typename Sender>
-        struct has_completion_scheduler
-          : has_completion_scheduler_impl<hpx::functional::is_tag_invocable_v<
-                                              get_completion_scheduler_t<CPO>,
-                                              std::decay_t<Sender> const&>,
-                CPO, Sender>
-        {
-        };
-
-        template <typename CPO, typename Sender>
-        inline constexpr bool has_completion_scheduler_v =
-            has_completion_scheduler<CPO, Sender>::value;
-
-        template <bool HasCompletionScheduler, typename ReceiverCPO,
-            typename Sender, typename AlgorithmCPO, typename... Ts>
-        struct is_completion_scheduler_tag_invocable_impl : std::false_type
-        {
-        };
-
-        template <typename ReceiverCPO, typename Sender, typename AlgorithmCPO,
-            typename... Ts>
-        struct is_completion_scheduler_tag_invocable_impl<true, ReceiverCPO,
-            Sender, AlgorithmCPO, Ts...>
-          : std::integral_constant<bool,
-                hpx::functional::is_tag_invocable_v<AlgorithmCPO,
-                    hpx::functional::tag_invoke_result_t<
-                        hpx::execution::experimental::
-                            get_completion_scheduler_t<ReceiverCPO>,
-                        Sender>,
-                    Sender, Ts...>>
-        {
-        };
-
-        template <typename ReceiverCPO, typename Sender, typename AlgorithmCPO,
-            typename... Ts>
-        struct is_completion_scheduler_tag_invocable
-          : is_completion_scheduler_tag_invocable_impl<
-                hpx::execution::experimental::detail::
-                    has_completion_scheduler_v<ReceiverCPO, Sender>,
-                ReceiverCPO, Sender, AlgorithmCPO, Ts...>
-        {
-        };
-
-        template <typename ReceiverCPO, typename Sender, typename AlgorithmCPO,
-            typename... Ts>
-        inline constexpr bool is_completion_scheduler_tag_invocable_v =
-            is_completion_scheduler_tag_invocable<ReceiverCPO, Sender,
-                AlgorithmCPO, Ts...>::value;
-    }    // namespace detail
-}    // namespace hpx::execution::experimental
-
-#endif
diff --git a/libs/core/execution_base/include/hpx/execution_base/completion_signatures.hpp b/libs/core/execution_base/include/hpx/execution_base/completion_signatures.hpp
index 41f7b23594ab..f20b7acdd572 100644
--- a/libs/core/execution_base/include/hpx/execution_base/completion_signatures.hpp
+++ b/libs/core/execution_base/include/hpx/execution_base/completion_signatures.hpp
@@ -31,9 +31,7 @@
 #include <system_error>
 #endif
 
-#if defined(HPX_HAVE_STDEXEC)
 #include <hpx/execution_base/stdexec_forward.hpp>
-#endif
 
 namespace hpx::execution::experimental {
 
@@ -111,220 +109,8 @@ namespace hpx::execution::experimental {
         template <typename... Ts>
         using decayed_tuple = meta::invoke<decay_tuple<hpx::tuple>, Ts...>;
 
-#if !defined(HPX_HAVE_STDEXEC)
-        // test, if set_value_t(Ts...), set_error_t(Error, Ts...), or
-        // set_stopped_t() are available, return meta::pack<Ts...>
-        template <typename Tag, typename MetaF = meta::func<meta::pack>,
-            typename... Ts>
-        std::enable_if_t<std::is_same_v<Tag, set_value_t>,
-            meta::pack<meta::invoke<MetaF, Ts...>>>
-            test_signature(Tag (*)(Ts...));
-
-        template <typename Tag, typename MetaF = meta::func<meta::pack>,
-            typename Error, typename... Ts>
-        std::enable_if_t<std::is_same_v<Tag, set_error_t>,
-            meta::pack<meta::invoke1<MetaF, Error>,
-                meta::invoke1<MetaF, Ts>...>>
-            test_signature(Tag (*)(Error, Ts...));
-
-        template <typename Tag, typename MetaF = meta::func<meta::pack>>
-        std::enable_if_t<std::is_same_v<Tag, set_stopped_t>,
-            meta::pack<meta::invoke<MetaF>>>
-            test_signature(Tag (*)());
-
-        // fallback, returns an empty pack<>
-        template <typename, typename = void>
-        meta::pack<> test_signature(...);
-
-        // clang-format off
-        template <typename Signature, typename Tag,
-            typename MetaF = meta::func<meta::pack>>
-        using signature_arg_apply = decltype(
-            test_signature<Tag, MetaF>(static_cast<Signature*>(nullptr)));
-        // clang-format on
-
-        template <typename Signature, typename Enable = void>
-        struct is_completion_signature : std::false_type
-        {
-        };
-
-        template <typename Signature>
-        struct is_completion_signature<Signature,
-            std::void_t<decltype(test_signature(
-                static_cast<Signature*>(nullptr)))>> : std::true_type
-        {
-        };
-
-        template <typename... Signatures>
-        struct compose_signatures
-        {
-            struct type
-            {
-                // clang-format off
-                template <typename Tuple, typename Variant>
-                struct make_value_types
-                {
-                    using type = meta::apply<Variant,
-                        signature_arg_apply<
-                            Signatures, set_value_t, Tuple
-                        >...
-                    >;
-                };
-
-                template <typename Variant>
-                struct make_error_types
-                {
-                    using type = meta::apply<Variant,
-                        signature_arg_apply<
-                            Signatures, set_error_t,
-                            meta::func1<meta::identity>
-                        >...
-                    >;
-                };
-
-                static constexpr bool sends_stopped =
-                    meta::apply<meta::count,
-                        signature_arg_apply<
-                            Signatures, set_stopped_t
-                        >...
-                    >::value != 0;
-                // clang-format on
-
-                template <template <typename...> typename Tuple,
-                    template <typename...> typename Variant>
-                using value_types = meta::type<
-                    make_value_types<meta::func<Tuple>, meta::func<Variant>>>;
-
-                template <template <typename...> typename Variant>
-                using error_types =
-                    meta::type<make_error_types<meta::func<Variant>>>;
-
-                using signatures_t = meta::pack<Signatures...>;
-            };
-        };
-
-        template <typename Pack, typename Enable = void>
-        struct generate_completion_signatures
-        {
-        };
-
-        template <typename... Signatures>
-        struct generate_completion_signatures<meta::pack<Signatures...>,
-            std::enable_if_t<
-                util::all_of_v<is_completion_signature<Signatures>...>>>
-          : meta::invoke<meta::func<compose_signatures>, Signatures...>
-        {
-        };
-#endif
-    }    // namespace detail
-
-#if !defined(HPX_HAVE_STDEXEC)
-    // A type Fn satisfies completion-signature if it is a function type with
-    // one of the following forms:
-    //
-    //      set_value_t(Vs...), where Vs is an arbitrary parameter pack.
-    //
-    //      set_error_t(E), where E is an arbitrary type.
-    //
-    //      set_stopped_t()
-    //
-    // Otherwise, Fn does not satisfy completion-signature.
-    //
-    // Let ValueFns be a template parameter pack of the function types in Fns
-    // whose return types are execution::set_value_t, and let Valuesn be a
-    // template parameter pack of the function argument types in the n-th type
-    // in ValueFns.
-    // Then, given two variadic templates Tuple and Variant, the type
-    // completion_signatures<Fns...>::value_types<Tuple, Variant> names the type
-    // Variant<Tuple<Values0...>, Tuple<Values1...>, ... Tuple<Valuesn-1...>>,
-    // where m is the size of the parameter pack ValueFns.
-    //
-    // Let ErrorFns be a template parameter pack of the function types in Fns
-    // whose return types are execution::set_error_t, and let Errorn be the
-    // function argument type in the n-th type in ErrorFns.
-    // Then, given a variadic template Variant, the type
-    // completion_signatures<Fns...>::error_types<Variant> names the type
-    // Variant<Error0, Error1, ... Errorn-1>, where m is the size of the
-    // parameter pack ErrorFns.
-    //
-    // completion_signatures<Fns...>::sends_stopped is true if at least one of
-    // the types in Fns is execution::set_stopped_t(); otherwise, false.
-    //
-    template <typename... Signatures>
-    using completion_signatures = meta::type<
-        detail::generate_completion_signatures<meta::pack<Signatures...>>>;
-
-#if defined(HPX_HAVE_CXX20_COROUTINES)
-    struct as_awaitable_t;
-#endif
-
-    namespace detail {
-
-        struct completion_signals_of_sender_depend_on_execution_environment
-        {
-        };
-#if defined(HPX_HAVE_CXX20_COROUTINES)
-        // https://github.com/NVIDIA/stdexec/pull/733#issue-1537242117
-        //
-        // We were inconsistent about whether promise types were directly
-        // queryable, or whether they implemented get_env. Now we expect
-        // promise types to implement get_env, and if they don't they are
-        // implicitly given an empty environment.
-        //
-        // In get_completion_signatures, we were testing for awaitability
-        // using the Env arg as a promise type, which was picking up stray
-        // await_transform functions that connect would not use,
-        // leading to an inconsistency.
-        //
-        // -- Eric Niebler
-        //
-        // To be kept in sync with the promise type used in connect_awaitable
-        template <typename Env>
-        struct env_promise;
-#endif
-
-        template <typename Env>
-        struct dependent_completion_signatures
-        {
-            template <template <typename...> typename,
-                template <typename...> typename>
-            using value_types =
-                completion_signals_of_sender_depend_on_execution_environment;
-
-            template <template <typename...> typename>
-            using error_types =
-                completion_signals_of_sender_depend_on_execution_environment;
-
-            static constexpr bool sends_stopped = false;
-
-#if defined(HPX_HAVE_CXX20_COROUTINES)
-            bool await_ready() = delete;
-            void await_suspend(
-                hpx::coroutine_handle<env_promise<Env>>) = delete;
-            dependent_completion_signatures await_resume() = delete;
-#endif
-        };
-
-        template <>
-        struct dependent_completion_signatures<no_env>
-        {
-#if defined(HPX_HAVE_CXX20_COROUTINES)
-            bool await_ready();
-            void await_suspend(hpx::coroutine_handle<env_promise<no_env>>);
-            dependent_completion_signatures await_resume();
-#endif
-        };
     }    // namespace detail
 
-    // dependent_completion_signatures is a placeholder completion signatures
-    // descriptor that can be used to report that a type might be a sender
-    // within a particular execution environment, but it isn't a sender in an
-    // arbitrary execution environment.
-    template <typename Env>
-    using dependent_completion_signatures =
-        detail::dependent_completion_signatures<Env>;
-#endif    // NOT HPX_HAVE_STDEXEC
-
     namespace detail {
 
         template <typename Sender, typename Enable = void>
@@ -339,130 +125,8 @@ namespace hpx::execution::experimental {
           : std::true_type
         {
         };
-#if defined(HPX_HAVE_STDEXEC)
-    }
-#else
-        struct no_completion_signatures
-        {
-        };
-
-        // sender<T> only checks if T is an awaitable if enable_sender<T> is
-        // false. Then it checks for awaitability with a promise type that
-        // doesn't have any environment queries, but that does have an
-        // await_transform that pipes the T through
-        // std::execution::as_awaitable. So you have two options for opting into
-        // the sender concept if you type is not generally awaitable: (1)
-        // specialize enable_sender, or (2) customize as_awaitable for T.
-        HPX_HAS_MEMBER_XXX_TRAIT_DEF(is_sender)
-
-#ifdef HPX_HAVE_CXX20_COROUTINES
-        template <typename Sender, typename = void>
-        inline constexpr bool is_enable_sender_v = has_is_sender_v<Sender>;
-
-        template <typename Sender>
-        inline constexpr bool is_enable_sender_v<Sender,
-            std::enable_if_t<
-                std::is_move_constructible_v<std::decay_t<Sender>> &&
-                std::is_class_v<std::decay_t<Sender>> &&
-                hpx::util::is_detected_v<is_awaitable, Sender,
-                    env_promise<no_env>>>> =
-            is_awaitable_v<Sender, env_promise<no_env>> ||
-            has_is_sender_v<Sender>;
-#else
-        template <typename Sender>
-        inline constexpr bool is_enable_sender_v = has_is_sender_v<Sender>;
-#endif    // HPX_HAVE_CXX20_COROUTINES
     }    // namespace detail
 
-    // execution::get_completion_signatures is a customization point object. Let
-    // s be an expression such that decltype((s)) is S, and let e be an
-    // expression such that decltype((e)) is E. Then
-    // get_completion_signatures(s) is expression-equivalent to
-    //
-    //      get_completion_signatures(s, no_env{})
-    //
-    //  and get_completion_signatures(s, e) is expression-equivalent to:
-    //
-    //      tag_invoke_result_t<get_completion_signatures_t, S, E>{} if that
-    //      expression is well-formed,
-    //
-    // Otherwise, if remove_cvref_t<S>::completion_signatures is well-formed and
-    // names a type, then a it returns a prvalue of
-    // remove_cvref_t<S>::completion_signatures
-    //
-    // Otherwise, if is-awaitable<S> is true, then
-    //
-    // If await-result-type<S> is cv void then a prvalue of a type equivalent
-    // to:
-    //
-    //      completion_signatures<
-    //          set_value_t(),
-    //          set_error_t(exception_ptr),
-    //          set_stopped_t()>
-    //
-    //  Otherwise, a prvalue of a type equivalent to:
-    //
-    //      completion_signatures<
-    //          set_value_t(await-result-type<S>),
-    //          set_error_t(exception_ptr),
-    //          set_stopped_t()>
-    //
-    //  Otherwise, no-completion-signatures{}.
-    //
-    inline constexpr struct get_completion_signatures_t final
-      : hpx::functional::detail::tag_fallback<get_completion_signatures_t>
-    {
-    private:
-        template <typename Sender, typename Env = no_env>
-        friend constexpr auto tag_fallback_invoke(
-            get_completion_signatures_t, Sender&&, Env const& = {}) noexcept
-        {
-            static_assert(sizeof(Sender),
-                "Incomplete type used with get_completion_signatures");
-            static_assert(sizeof(Env),
-                "Incomplete type used with get_completion_signatures");
-
-            if constexpr (meta::value<
-                              detail::has_completion_signatures<Sender>>)
-            {
-                return typename detail::remove_cv_ref_t<
-                    Sender>::completion_signatures{};
-            }
-#if defined(HPX_HAVE_CXX20_COROUTINES)
-            else if constexpr (is_awaitable_v<Sender, detail::env_promise<Env>>)
-            {
-                using result_type =
-                    await_result_t<Sender, detail::env_promise<Env>>;
-                if constexpr (std::is_same_v<result_type,
-                                  detail::dependent_completion_signatures<
-                                      no_env>>)
-                {
-                    return detail::dependent_completion_signatures<no_env>{};
-                }
-                else
-                {
-                    return completion_signatures<
-                        hpx::meta::invoke<
-                            hpx::meta::remove<void,
-                                hpx::meta::compose_func<set_value_t>>,
-                            result_type>,
-                        set_error_t(std::exception_ptr)>{};
-                }
-            }
-#endif
-            else if constexpr (std::is_same_v<Env, no_env> &&
-                detail::is_enable_sender_v<std::decay_t<Sender>>)
-            {
-                return detail::dependent_completion_signatures<no_env>{};
-            }
-            else
-            {
-                return detail::no_completion_signatures{};
-            }
-        }
-    } get_completion_signatures{};
-#endif    // NOT HPX_HAVE_STDEXEC
-
     // A sender is a type that is describing an asynchronous operation. The
     // operation itself might not have started yet. In order to get the result
     // of this asynchronous operation, a sender needs to be connected to a
@@ -476,7 +140,6 @@ namespace hpx::execution::experimental {
     //
     // A sender's destructor shall not block pending completion of submitted
     // operations.
-#if defined(HPX_HAVE_STDEXEC)
     template <typename Sender, typename... Env>
     struct is_sender_in : std::bool_constant<hpxexec::sender_in<Sender, Env...>>
     {
@@ -562,1042 +225,6 @@ namespace hpx::execution::experimental {
     using connect_awaitable_t =
         hpxexec::stdexec_internal::__connect_awaitable_t;
     inline constexpr connect_awaitable_t connect_awaitable{};
-#else
-    template <typename Sender, typename Env = no_env>
-    struct is_sender;
-
-    // \see is_sender
-    template <typename Sender, typename Receiver>
-    struct is_sender_to;
-
-    // The sender_of concept defines the requirements for a sender type that on
-    // successful completion sends the specified set of value types.
-    template <typename S, typename E = no_env, typename... Ts>
-    struct is_sender_of;
-
-    namespace detail {
-
-        ///////////////////////////////////////////////////////////////////////
-        template <typename T>
-        constexpr bool has_value_types(
-            typename T::template value_types<meta::pack, meta::pack>*) noexcept
-        {
-            return true;
-        }
-
-        template <typename T>
-        constexpr bool has_value_types(...) noexcept
-        {
-            return false;
-        }
-
-        template <typename T>
-        constexpr bool has_error_types(
-            typename T::template error_types<meta::pack>*) noexcept
-        {
-            return true;
-        }
-
-        template <typename T>
-        constexpr bool has_error_types(...) noexcept
-        {
-            return false;
-        }
-
-        template <typename T>
-        constexpr bool has_sends_stopped(decltype(T::sends_stopped)*) noexcept
-        {
-            return true;
-        }
-
-        template <typename T>
-        constexpr bool has_sends_stopped(...) noexcept
-        {
-            return false;
-        }
-
-        template <typename T>
-        struct has_sender_types
-          : std::integral_constant<bool,
-                has_value_types<T>(nullptr) && has_error_types<T>(nullptr) &&
-                    has_sends_stopped<T>(nullptr)>
-        {
-        };
-
-        template <typename T>
-        inline constexpr bool has_sender_types_v = has_sender_types<T>::value;
-
-        ///////////////////////////////////////////////////////////////////////
-        template <typename Traits>
-        struct valid_completion_signatures
-        {
-            using type = Traits;
-        };
-
-        // leave undefined
-        template <>
-        struct valid_completion_signatures<no_completion_signatures>;
-
-        template <typename Sender, typename Env = no_env>
-        using completion_signatures_of = meta::type<valid_completion_signatures<
-            util::invoke_result_t<get_completion_signatures_t, Sender, Env>>>;
-
-        template <typename Sender, typename Env, bool IsClass,
-            typename Enable = void>
-        struct provides_completion_signatures_impl : std::false_type
-        {
-        };
-
-        template <typename Sender, typename Env, typename Enable = void>
-        struct completion_signatures_of_is_valid : std::false_type
-        {
-        };
-
-        template <typename Sender, typename Env>
-        struct completion_signatures_of_is_valid<Sender, Env,
-            std::void_t<decltype(get_completion_signatures(
-                std::declval<Sender>(), std::declval<Env>()))>> : std::true_type
-        {
-        };
-
-        template <typename Sender, typename Env>
-        struct provides_completion_signatures_impl<Sender, Env, true,
-            std::enable_if_t<
-                meta::value<completion_signatures_of_is_valid<Sender, Env>> &&
-                has_sender_types_v<completion_signatures_of<Sender, Env>>>>
-          : std::true_type
-        {
-        };
-
-        template <typename Sender, typename Env = no_env>
-        struct provides_completion_signatures
-          : provides_completion_signatures_impl<Sender, Env,
-                std::is_class_v<Sender>>
-        {
-        };
-    }    // namespace detail
-
-    // The alias template completion_signatures_of_t is used to query a sender
-    // type for facts associated with the signals it sends.
-    //
-    // completion_signatures_of_t also recognizes awaitables as senders. For
-    // this clause ([exec]):
-    //
-    // An awaitable is an expression that would be well-formed as the operand of
-    // a co_await expression within a given context.
-    //
-    // For any type T, is-awaitable<T> is true if and only if an expression of
-    // that type is an awaitable as described above within the context of a
-    // coroutine whose promise type does not define a member await_transform.
-    // For a coroutine promise type P, is-awaitable<T, P> is true if and only if
-    // an expression of that type is an awaitable as described above within the
-    // context of a coroutine whose promise type is P.
-    //
-    // For an awaitable a such that decltype((a)) is type A,
-    // await-result-type<A> is an alias for decltype(e), where e is a's
-    // await-resume expression ([expr.await]) within the context of a coroutine
-    // whose promise type does not define a member await_transform. For a
-    // coroutine promise type P, await-result-type<A, P> is an alias for
-    // decltype(e), where e is a's await-resume expression ([expr.await]) within
-    // the context of a coroutine whose promise type is P.
-    //
-    // For types S and E, the type completion_signatures_of_t<S, E> is an alias
-    // for decltype(get_completion_signatures(declval<S>(), declval<E>())) if
-    // that expression is well-formed and names a type other than
-    // no-completion-signatures. Otherwise, it is ill-formed.
-    //
-    // The exposition-only type variant-or-empty<Ts...> is defined as follows:
-    //
-    // If sizeof...(Ts) is greater than zero, variant-or-empty<Ts...> names the
-    // type variant<Us...> where Us... is the pack decay_t<Ts>... with duplicate
-    // types removed.
-    //
-    // Otherwise, variant-or-empty<Ts...> names an implementation defined class
-    // type equivalent to the following:
-    //
-    //      struct empty-variant {
-    //          empty-variant() = delete;
-    //      };
-    //
-    // Let r be an rvalue receiver of type R, and let S be the type of a sender.
-    // If value_types_of_t<S, env_of_t<R>, Tuple, Variant> is well formed, it
-    // shall name the type Variant<Tuple<Args0...>, Tuple<Args1...>, ...,
-    // Tuple<ArgsN...>>>, where the type packs Args0 through ArgsN are the packs
-    // of types the sender S passes as arguments to execution::set_value
-    // (besides the receiver object). If such sender S odr-uses
-    // ([basic.def.odr]) execution::set_value(r, args...), where
-    // decltype(args)... is not one of the type packs Args0... through ArgsN...
-    // (ignoring differences in rvalue-reference qualification), the program is
-    // ill-formed with no diagnostic required.
-    //
-    // Let r be an rvalue receiver of type R, and let S be the type of a sender.
-    // If error_types_of_t<S, env_of_t<R>, Variant> is well formed, it shall
-    // name the type Variant<E0, E1, ..., EN>, where the types E0 through EN are
-    // the types the sender S passes as arguments to execution::set_error
-    // (besides the receiver object). If such sender S odr-uses
-    // execution::set_error(r, e), where decltype(e) is not one of the types E0
-    // through EN (ignoring differences in rvalue-reference qualification), the
-    // program is ill-formed with no diagnostic required.
-    //
-    // Let r be an rvalue receiver of type R, and let S be the type of a sender.
-    // If completion_signatures_of_t<S, env_of_t<R>>::sends_stopped is well
-    // formed and false, and such sender S odr-uses execution::set_stopped(r),
-    // the program is ill-formed with no diagnostic required.
-    //
-    // Let S be the type of a sender, let E be the type of an execution
-    // environment other than execution::no_env such that sender<S, E> is true.
-    // Let Tuple, Variant1, and Variant2 be variadic alias templates or class
-    // templates such that following types are well-formed:
-    //
-    //      value_types_of_t<S, no_env, Tuple, Variant1>
-    //
-    //      error_types_of_t<S, no_env, Variant2>
-    //
-    // then the following shall also be true:
-    //
-    // value_types_of_t<S, E, Tuple, Variant1> shall also be well-formed and
-    // shall name the same type as value_types_of_t<S, no_env, Tuple, Variant1>,
-    //
-    // error_types_of_t<S, E, Variant2> shall also be well-formed and shall name
-    // the same type as error_types_of_t<S, no_env, Variant2>, and
-    //
-    // completion_signatures_of_t<S, E>::sends_stopped shall have the same value
-    // as completion_signatures_of_t<S, no_env>::sends_stopped.
-    template <typename Sender, typename Env = no_env>
-    using completion_signatures_of_t =
-        detail::completion_signatures_of<Sender, Env>;
-
-    struct connect_t;
-
-    namespace detail {
-
-        template <bool IsSenderReceiver, typename Sender, typename Receiver>
-        struct is_sender_to_impl;
-
-        template <typename Sender, typename Receiver>
-        struct is_sender_to_impl<false, Sender, Receiver> : std::false_type
-        {
-        };
-
-        template <typename Sender, typename Receiver>
-        struct is_sender_to_impl<true, Sender, Receiver>
-          : std::integral_constant<bool,
-                hpx::is_invocable_v<connect_t, Sender&&, Receiver&&> ||
-                    hpx::is_invocable_v<connect_t, Sender&&, Receiver&> ||
-                    hpx::is_invocable_v<connect_t, Sender&&, Receiver const&> ||
-                    hpx::is_invocable_v<connect_t, Sender&, Receiver&&> ||
-                    hpx::is_invocable_v<connect_t, Sender&, Receiver&> ||
-                    hpx::is_invocable_v<connect_t, Sender&, Receiver const&> ||
-                    hpx::is_invocable_v<connect_t, Sender const&, Receiver&&> ||
-                    hpx::is_invocable_v<connect_t, Sender const&, Receiver&> ||
-                    hpx::is_invocable_v<connect_t, Sender const&,
-                        Receiver const&>>
-        {
-        };
-
-        // This concept has been introduced to increase atomicity of concepts
-        // clang-format off
-        template <typename Sender, typename Env>
-        inline constexpr bool is_sender_plain_v =
-            std::is_move_constructible_v<std::decay_t<Sender>> &&
-            std::is_class_v<std::decay_t<Sender>>;
-        // clang-format on
-    }    // namespace detail
-
-    template <typename Sender, typename Env>
-    struct is_sender
-      : std::integral_constant<bool,
-            !!(detail::is_sender_plain_v<Sender, Env> &&
-                detail::is_enable_sender_v<std::decay_t<Sender>>) ||
-                meta::value<detail::provides_completion_signatures<
-                    std::decay_t<Sender>, Env>>>
-    {
-    };
-
-    template <typename Sender, typename Env = no_env>
-    inline constexpr bool is_sender_v = is_sender<Sender, Env>::value;
-
-    namespace detail {
-
-        template <bool IsSenderOf, typename S, typename E, typename... Ts>
-        struct is_sender_of_impl;
-
-        template <typename S, typename E, typename... Ts>
-        struct is_sender_of_impl<false, S, E, Ts...> : std::false_type
-        {
-        };
-
-        template <typename CS, typename... Ts>
-        inline bool constexpr is_same_types = std::is_same_v<
-            typename CS::template value_types<meta::pack, meta::pack>,
-            meta::pack<meta::pack<Ts...>>>;
-
-        template <class S, class E, class... Ts>
-        struct is_sender_of_impl<true, S, E, Ts...>
-          : std::integral_constant<bool,
-                is_same_types<completion_signatures_of_t<S, E>, Ts...>>
-        {
-        };
-    }    // namespace detail
-
-    // The sender_of concept defines the requirements for a sender type that on
-    // successful completion sends the specified set of value types.
-    //
-    //      template <typename S, typename E = no_env, typename... Ts>
-    //      concept sender_of =
-    //          sender<S, E> &&
-    //          same_as<
-    //              type-list<Ts...>,
-    //              value_types_of_t<S, E, type-list, type_identity_t>
-    //          >;
-    //
-    template <typename S, typename E, typename... Ts>
-    struct is_sender_of
-      : detail::is_sender_of_impl<is_sender_v<S, E>, S, E, Ts...>
-    {
-    };
-
-    template <typename S, typename E = no_env, typename... Ts>
-    inline constexpr bool is_sender_of_v = is_sender_of<S, E, Ts...>::value;
-
-    template <typename Sender, typename Receiver>
-    struct is_sender_to
-      : detail::is_sender_to_impl<is_sender_v<Sender, env_of_t<Receiver>> &&
-                is_receiver_v<Receiver>,
-            Sender, Receiver>
-    {
-    };
-
-    template <typename Sender, typename Receiver>
-    inline constexpr bool is_sender_to_v =
-        is_sender_to<Sender, Receiver>::value;
-
-    ///////////////////////////////////////////////////////////////////////////
-    namespace detail {
-
-        template <typename Signatures, typename Tuple, typename Variant>
-        using value_types_from =
-            typename Signatures::template value_types<Tuple::template apply,
-                Variant::template apply>;
-
-        template <typename Signatures, typename Variant>
-        using error_types_from =
-            typename Signatures::template error_types<Variant::template apply>;
-
-        template <typename Signatures>
-        using sends_stopped_from = meta::bool_<Signatures::sends_stopped>;
-    }    // namespace detail
-
-    // Let r be an rvalue receiver of type R, and let S be the type of a sender.
-    // If value_types_of_t<S, env_of_t<R>, Tuple, Variant> is well formed, it
-    // shall name the type Variant<Tuple<Args0...>, Tuple<Args1...>, ...,
-    // Tuple<ArgsN...>>>, where the type packs Args0 through ArgsN are the packs
-    // of types the sender S passes as arguments to execution::set_value
-    // (besides the receiver object). If such sender S odr-uses
-    // ([basic.def.odr]) execution::set_value(r, args...), where
-    // decltype(args)... is not one of the type packs Args0... through ArgsN...
-    // (ignoring differences in rvalue-reference qualification), the program is
-    // ill-formed with no diagnostic required.
-    //
-    // clang-format off
-    template <typename Sender, typename Env = no_env,
-        template <typename...> typename Tuple = detail::decayed_tuple,
-        template <typename...> typename Variant = detail::decayed_variant,
-        typename = std::enable_if_t<is_sender_v<Sender, Env>>>
-    // clang-format on
-    using value_types_of_t =
-        detail::value_types_from<detail::completion_signatures_of<Sender, Env>,
-            meta::func<Tuple>, meta::func<Variant>>;
-
-    /// Start definitions from coroutine_utils and sender
-
-    template <typename Receiver, typename Sender>
-    inline constexpr bool is_receiver_from_v = is_receiver_of_v<Receiver,
-        completion_signatures_of_t<Sender, env_of_t<Receiver>>>;
-
-    // Alias template single-sender-value-type is defined as follows:
-    //
-    // 1. If value_types_of_t<S, E, Tuple, Variant> would have the form
-    // Variant<Tuple<T>>, then single-sender-value-type<S, E> is an alias for
-    // type T.
-    // 2. Otherwise, if value_types_of_t<S, E, Tuple, Variant> would
-    // have the form Variant<Tuple<>> or Variant<>, then
-    // single-sender-value-type<S, E> is an alias for type void.
-    // 3. Otherwise, single-sender-value-type<S, E> is ill-formed.
-    //
-    template <typename Sender, typename Env = no_env>
-    using single_sender_value_t =
-        detail::value_types_from<detail::completion_signatures_of<Sender, Env>,
-            meta::single_or<void>, meta::compose_template_func<meta::single_t>>;
-
-    struct connect_awaitable_t;
-
-    struct is_debug_env_t : hpx::functional::tag<is_debug_env_t>
-    {
-        template <typename Env,
-            typename = std::enable_if_t<
-                hpx::functional::is_tag_invocable_v<is_debug_env_t, Env>>>
-        void tag_invoke(Env&&) const noexcept;
-    };
-
-    struct connect_t;
-
-    template <typename S, typename R>
-    using connect_result_t = hpx::util::invoke_result_t<connect_t, S, R>;
-
-    template <typename Sender, typename Receiver>
-    struct has_nothrow_connect;
-
-#if defined(HPX_HAVE_CXX20_COROUTINES)
-    // 4.18. Cancellation of a sender can unwind a stack of coroutines As
-    // described in the section "All awaitables are senders", the sender
-    // customization points recognize awaitables and adapt them transparently to
-    // model the sender concept. When connect-ing an awaitable and a receiver,
-    // the adaptation layer awaits the awaitable within a coroutine that
-    // implements unhandled_stopped in its promise type. The effect of this is
-    // that an "uncatchable" stopped exception propagates seamlessly out of
-    // awaitables, causing execution::set_stopped to be called on the receiver.
-    // Obviously, unhandled_stopped is a library extension of the coroutine
-    // promise interface. Many promise types will not implement
-    // unhandled_stopped. When an uncatchable stopped exception tries to
-    // propagate through such a coroutine, it is treated as an unhandled
-    // exception and terminate is called. The solution, as described above, is
-    // to use a sender adaptor to handle the stopped exception before awaiting
-    // it. It goes without saying that any future Standard Library coroutine
-    // types ought to implement unhandled_stopped. The author of Add lazy
-    // coroutine (coroutine task) type, which proposes a standard coroutine task
-    // type, is in agreement.
-    template <typename Promise, typename = void>
-    inline constexpr bool has_unhandled_stopped = false;
-
-    template <typename Promise>
-    inline constexpr bool has_unhandled_stopped<Promise,
-        std::void_t<decltype(std::declval<Promise>().unhandled_stopped())>> =
-        true;
-
-    template <typename Promise, typename = void>
-    inline constexpr bool has_convertible_unhandled_stopped = false;
-
-    template <typename Promise>
-    inline constexpr bool has_convertible_unhandled_stopped<Promise,
-        std::enable_if_t<std::is_convertible_v<
-            decltype(std::declval<Promise>().unhandled_stopped()),
-            hpx::coroutine_handle<>>>> = true;
-
-    namespace detail {
-
-        // clang-format off
-        template <typename T, typename U>
-        inline constexpr bool decays_to = std::is_same_v<std::decay_t<T>, U>&&
-            std::is_same_v<std::decay_t<U>, T>;
-        // clang-format on
-
-        struct void_type
-        {
-        };
-
-        template <typename Value>
-        using value_or_void_t =
-            hpx::meta::if_<std::is_same<Value, void>, void_type, Value>;
-
-        template <typename Value>
-        using coroutine_expected_result_t = hpx::variant<hpx::monostate,
-            value_or_void_t<Value>, std::exception_ptr>;
-
-        template <typename Promise>
-        using coroutine_env_t = hpx::util::detected_or<exec_envs::empty_env,
-            hpx::functional::tag_invoke_result_t, get_env_t, Promise>;
-
-        template <typename Value>
-        struct receiver_base
-        {
-            template <typename... Us,
-                HPX_CONCEPT_REQUIRES_(
-                    std::is_constructible_v<value_or_void_t<Value>, Us...>)>
-            friend void tag_invoke(
-                set_value_t, receiver_base&& self, Us&&... us) noexcept
-            try
-            {
-                self.result->template emplace<1>(HPX_FORWARD(Us, us)...);
-                self.continuation.resume();
-            }
-            catch (...)
-            {
-                set_error(
-                    HPX_FORWARD(receiver_base, self), std::current_exception());
-            }
-
-            template <typename Error>
-            friend void tag_invoke(
-                set_error_t, receiver_base&& self, Error&& err) noexcept
-            {
-                if constexpr (decays_to<Error, std::exception_ptr>)
-                {
-                    self.result->template emplace<2>(HPX_FORWARD(Error, err));
-                }
-                else if constexpr (decays_to<Error, std::error_code>)
-                {
-                    self.result->template emplace<2>(
-                        std::make_exception_ptr(std::system_error(err)));
-                }
-                else
-                {
-                    self.result->template emplace<2>(
-                        std::make_exception_ptr(HPX_FORWARD(Error, err)));
-                }
-                self.continuation.resume();
-            }
-
-            coroutine_expected_result_t<Value>* result;
-            hpx::coroutine_handle<> continuation;
-        };
-
-        template <typename PromiseId, typename Value>
-        struct receiver
-        {
-            using Promise = hpx::meta::type<PromiseId>;
-            struct type : receiver_base<Value>
-            {
-                using id = receiver;
-                friend void tag_invoke(set_stopped_t, type&& self) noexcept
-                {
-                    auto continuation =
-                        hpx::coroutine_handle<Promise>::from_address(
-                            self.continuation.address());
-                    hpx::coroutine_handle<> stopped_continuation =
-                        continuation.promise().unhandled_stopped();
-                    stopped_continuation.resume();
-                }
-                friend coroutine_env_t<Promise&> tag_invoke(
-                    get_env_t, type const& self)
-                {
-                    if constexpr (hpx::functional::is_tag_invocable_v<get_env_t,
-                                      Promise&>)
-                    {
-                        auto continuation =
-                            hpx::coroutine_handle<Promise>::from_address(
-                                self.continuation.address());
-                        return get_env(continuation.promise());
-                    }
-                    else
-                    {
-                        return no_env{};
-                    }
-                }
-            };
-        };
-
-        template <typename Sender, typename Promise>
-        using receiver_t =
-            hpx::meta::type<receiver<hpx::meta::get_id_t<Promise>,
-                single_sender_value_t<Sender, coroutine_env_t<Promise>>>>;
-
-        template <typename PromiseId, typename Value>
-        struct sender_awaitable_base
-        {
-            static constexpr bool await_ready() noexcept
-            {
-                return false;
-            }
-
-            Value await_resume()
-            {
-                switch (result.index())
-                {
-                default:
-                    [[fallthrough]];
-                case 0:    // receiver contract not satisfied
-                    HPX_ASSERT_MSG(0, "_Should never get here");
-                    break;
-
-                case 1:    // set_value
-                    if constexpr (!std::is_void_v<Value>)
-                    {
-                        return HPX_MOVE(std::get<1>(result));
-                    }
-                    else
-                    {
-                        return;
-                    }
-
-                case 2:    // set_error
-                    std::rethrow_exception(std::get<2>(result));
-                }
-                std::terminate();
-            }
-
-        protected:
-            coroutine_expected_result_t<Value> result;
-        };
-
-        template <typename PromiseId, typename SenderId>
-        struct sender_awaitable;
-
-        template <typename Promise, typename Sender>
-        using sender_awaitable_t =
-            hpx::meta::type<sender_awaitable<hpx::meta::get_id_t<Promise>,
-                hpx::meta::get_id_t<Sender>>>;
-
-        // clang-format off
-        template <typename Sender, typename Env = no_env>
-        inline constexpr bool is_single_typed_sender_v =
-            is_sender_v<Sender, Env> &&
-            hpx::meta::value<
-                hpx::meta::is_valid<single_sender_value_t, Sender, Env>>;
-
-        template <typename Sender, typename Promise>
-        inline constexpr bool is_awaitable_sender_v =
-            is_single_typed_sender_v<Sender, coroutine_env_t<Promise>> &&
-            is_sender_to_v<Sender, receiver_t<Sender, Promise>> &&
-            has_unhandled_stopped<Promise>;
-        // clang-format on
-    }    // namespace detail
-
-    inline constexpr struct as_awaitable_t
-      : hpx::functional::detail::tag_fallback<as_awaitable_t>
-    {
-        template <typename T, typename Promise>
-        static constexpr auto select_impl() noexcept
-        {
-            if constexpr (hpx::functional::is_tag_invocable_v<as_awaitable_t, T,
-                              Promise&>)
-            {
-                using result_type =
-                    hpx::functional::tag_invoke_result_t<as_awaitable_t, T,
-                        Promise&>;
-                constexpr bool Nothrow =
-                    hpx::functional::is_nothrow_tag_invocable_v<as_awaitable_t,
-                        T, Promise&>;
-                return static_cast<result_type (*)() noexcept(Nothrow)>(
-                    nullptr);
-            }
-            else if constexpr (is_awaitable_v<T>)
-            {
-                // NOT awaitable<T, Promise> !!
-                using func_type = T && (*) () noexcept;
-                return static_cast<func_type>(nullptr);
-            }
-            else if constexpr (detail::is_awaitable_sender_v<T, Promise>)
-            {
-                using result_type = detail::sender_awaitable_t<Promise, T>;
-                constexpr bool Nothrow =
-                    std::is_nothrow_constructible_v<result_type, T,
-                        hpx::coroutine_handle<Promise>>;
-                return static_cast<result_type (*)() noexcept(Nothrow)>(
-                    nullptr);
-            }
-            else
-            {
-                using func_type = T && (*) () noexcept;
-                return static_cast<func_type>(nullptr);
-            }
-        }
-
-        template <typename T, typename Promise>
-        using select_impl_t = decltype(select_impl<T, Promise>());
-
-        template <typename T, typename Promise>
-        friend HPX_FORCEINLINE auto
-        tag_fallback_invoke(as_awaitable_t, T&& t, Promise& promise) noexcept(
-            hpx::is_nothrow_invocable_v<select_impl_t<T, Promise>>)
-            -> hpx::util::invoke_result_t<select_impl_t<T, Promise>>
-        {
-            if constexpr (detail::is_awaitable_sender_v<T, Promise>)
-            {
-                auto hcoro =
-                    hpx::coroutine_handle<Promise>::from_promise(promise);
-                return detail::sender_awaitable_t<Promise, T>{
-                    HPX_FORWARD(T, t), hcoro};
-            }
-            else
-            {
-                return HPX_FORWARD(T, t);
-            }
-        }
-    } as_awaitable{};
-
-    namespace detail {
-
-        template <typename Env>
-        struct env_promise
-        {
-            template <typename Ty,
-                typename =
-                    std::enable_if_t<!hpx::functional::is_tag_invocable_v<
-                        as_awaitable_t, Ty, env_promise&>>>
-            Ty&& await_transform(Ty&& value) noexcept
-            {
-                return HPX_FORWARD(Ty, value);
-            }
-
-            template <typename Ty,
-                typename = std::enable_if_t<hpx::functional::is_tag_invocable_v<
-                    as_awaitable_t, Ty, env_promise&>>>
-            auto await_transform(Ty&& value) noexcept(
-                hpx::functional::is_nothrow_tag_invocable_v<as_awaitable_t, Ty,
-                    env_promise&>)
-                -> hpx::functional::tag_invoke_result_t<as_awaitable_t, Ty,
-                    env_promise&>
-            {
-                return tag_invoke(as_awaitable, HPX_FORWARD(Ty, value), *this);
-            }
-
-            // clang-format off
-            template <typename T>
-            friend auto tag_invoke(
-                get_env_t, env_promise<T> const&) noexcept -> T const&;
-            // clang-format on
-        };
-
-        struct with_awaitable_senders_base
-        {
-            with_awaitable_senders_base() = default;
-
-            template <typename OtherPromise>
-            void set_continuation(
-                hpx::coroutine_handle<OtherPromise> hcoro) noexcept
-            {
-                static_assert(!std::is_void_v<OtherPromise>);
-
-                continuation_handle = hcoro;
-                if constexpr (has_unhandled_stopped<OtherPromise>)
-                {
-                    stopped_callback =
-                        [](void* address) noexcept -> hpx::coroutine_handle<> {
-                        // This causes the rest of the coroutine (the part after
-                        // the co_await of the sender) to be skipped and invokes
-                        // the calling coroutine's stopped handler.
-                        return hpx::coroutine_handle<
-                            OtherPromise>::from_address(address)
-                            .promise()
-                            .unhandled_stopped();
-                    };
-                }
-
-                // If OtherPromise doesn't implement unhandled_stopped(),
-                // then if a "stopped" unwind reaches this point,
-                // it's considered an unhandled exception and terminate()
-                // is called.
-            }
-
-            hpx::coroutine_handle<> continuation() const noexcept
-            {
-                return continuation_handle;
-            }
-
-            hpx::coroutine_handle<> unhandled_stopped() const noexcept
-            {
-                return (*stopped_callback)(continuation_handle.address());
-            }
-
-        private:
-            hpx::coroutine_handle<> continuation_handle{};
-            hpx::coroutine_handle<> (*stopped_callback)(void*) noexcept =
-                [](void*) noexcept -> hpx::coroutine_handle<> {
-                std::terminate();
-            };
-        };
-    }    // namespace detail
-
-    // clang-format off
-    template <typename A, typename B>
-    inline constexpr bool is_derived_from_v = std::is_base_of_v<B, A> &&
-        std::is_convertible_v<A const volatile*, B const volatile*>;
-    // clang-format on
-
-    template <typename Promise>
-    struct with_awaitable_senders : detail::with_awaitable_senders_base
-    {
-        template <typename Value>
-        auto await_transform(Value&& val)
-            -> hpx::util::invoke_result_t<as_awaitable_t, Value, Promise&>
-        {
-            static_assert(is_derived_from_v<Promise, with_awaitable_senders>);
-            return as_awaitable(
-                HPX_FORWARD(Value, val), static_cast<Promise&>(*this));
-        }
-    };
-
-    struct promise_base
-    {
-        static constexpr hpx::suspend_always initial_suspend() noexcept
-        {
-            return {};
-        }
-
-        [[noreturn]] static hpx::suspend_always final_suspend() noexcept
-        {
-            std::terminate();
-        }
-
-        [[noreturn]] static void unhandled_exception() noexcept
-        {
-            std::terminate();
-        }
-
-        [[noreturn]] static void return_void() noexcept
-        {
-            std::terminate();
-        }
-
-        template <typename Fun>
-        auto yield_value(Fun&& fun) noexcept
-        {
-            struct awaiter
-            {
-                Fun&& fun;
-
-                static constexpr bool await_ready() noexcept
-                {
-                    return false;
-                }
-
-                void await_suspend(hpx::coroutine_handle<>) noexcept(
-                    std::is_nothrow_invocable_v<Fun>)
-                {
-                    // If this throws, the runtime catches the exception,
-                    // resumes the connect_awaitable coroutine, and immediately
-                    // rethrows the exception. The end result is that an
-                    // exception_ptr to the exception gets passed to set_error.
-                    HPX_FORWARD(Fun, fun)();
-                }
-
-                [[noreturn]] static void await_resume() noexcept
-                {
-                    std::terminate();
-                }
-            };
-
-            return awaiter{HPX_FORWARD(Fun, fun)};
-        }
-    };
-
-    struct operation_base
-    {
-        hpx::coroutine_handle<> coro_handle;
-
-        explicit operation_base(hpx::coroutine_handle<> hcoro) noexcept
-          : coro_handle(hcoro)
-        {
-        }
-
-        operation_base(operation_base const& other) = delete;
-        operation_base(operation_base&& other) noexcept
-          : coro_handle(std::exchange(other.coro_handle, {}))
-        {
-        }
-
-        operation_base& operator=(operation_base const&) = delete;
-        operation_base& operator=(operation_base&& rhs) noexcept
-        {
-            coro_handle = std::exchange(rhs.coro_handle, {});
-            return *this;
-        }
-
-        ~operation_base()
-        {
-            if (coro_handle)
-                coro_handle.destroy();
-        }
-
-        friend void tag_invoke(start_t, operation_base& self) noexcept
-        {
-            self.coro_handle.resume();
-        }
-    };
-
-    template <typename ReceiverId>
-    struct promise;
-
-    template <typename ReceiverId>
-    struct operation
-    {
-        struct type : operation_base
-        {
-            using promise_type = hpx::meta::type<promise<ReceiverId>>;
-            using operation_base::operation_base;
-        };
-    };
-
-    template <typename ReceiverId>
-    struct promise
-    {
-        using Receiver = hpx::meta::type<ReceiverId>;
-        struct type : promise_base
-        {
-            using id = promise;
-            explicit type(auto&, Receiver& rcvr_) noexcept
-              : rcvr(rcvr_)
-            {
-            }
-
-            hpx::coroutine_handle<> unhandled_stopped() noexcept
-            {
-                set_stopped(std::move(rcvr));
-                // Returning noop_coroutine here causes the __connect_awaitable
-                // coroutine to never resume past the point where it co_await's
-                // the awaitable.
-                return hpx::noop_coroutine();
-            }
-
-            hpx::meta::type<operation<ReceiverId>> get_return_object() noexcept
-            {
-                return hpx::meta::type<operation<ReceiverId>>{
-                    hpx::coroutine_handle<type>::from_promise(*this)};
-            }
-
-            template <typename Awaitable>
-            auto await_transform(Awaitable&& await) noexcept(
-                hpx::functional::is_nothrow_tag_invocable_v<as_awaitable_t,
-                    Awaitable, promise&> ||
-                !hpx::functional::is_tag_invocable_v<as_awaitable_t, Awaitable,
-                    promise&>)
-
-            {
-                if constexpr (hpx::functional::is_tag_invocable_v<
-                                  as_awaitable_t, Awaitable, promise&>)
-                {
-                    return as_awaitable(HPX_FORWARD(Awaitable, await), *this);
-                }
-                else
-                {
-                    return HPX_FORWARD(Awaitable, await);
-                }
-            }
-
-            // Pass through the get_env receiver query
-            // clang-format off
-            friend auto tag_invoke(
-                get_env_t, type const& self) -> env_of_t<Receiver>
-            {
-                return get_env(self.rcvr);
-            }
-            // clang-format on
-
-            Receiver& rcvr;
-        };
-    };
-
-    template <typename Receiver,
-        typename = std::enable_if_t<is_receiver_v<Receiver>>>
-    using promise_t = hpx::meta::type<promise<hpx::meta::get_id_t<Receiver>>>;
-
-    template <typename Receiver,
-        typename = std::enable_if_t<is_receiver_v<Receiver>>>
-    using operation_t =
-        hpx::meta::type<operation<hpx::meta::get_id_t<Receiver>>>;
-
-    inline constexpr struct connect_awaitable_t
-    {
-    private:
-        template <typename Fun, typename... Ts>
-        static auto co_call(Fun fun, Ts&&... as) noexcept
-        {
-            auto fn = [&, fun]() noexcept { fun(HPX_FORWARD(Ts, as)...); };
-
-            struct awaiter
-            {
-                decltype(fn) fn_;
-
-                static constexpr bool await_ready() noexcept
-                {
-                    return false;
-                }
-
-                void await_suspend(hpx::coroutine_handle<>) noexcept
-                {
-                    fn_();
-                }
-
-                [[noreturn]] static void await_resume() noexcept
-                {
-                    std::terminate();
-                }
-            };
-
-            return awaiter{fn};
-        }
-
-        template <typename Awaitable, typename Receiver>
-        static operation_t<Receiver> impl(Awaitable await, Receiver rcvr)
-        {
-            using result_t = await_result_t<Awaitable, promise_t<Receiver>>;
-            std::exception_ptr eptr;
-            try
-            {
-                if constexpr (std::is_void_v<result_t>)
-                {
-                    // clang-format off
-                    co_await (co_await HPX_FORWARD(Awaitable, await),
-                        co_call(set_value, HPX_FORWARD(Receiver, rcvr)));
-                    // clang-format on
-                }
-                else
-                {
-                    co_await co_call(set_value, HPX_FORWARD(Receiver, rcvr),
-                        co_await HPX_FORWARD(Awaitable, await));
-                }
-            }
-            catch (...)
-            {
-                eptr = std::current_exception();
-            }
-
-            if (eptr)
-            {
-                co_await co_call(set_error, HPX_FORWARD(Receiver, rcvr),
-                    HPX_FORWARD(std::exception_ptr, eptr));
-            }
-        }
-
-        template <typename Receiver, typename Awaitable,
-            typename = std::enable_if_t<is_receiver_v<Receiver>>>
-        using completions_t = completion_signatures<
-            hpx::meta::invoke1<    // set_value_t() or set_value_t(T)
-                hpx::meta::remove<void, hpx::meta::compose_func<set_value_t>>,
-                await_result_t<Awaitable, promise_t<Receiver>>>,
-            set_error_t(std::exception_ptr), set_stopped_t()>;
-
-    public:
-        template <typename Receiver, typename Awaitable,
-            typename = std::enable_if_t<
-                is_awaitable_v<Awaitable, promise_t<Receiver>>>,
-            typename = std::enable_if_t<
-                is_receiver_of_v<Receiver, completions_t<Receiver, Awaitable>>>>
-        operation_t<Receiver> operator()(Awaitable&& await, Receiver rcvr) const
-        {
-            return impl(
-                HPX_FORWARD(Awaitable, await), HPX_FORWARD(Receiver, rcvr));
-        }
-    } connect_awaitable{};
-#endif    // HPX_HAVE_CXX20_COROUTINES
-
-    HPX_HOST_DEVICE_INLINE_CONSTEXPR_VARIABLE struct connect_t
-      : hpx::functional::detail::tag_fallback<connect_t>
-    {
-#if defined(HPX_HAVE_CXX20_COROUTINES)
-        template <typename Sender, typename Receiver,
-            typename = std::enable_if_t<
-                hpx::is_invocable_v<connect_awaitable_t, Sender, Receiver> ||
-                hpx::functional::is_tag_invocable_v<is_debug_env_t,
-                    env_of_t<Receiver>>>>
-        friend constexpr auto tag_fallback_invoke(
-            connect_t, Sender&& sndr, Receiver&& rcvr) noexcept
-        {
-            if constexpr (hpx::is_invocable_v<connect_awaitable_t, Sender,
-                              Receiver>)
-            {
-                return connect_awaitable(
-                    HPX_FORWARD(Sender, sndr), HPX_FORWARD(Receiver, rcvr));
-            }
-            else
-            {
-                return;
-            }
-        }
-#endif    // HPX_HAVE_CXX20_COROUTINES
-    } connect{};
-#endif    // NOT HPX_HAVE_STDEXEC
 
     template <typename Sender, typename Receiver>
     struct has_nothrow_connect
@@ -1607,207 +234,4 @@ namespace hpx::execution::experimental {
     {
     };
 
-#if !defined(HPX_HAVE_STDEXEC)
-#if defined(HPX_HAVE_CXX20_COROUTINES)
-    namespace detail {
-
-        template <typename PromiseId, typename SenderId>
-        struct sender_awaitable
-        {
-            using promise_type = hpx::meta::type<PromiseId>;
-            using sender_type = hpx::meta::type<SenderId>;
-            using env_type = env_of_t<promise_type>;
-            using value_type = single_sender_value_t<sender_type, env_type>;
-
-            struct type : sender_awaitable_base<PromiseId, value_type>
-            {
-                // clang-format off
-                type(sender_type&& sender, hpx::coroutine_handle<promise_type> hcoro)
-                    noexcept(has_nothrow_connect<sender_type, receiver>::value)
-                  : op_state_(connect(HPX_FORWARD(sender_type, sender),
-                        receiver{{&this->result, hcoro}}))
-                {
-                }
-                // clang-format on
-
-                void await_suspend(hpx::coroutine_handle<promise_type>) noexcept
-                {
-                    start(op_state_);
-                }
-
-            private:
-                using receiver = receiver_t<sender_type, promise_type>;
-                connect_result_t<sender_type, receiver> op_state_;
-            };
-        };
-    }     // namespace detail
-#endif    // HPX_HAVE_CXX20_COROUTINES
-
-    /// End definitions from coroutine_utils and sender
-
-    // Let r be an rvalue receiver of type R, and let S be the type of a sender.
-    // If error_types_of_t<S, env_of_t<R>, Variant> is well formed, it shall
-    // name the type Variant<E0, E1, ..., EN>, where the types E0 through EN are
-    // the types the sender S passes as arguments to execution::set_error
-    // (besides the receiver object). If such sender S odr-uses
-    // execution::set_error(r, e), where decltype(e) is not one of the types E0
-    // through EN (ignoring differences in rvalue-reference qualification), the
-    // program is ill-formed with no diagnostic required.
-    //
-    // clang-format off
-    template <typename Sender, typename Env = no_env,
-        template <typename...> typename Variant = detail::decayed_variant,
-        typename = std::enable_if_t<is_sender_v<Sender, Env>>>
-    // clang-format on
-    using error_types_of_t =
-        detail::error_types_from<detail::completion_signatures_of<Sender, Env>,
-            meta::func<Variant>>;
-
-    // clang-format off
-    template <typename Sender, typename Env = no_env,
-        typename = std::enable_if_t<is_sender_v<Sender, Env>>>
-    // clang-format on
-    inline constexpr bool sends_stopped_of_v =
-        meta::value<detail::sends_stopped_from<
-            detail::completion_signatures_of<Sender, Env>>>;
-
-    namespace detail {
-
-        // meta function versions for value_types_of, error_types_of, and
-        // sends_stopped
-        //
-        // Note: the value_types_of and error_types_of functions below do not
-        //       create an 'empty-variant' (this is different from the
-        //       corresponding functions execution::value_types_of_t and
-        //       execution::error_types_of_t).
-
-        // clang-format off
-        template <typename Sender, typename Env,
-            typename Tuple  = meta::func<meta::pack>,
-            typename Variant = meta::func<meta::pack>,
-            typename = std::enable_if_t<is_sender_v<Sender, Env>>>
-        // clang-format on
-        using value_types_of =
-            value_types_from<completion_signatures_of_t<Sender, Env>,
-                decay_tuple<Tuple::template apply>,
-                decay_variant<Variant::template apply>>;
-
-        // clang-format off
-        template <typename Sender, typename Env,
-            typename Variant = meta::func<meta::pack>,
-            typename = std::enable_if_t<is_sender_v<Sender, Env>>>
-        // clang-format on
-        using error_types_of =
-            error_types_from<completion_signatures_of_t<Sender, Env>,
-                decay_variant<Variant::template apply>>;
-
-        // clang-format off
-        template <typename Sender, typename Env = no_env,
-            typename = std::enable_if_t<is_sender_v<Sender, Env>>>
-        // clang-format on
-        using sends_stopped_of =
-            meta::bool_<completion_signatures_of_t<Sender, Env>::sends_stopped>;
-
-        // helpers for make_completion_signatures
-        template <typename... Ts>
-        using set_value_signature = set_value_t(Ts...);
-
-        template <typename Error>
-        using set_error_signature = set_error_t(Error);
-
-        template <typename Sender, typename Env, typename Signatures,
-            typename SetValue, typename SetError, typename SendsStopped>
-        using completion_signatures_t = meta::apply<
-            meta::remove<void, meta::unique<meta::func<completion_signatures>>>,
-            typename Signatures::signatures_t,
-            value_types_of<Sender, Env, SetValue, meta::func<meta::pack>>,
-            error_types_of<Sender, Env,
-                meta::transform<SetError, meta::func<meta::pack>>>,
-            meta::if_<SendsStopped, meta::pack<set_stopped_t()>, meta::pack<>>>;
-
-        template <typename Sender, typename Env, typename Signatures,
-            typename SetValue, typename SetError, bool SendsStopped>
-        struct make_helper
-        {
-            using type = completion_signatures_t<Sender, Env, Signatures,
-                SetValue, SetError, meta::bool_<SendsStopped>>;
-        };
-
-        template <typename Sender, typename Signatures, typename SetValue,
-            typename SetError, bool SendsStopped>
-        struct make_helper<Sender, no_env, Signatures, SetValue, SetError,
-            SendsStopped>
-        {
-            using type = dependent_completion_signatures<no_env>;
-        };
-    }    // namespace detail
-
-    // make_completion_signatures is an alias template used to adapt the
-    // completion signatures of a sender. It takes a sender, and environment,
-    // and several other template arguments that apply modifications to the
-    // sender's completion signatures to generate a new instantiation of
-    // execution::completion_signatures.
-    //
-    // Example:
-    //
-    // Given a sender S and an environment Env, adapt a S's completion
-    // signatures by lvalue-ref qualifying the values, adding an additional
-    // exception_ptr error completion if its not already there, and leaving the
-    // other signals alone.
-    //
-    //      template <typename... Args> using my_set_value_t =
-    //          execution::set_value_t(add_lvalue_reference_t<Args>...);
-    //
-    //      using my_completion_signals =
-    //          execution::make_completion_signatures<
-    //              S, Env, execution::completion_signatures<
-    //                  execution::set_error_t(exception_ptr)>,
-    //              my_set_value_t>;
-    //
-    // AddlSigs shall name an instantiation of the
-    // execution::completion_signatures class template.
-    //
-    // SetValue shall name an alias template such that for any template
-    // parameter pack As..., SetValue<As...> is either ill-formed, void or an
-    // alias for a function type whose return type is execution::set_value_t.
-    //
-    // SetError shall name an alias template such that for any type Err,
-    // SetError<Err> is either ill-formed, void or an alias for a function type
-    // whose return type is execution::set_error_t.
-    //
-    // Let Vs... be a pack of the non-void types in the type-list named by
-    // value_types_of_t<Sndr, Env, SetValue, type-list>.
-    //
-    // Let Es... be a pack of the non-void types in the type-list named by
-    // error_types_of_t<Sndr, Env, error-list>, where error-list is an alias
-    // template such that error-list<Ts...> names type-list<SetError<Ts>...>.
-    //
-    // Let Ss... be an empty pack if SendsStopped is false; otherwise, a pack
-    // containing the single type execution::set_stopped_t().
-    //
-    // Let MoreSigs... be a pack of the template arguments of the
-    // execution::completion_signatures instantiation named by AddlSigs.
-    //
-    // If any of the above types are ill-formed, then
-    // make_completion_signatures<Sndr, Env, AddlSigs, SetValue, SetDone,
-    // SendsStopped> is an alias for dependent_completion_signatures<Env>.
-    //
-    // Otherwise, make_completion_signatures<Sndr, Env, AddlSigs, SetValue,
-    // SetDone, SendsStopped> names the type completion_signatures<Sigs...>
-    // where Sigs... is the unique set of types in [Vs..., Es..., Ss...,
-    // MoreSigs...].
-    //
-    // clang-format off
-    template <typename Sender, typename Env = no_env,
-        typename AddlSignatures = completion_signatures<>,
-        template <typename...> typename SetValue = detail::set_value_signature,
-        template <typename> typename SetError = detail::set_error_signature,
-        bool SendsStopped =
-            completion_signatures_of_t<Sender, Env>::sends_stopped,
-        typename = std::enable_if_t<is_sender_v<Sender, Env>>>
-    // clang-format on
-    using make_completion_signatures =
-        meta::type<detail::make_helper<Sender, Env, AddlSignatures,
-            meta::func<SetValue>, meta::func1<SetError>, SendsStopped>>;
-#endif    // NOT HPX_HAVE_STDEXEC
 }    // namespace hpx::execution::experimental
diff --git a/libs/core/execution_base/include/hpx/execution_base/coroutine_utils.hpp b/libs/core/execution_base/include/hpx/execution_base/coroutine_utils.hpp
index d9300fe13069..95653ee8e492 100644
--- a/libs/core/execution_base/include/hpx/execution_base/coroutine_utils.hpp
+++ b/libs/core/execution_base/include/hpx/execution_base/coroutine_utils.hpp
@@ -31,49 +31,6 @@ namespace hpx::execution::experimental {
     //   3. Otherwise, sender-awaitable{e, p} if awaitable-sender<E, P>
     //      is true.
     //   4. Otherwise, e.
-#if !defined(HPX_HAVE_STDEXEC)
-    struct as_awaitable_t;
-
-    struct connect_awaitable_t;
-
-    namespace detail {
-
-        template <typename Value>
-        struct receiver_base;
-
-        template <typename PromiseId, typename Value>
-        struct sender_awaitable_base;
-
-        template <typename PromiseId, typename SenderId>
-        struct sender_awaitable;
-    }    // namespace detail
-
-    namespace detail {
-
-        struct with_awaitable_senders_base;
-    }    // namespace detail
-
-    // with_awaitable_senders, when used as the base class of a coroutine
-    // promise type, makes senders awaitable in that coroutine type. In
-    // addition, it provides a default implementation of unhandled_stopped()
-    // such that if a sender completes by calling execution::set_stopped, it is
-    // treated as if an uncatchable "stopped" exception were thrown from the
-    // await-expression. In practice, the coroutine is never resumed, and the
-    // unhandled_stopped of the coroutine caller's promise type is called.
-    //
-    //    template <typename Promise>
-    //    struct with_awaitable_senders;
-
-    struct promise_base;
-
-    struct operation_base;
-
-    template <typename ReceiverId>
-    struct promise;
-
-    template <typename ReceiverId>
-    struct operation;
-#endif
 }    // namespace hpx::execution::experimental
 
 #endif    // HPX_HAVE_CXX20_COROUTINES
diff --git a/libs/core/execution_base/include/hpx/execution_base/get_env.hpp b/libs/core/execution_base/include/hpx/execution_base/get_env.hpp
index 627b25bba325..898457b81118 100644
--- a/libs/core/execution_base/include/hpx/execution_base/get_env.hpp
+++ b/libs/core/execution_base/include/hpx/execution_base/get_env.hpp
@@ -12,7 +12,6 @@
 #include <hpx/type_support/meta.hpp>
 #include <hpx/type_support/unwrap_ref.hpp>
 
-#if defined(HPX_HAVE_STDEXEC)
 #include <hpx/execution_base/stdexec_forward.hpp>
 
 #if defined(HPX_GCC_VERSION)
@@ -46,233 +45,3 @@ namespace hpx::execution::experimental {
 
     using exec::read_with_default;
 }    // namespace hpx::execution::experimental
-#else
-
-#include <type_traits>
-#include <utility>
-
-namespace hpx::execution::experimental {
-
-    // 11.3.1. queryable concept [exec.queries.queryable]
-    // 1. A query object is a customization point object
-    //    ([customization.point.object]) that accepts as its first argument
-    //    a queryable object, and for each such invocation that is valid,
-    //    produces a value of the corresponding property of the object.
-    // 2. Unless otherwise specified, given a queryable object e, a query
-    //    object Q, and a pack of subexpressions args, the value returned
-    //    by the expression Q(e, args...) is valid as long as e is valid.
-    //
-    //    Let e be an object of type E. The type E models queryable if for
-    //    each callable object Q and a pack of subexpressions args, if
-    //    requires { Q(e, args...) } is true then Q(e, args...) meets any
-    //    semantic requirements imposed by Q.
-    //
-    // Reference implementation avoids using libstdc++'s object concepts
-    // because they instantiate a lot of templates.
-    template <typename T>
-    inline constexpr bool is_queryable_v = std::is_destructible_v<T>;
-
-    namespace detail {
-
-        // checks whether tag_invoke(CPO, Args...) is contextually convertible
-        // to bool, apply this meta function only for tag_invoke overloads
-        template <typename CPO>
-        struct contextually_convertible_to_bool
-        {
-            template <typename EnableTag, typename... Args>
-            struct apply : std::true_type
-            {
-            };
-
-            template <typename... Args>
-            struct apply<hpx::functional::enable_tag_invoke_t, Args...>
-              : std::is_invocable_r<bool,
-                    hpx::functional::tag_t<hpx::functional::tag_invoke>, CPO,
-                    Args...>
-            {
-            };
-        };
-    }    // namespace detail
-
-    // 1. An execution environment contains state associated with the
-    //    completion of an asynchronous operation. Every receiver has an
-    //    associated execution environment, accessible with the get_env receiver
-    //    query. The state of an execution environment is accessed with
-    //    customization point objects. An execution environment may respond to
-    //    any number of these environment queries.
-    //
-    // 2. An environment query is a customization point object that accepts
-    //    as its first argument an execution environment. For an environment
-    //    query EQ and an object e of type no_env, the expression EQ(e) shall be
-    //    ill-formed.
-    //
-    namespace exec_envs {
-
-        // no_env is a special environment used by the sender concept and by the
-        // get_completion_signatures customization point when the user has
-        // specified no environment argument.
-        //
-        //  [Note: A user may choose to not specify an environment in order
-        //         to see if a sender knows its completion signatures
-        //         independent of any particular execution environment.
-        //  -- end note]
-        struct no_env
-        {
-            using type = no_env;
-            using id = no_env;
-
-            template <typename Tag, typename Env>
-            friend std::enable_if_t<std::is_same_v<no_env, std::decay_t<Env>>>
-                tag_invoke(Tag, Env) = delete;
-        };
-
-        struct empty_env
-        {
-            using type = empty_env;
-            using id = empty_env;
-        };
-
-        template <typename Tag, typename Value, typename BaseEnv = empty_env>
-        struct env
-        {
-            struct type
-            {
-                using id = env;
-
-                HPX_NO_UNIQUE_ADDRESS util::unwrap_reference_t<Value> value_;
-                HPX_NO_UNIQUE_ADDRESS BaseEnv base_env_{};
-
-                // Forward only the receiver queries
-                template <typename Tag2, typename... Args,
-                    typename = std::enable_if_t<functional::is_tag_invocable_v<
-                        Tag2, BaseEnv const&, Args...>>>
-                friend constexpr auto tag_invoke(
-                    Tag2 tag, type const& self, Args&&... args) noexcept
-                    -> functional::tag_invoke_result_t<Tag2, BaseEnv const&,
-                        Args...>
-                {
-                    return HPX_FORWARD(Tag2, tag)(
-                        self.base_env_, HPX_FORWARD(Args, args)...);
-                }
-
-                template <typename... Args>
-                friend constexpr auto
-                tag_invoke(Tag, type const& self, Args&&...) noexcept(
-                    std::is_nothrow_copy_constructible_v<
-                        util::unwrap_reference_t<Value>>)
-                    -> util::unwrap_reference_t<Value>
-                {
-                    return self.value_;
-                }
-            };
-        };
-
-        template <typename Tag, typename Value, typename BaseEnv = empty_env>
-        using env_t = std::decay_t<hpx::meta::type<env<Tag, Value, BaseEnv>>>;
-
-        template <typename Tag>
-        struct make_env_t
-        {
-            template <typename Value>
-            constexpr auto operator()(Value&& value) const
-                noexcept(std::is_nothrow_copy_constructible_v<
-                    util::unwrap_reference_t<std::decay_t<Value>>>)
-                    -> env_t<Tag, std::decay_t<Value>>
-            {
-                return {HPX_FORWARD(Value, value)};
-            }
-
-            template <typename Value, typename BaseEnvId>
-            constexpr auto operator()(Value&& value, BaseEnvId&& base_env) const
-                -> env_t<Tag, std::decay_t<Value>, std::decay_t<BaseEnvId>>
-            {
-                return {HPX_FORWARD(Value, value),
-                    HPX_FORWARD(BaseEnvId, base_env)};
-            }
-        };
-
-        // For making an evaluation environment from a key/value pair, and
-        // optionally another environment.
-        template <typename Tag>
-        inline constexpr exec_envs::make_env_t<Tag> make_env{};
-
-    }    // namespace exec_envs
-
-    using exec_envs::empty_env;
-    using exec_envs::env;
-    using exec_envs::make_env;
-    using exec_envs::no_env;
-
-    template <typename Env>
-    struct is_no_env : std::is_same<std::decay_t<Env>, no_env>
-    {
-    };
-
-    template <typename Env>
-    inline constexpr bool is_no_env_v = is_no_env<Env>::value;
-
-    // get_env is a customization point object. For some subexpression r,
-    // get_env(r) is expression-equivalent to:
-    //
-    // 1. tag_invoke(execution::get_env, r) if that expression is well-formed.
-    // 2. Otherwise, empty_env{}.
-    //
-    HPX_HOST_DEVICE_INLINE_CONSTEXPR_VARIABLE struct get_env_t final
-      : hpx::functional::detail::tag_fallback<get_env_t>
-    {
-    private:
-        template <typename EnvProvider>
-        friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(
-            get_env_t, EnvProvider&&) noexcept
-        {
-            return empty_env{};
-        }
-    } get_env{};
-
-    template <typename T>
-    using env_of_t = decltype(get_env(std::declval<T>()));
-
-    // different versions of clang-format disagree
-    // clang-format off
-    template <typename Tag, typename Value, typename BaseEnv = empty_env>
-    using make_env_t = decltype(
-        make_env<Tag>(std::declval<Value&&>(), std::declval<BaseEnv&&>()));
-    // clang-format on
-
-    // execution::forwarding_env_query is used to ask a customization point
-    // object whether it is an environment query that should be forwarded
-    // through environment adaptors.
-    //
-    // The name execution::forwarding_env_query denotes a customization point
-    // object. For some subexpression t, execution::forwarding_env_query(t) is
-    // expression equivalent to:
-    //
-    // 1. tag_invoke(execution::forwarding_env_query, t), contextually converted
-    //    to bool, if the tag_invoke expression is well formed.
-    //
-    //      - Mandates: The tag_invoke expression is indeed contextually
-    //        convertible to bool, that expression and the contextual conversion
-    //        are not potentially-throwing and are core constant expressions if
-    //        t is a core constant expression.
-    //
-    // 2. Otherwise, false.
-    //
-    HPX_HOST_DEVICE_INLINE_CONSTEXPR_VARIABLE struct forwarding_env_query_t
-        final
-      : hpx::functional::detail::tag_fallback_noexcept<forwarding_env_query_t,
-            detail::contextually_convertible_to_bool<forwarding_env_query_t>>
-    {
-    private:
-        template <typename T>
-        friend constexpr HPX_FORCEINLINE auto tag_fallback_invoke(
-            forwarding_env_query_t, T&&) noexcept
-        {
-            return false;
-        }
-    } forwarding_env_query{};
-
-    template <typename T>
-    inline constexpr bool is_environment_provider_v =
-        std::is_same_v<T, hpx::util::invoke_result_t<get_env_t, T>>;
-}    // namespace hpx::execution::experimental
-#endif
diff --git a/libs/core/execution_base/include/hpx/execution_base/operation_state.hpp b/libs/core/execution_base/include/hpx/execution_base/operation_state.hpp
index 1e382527b321..be28aaa2785d 100644
--- a/libs/core/execution_base/include/hpx/execution_base/operation_state.hpp
+++ b/libs/core/execution_base/include/hpx/execution_base/operation_state.hpp
@@ -9,7 +9,6 @@
 
 #include <hpx/config.hpp>
 
-#if defined(HPX_HAVE_STDEXEC)
 #include <hpx/execution_base/stdexec_forward.hpp>
 
 namespace hpx::execution::experimental {
@@ -23,100 +22,3 @@ namespace hpx::execution::experimental {
     {
     };
 }    // namespace hpx::execution::experimental
-#else
-
-#include <hpx/config/constexpr.hpp>
-#include <hpx/functional/tag_invoke.hpp>
-#include <hpx/functional/traits/is_invocable.hpp>
-#include <hpx/type_support/meta.hpp>
-
-#include <type_traits>
-#include <utility>
-
-namespace hpx::execution::experimental {
-
-#if defined(DOXYGEN)
-    /// start is a customization point object. The expression
-    /// `hpx::execution::experimental::start(r)` is equivalent to:
-    ///     * `r.start()`, if that expression is valid. If the function selected
-    ///       does not signal the receiver `r`'s done channel,
-    ///       the program is ill-formed (no diagnostic required).
-    ///     * Otherwise, `start(r), if that expression is valid, with
-    ///       overload resolution performed in a context that include the declaration
-    ///       `void start();`
-    ///     * Otherwise, the expression is ill-formed.
-    ///
-    /// The customization is implemented in terms of `hpx::functional::tag_invoke`.
-    template <typename O>
-    void start(O&& o);
-
-    /// An `operation_state` is an object representing the asynchronous operation
-    /// that has been returned from calling `hpx::execution::experimental::connect` with
-    /// a `sender` and a `receiver`. The only operation on an `operation_state`
-    /// is:
-    ///     * `hpx::execution::experimental::start`
-    ///
-    /// `hpx::execution::experimental::start` can be called exactly once. Once it has
-    /// been invoked, the caller needs to ensure that the receiver's completion
-    /// signaling operations strongly happen before the destructor of the state
-    /// is called. The call to `hpx::execution::experimental::start` needs to happen
-    /// strongly before the completion signaling operations.
-    ///
-    template <typename O>
-    struct is_operation_state;
-#endif
-
-    namespace detail {
-
-        // start should not be callable for operation states that are rvalues
-        struct enable_start
-        {
-            template <typename EnableTag, typename... Ts>
-            struct apply : std::false_type
-            {
-            };
-
-            template <typename EnableTag, typename State>
-            struct apply<EnableTag, State> : std::is_lvalue_reference<State>
-            {
-            };
-        };
-    }    // namespace detail
-
-    HPX_HOST_DEVICE_INLINE_CONSTEXPR_VARIABLE
-    struct start_t
-      : hpx::functional::tag_noexcept<start_t, detail::enable_start>
-    {
-    } start{};
-
-    namespace detail {
-
-        template <bool IsOperationState, typename O>
-        struct is_operation_state_impl;
-
-        template <typename O>
-        struct is_operation_state_impl<false, O> : std::false_type
-        {
-        };
-
-        template <typename O>
-        struct is_operation_state_impl<true, O>
-          : std::integral_constant<bool, noexcept(start(std::declval<O&>()))>
-        {
-        };
-    }    // namespace detail
-
-    template <typename O>
-    struct is_operation_state
-      : detail::is_operation_state_impl<std::is_destructible_v<O> &&
-                std::is_object_v<O> &&
-                hpx::is_invocable_v<start_t, std::decay_t<O>&>,
-            O>
-    {
-    };
-
-    template <typename O>
-    inline constexpr bool is_operation_state_v =
-        meta::value<is_operation_state<O>>;
-}    // namespace hpx::execution::experimental
-#endif
diff --git a/libs/core/execution_base/include/hpx/execution_base/receiver.hpp b/libs/core/execution_base/include/hpx/execution_base/receiver.hpp
index 9d9f1462666c..750c713fae1d 100644
--- a/libs/core/execution_base/include/hpx/execution_base/receiver.hpp
+++ b/libs/core/execution_base/include/hpx/execution_base/receiver.hpp
@@ -9,7 +9,6 @@
 
 #include <hpx/config.hpp>
 
-#if defined(HPX_HAVE_STDEXEC)
 #include <hpx/execution_base/stdexec_forward.hpp>
 #include <type_traits>
 
@@ -48,305 +47,3 @@ namespace hpx::execution::experimental {
     }    // namespace detail
 
 }    // namespace hpx::execution::experimental
-
-#else
-
-#include <hpx/config/constexpr.hpp>
-#include <hpx/functional/tag_invoke.hpp>
-#include <hpx/functional/traits/is_invocable.hpp>
-#include <hpx/type_support/meta.hpp>
-#include <hpx/type_support/pack.hpp>
-
-#include <exception>
-#include <type_traits>
-#include <utility>
-
-namespace hpx::execution::experimental {
-
-#if defined(DOXYGEN)
-    /// set_value is a customization point object. The expression
-    /// `hpx::execution::set_value(r, as...)` is equivalent to:
-    ///     * `r.set_value(as...)`, if that expression is valid. If the function
-    ///       selected does not send the value(s) `as...` to the Receiver `r`'s
-    ///       value channel, the program is ill-formed (no diagnostic required).
-    ///     * Otherwise, `set_value(r, as...), if that expression is valid, with
-    ///       overload resolution performed in a context that include the
-    ///       declaration `void set_value();`
-    ///     * Otherwise, the expression is ill-formed.
-    ///
-    /// The customization is implemented in terms of
-    /// `hpx::functional::tag_invoke`.
-    template <typename R, typename... As>
-    void set_value(R&& r, As&&... as);
-
-    /// set_stopped is a customization point object. The expression
-    /// `hpx::execution::set_stopped(r)` is equivalent to:
-    ///     * `r.set_stopped()`, if that expression is valid. If the function
-    ///       selected does not signal the Receiver `r`'s done channel, the
-    ///       program is ill-formed (no diagnostic required).
-    ///     * Otherwise, `set_stopped(r), if that expression is valid, with
-    ///       overload resolution performed in a context that include the
-    ///       declaration `void set_stopped();`
-    ///     * Otherwise, the expression is ill-formed.
-    ///
-    /// The customization is implemented in terms of
-    /// `hpx::functional::tag_invoke`.
-    template <typename R>
-    void set_stopped(R&& r);
-
-    /// set_error is a customization point object. The expression
-    /// `hpx::execution::set_error(r, e)` is equivalent to:
-    ///     * `r.set_stopped(e)`, if that expression is valid. If the function
-    ///       selected does not send the error `e` the Receiver `r`'s error
-    ///       channel, the program is ill-formed (no diagnostic required).
-    ///     * Otherwise, `set_error(r, e), if that expression is valid, with
-    ///       overload resolution performed in a context that include the
-    ///       declaration `void set_error();`
-    ///     * Otherwise, the expression is ill-formed.
-    ///
-    /// The customization is implemented in terms of
-    /// `hpx::functional::tag_invoke`.
-    template <typename R, typename E>
-    void set_error(R&& r, E&& e);
-#endif
-
-    /// Receiving values from asynchronous computations is handled by the
-    /// `Receiver` concept. A `Receiver` needs to be able to receive an error or
-    /// be marked as being canceled. As such, the Receiver concept is defined by
-    /// having the following two customization points defined, which form the
-    /// completion-signal operations:
-    ///     * `hpx::execution::experimental::set_stopped` *
-    ///       `hpx::execution::experimental::set_error`
-    ///
-    /// Those two functions denote the completion-signal operations. The
-    /// Receiver contract is as follows:
-    ///     * None of a Receiver's completion-signal operation shall be invoked
-    ///       before `hpx::execution::experimental::start` has been called on
-    ///       the operation state object that was returned by connecting a
-    ///       Receiver to a sender `hpx::execution::experimental::connect`.
-    ///     * Once `hpx::execution::start` has been called on the operation
-    ///       state object, exactly one of the Receiver's completion-signal
-    ///       operation shall complete without an exception before the Receiver
-    ///       is destroyed
-    ///
-    /// Once one of the Receiver's completion-signal operation has been
-    /// completed without throwing an exception, the Receiver contract has been
-    /// satisfied. In other words: The asynchronous operation has been
-    /// completed.
-    ///
-    /// \see hpx::execution::experimental::is_receiver_of
-    template <typename T, typename E = std::exception_ptr>
-    struct is_receiver;
-
-    /// The `receiver_of` concept is a refinement of the `Receiver` concept by
-    /// requiring one additional completion-signal operation:
-    ///     * `hpx::execution::set_value`
-    ///
-    /// The `receiver_of` concept takes a receiver and an instance of the
-    /// `completion_signatures<>` class template. The `receiver_of` concept,
-    /// rather than accepting a receiver and some value types, is changed to
-    /// take a receiver and an instance of the `completion_signatures<>` class
-    /// template. A sender uses `completion_signatures<>` to describe the
-    /// signals with which it completes. The `receiver_of` concept ensures that
-    /// a particular receiver is capable of receiving those signals.
-    ///
-    /// This completion-signal operation adds the following to the Receiver's
-    /// contract:
-    ///     * If `hpx::execution::set_value` exits with an exception, it
-    ///       is still valid to call `hpx::execution::set_error` or
-    ///       `hpx::execution::set_stopped`
-    ///
-    /// \see hpx::execution::traits::is_receiver
-    template <typename Receiver, typename CS>
-    struct is_receiver_of;
-
-    HPX_HOST_DEVICE_INLINE_CONSTEXPR_VARIABLE
-    struct set_value_t : hpx::functional::tag<set_value_t>
-    {
-    } set_value{};
-
-    HPX_HOST_DEVICE_INLINE_CONSTEXPR_VARIABLE
-    struct set_error_t : hpx::functional::tag_noexcept<set_error_t>
-    {
-    } set_error{};
-
-    HPX_HOST_DEVICE_INLINE_CONSTEXPR_VARIABLE
-    struct set_stopped_t : hpx::functional::tag_noexcept<set_stopped_t>
-    {
-    } set_stopped{};
-
-    ///////////////////////////////////////////////////////////////////////
-    namespace detail {
-
-        template <bool ConstructionRequirements, typename T, typename E>
-        struct is_receiver_impl;
-
-        template <typename T, typename E>
-        struct is_receiver_impl<false, T, E> : std::false_type
-        {
-        };
-
-        template <typename T, typename E>
-        struct is_receiver_impl<true, T, E>
-          : std::integral_constant<bool,
-                hpx::is_invocable_v<set_stopped_t, std::decay_t<T>&&> &&
-                    hpx::is_invocable_v<set_error_t, std::decay_t<T>&&, E>>
-        {
-        };
-    }    // namespace detail
-
-    template <typename T, typename E>
-    struct is_receiver
-      : detail::is_receiver_impl<
-            std::is_move_constructible_v<std::decay_t<T>> &&
-                std::is_constructible_v<std::decay_t<T>, T>,
-            T, E>
-    {
-    };
-
-    template <typename T, typename E = std::exception_ptr>
-    inline constexpr bool is_receiver_v = is_receiver<T, E>::value;
-
-    ///////////////////////////////////////////////////////////////////////
-    namespace detail {
-
-        template <bool IsReceiverOf, typename T, typename CS>
-        struct is_receiver_of_impl;
-
-        template <typename T, typename CS>
-        struct is_receiver_of_impl<false, T, CS> : std::false_type
-        {
-        };
-
-        template <typename F, typename T, typename Variant>
-        struct is_invocable_variant_of_tuples : std::false_type
-        {
-        };
-
-        template <typename F, typename T, typename... Ts>
-        struct is_invocable_variant_of_tuples<F, T,
-            meta::pack<meta::pack<Ts...>>>
-          : hpx::is_invocable<F, std::decay_t<T>&&, Ts...>
-        {
-        };
-
-        template <typename F, typename T, typename Variant>
-        struct is_invocable_variant : std::false_type
-        {
-        };
-
-        template <typename F, typename T, typename... Ts>
-        struct is_invocable_variant<F, T, meta::pack<Ts...>>
-          : hpx::is_invocable<F, std::decay_t<T>&&, Ts...>
-        {
-        };
-
-        template <typename T, typename CS>
-        struct is_receiver_of_impl<true, T, CS>
-          : std::integral_constant<bool,
-                is_invocable_variant_of_tuples<set_value_t, T,
-                    typename CS::template value_types<meta::pack,
-                        meta::pack>>::value &&
-                    is_invocable_variant<set_error_t, T,
-                        typename CS::template error_types<meta::pack>>::value &&
-                    CS::sends_stopped>
-        {
-        };
-    }    // namespace detail
-
-    template <typename T, typename CS>
-    struct is_receiver_of : detail::is_receiver_of_impl<is_receiver_v<T>, T, CS>
-    {
-    };
-
-    template <typename T, typename CS>
-    inline constexpr bool is_receiver_of_v = is_receiver_of<T, CS>::value;
-
-    ///////////////////////////////////////////////////////////////////////
-    namespace detail {
-
-        template <typename F, typename T, typename Variant>
-        struct is_nothrow_invocable_variant_of_tuples : std::false_type
-        {
-        };
-
-        template <typename F, typename T, typename... Ts>
-        struct is_nothrow_invocable_variant_of_tuples<F, T,
-            meta::pack<meta::pack<Ts...>>>
-          : hpx::functional::is_nothrow_tag_invocable<F, std::decay_t<T>&&,
-                Ts...>
-        {
-        };
-
-        template <typename F, typename T, typename Variant>
-        struct is_nothrow_invocable_variant : std::false_type
-        {
-        };
-
-        template <typename F, typename T, typename... Ts>
-        struct is_nothrow_invocable_variant<F, T, meta::pack<Ts...>>
-          : hpx::functional::is_nothrow_tag_invocable<F, std::decay_t<T>&&,
-                Ts...>
-        {
-        };
-
-        template <bool IsReceiverOf, typename T, typename CS>
-        struct is_nothrow_receiver_of_impl;
-
-        template <typename T, typename CS>
-        struct is_nothrow_receiver_of_impl<false, T, CS> : std::false_type
-        {
-        };
-
-        template <typename T, typename CS>
-        struct is_nothrow_receiver_of_impl<true, T, CS>
-          : std::integral_constant<bool,
-                is_nothrow_invocable_variant_of_tuples<set_value_t, T,
-                    typename CS::template value_types<meta::pack,
-                        meta::pack>>::value &&
-                    is_nothrow_invocable_variant<set_error_t, T,
-                        typename CS::template error_types<meta::pack>>::value &&
-                    CS::sends_stopped>
-        {
-        };
-    }    // namespace detail
-
-    template <typename T, typename CS>
-    struct is_nothrow_receiver_of
-      : detail::is_nothrow_receiver_of_impl<
-            is_receiver_v<T> && is_receiver_of_v<T, CS>, T, CS>
-    {
-    };
-
-    template <typename T, typename CS>
-    inline constexpr bool is_nothrow_receiver_of_v =
-        is_nothrow_receiver_of<T, CS>::value;
-
-    namespace detail {
-
-        template <typename CPO>
-        struct is_receiver_cpo : std::false_type
-        {
-        };
-
-        template <>
-        struct is_receiver_cpo<set_value_t> : std::true_type
-        {
-        };
-
-        template <>
-        struct is_receiver_cpo<set_error_t> : std::true_type
-        {
-        };
-
-        template <>
-        struct is_receiver_cpo<set_stopped_t> : std::true_type
-        {
-        };
-
-        template <typename CPO>
-        inline constexpr bool is_receiver_cpo_v = is_receiver_cpo<CPO>::value;
-    }    // namespace detail
-}    // namespace hpx::execution::experimental
-
-#endif
diff --git a/libs/core/execution_base/include/hpx/execution_base/sender.hpp b/libs/core/execution_base/include/hpx/execution_base/sender.hpp
index 5c4f593b35c5..04fa3555584f 100644
--- a/libs/core/execution_base/include/hpx/execution_base/sender.hpp
+++ b/libs/core/execution_base/include/hpx/execution_base/sender.hpp
@@ -9,7 +9,6 @@
 
 #include <hpx/config.hpp>
 
-#if defined(HPX_HAVE_STDEXEC)
 #include <hpx/execution_base/stdexec_forward.hpp>
 
 namespace hpx::execution::experimental {
@@ -29,193 +28,3 @@ namespace hpx::execution::experimental {
         };
     }    // namespace detail
 }    // namespace hpx::execution::experimental
-#else
-
-#include <hpx/config/constexpr.hpp>
-#include <hpx/execution_base/coroutine_utils.hpp>
-#include <hpx/execution_base/get_env.hpp>
-#include <hpx/execution_base/operation_state.hpp>
-#include <hpx/execution_base/receiver.hpp>
-#include <hpx/functional/invoke_result.hpp>
-#include <hpx/functional/tag_invoke.hpp>
-#include <hpx/functional/traits/is_invocable.hpp>
-#include <hpx/type_support/equality.hpp>
-#include <hpx/type_support/meta.hpp>
-
-#include <cstddef>
-#include <exception>
-#include <type_traits>
-
-namespace hpx::execution::experimental {
-
-#if defined(DOXYGEN)
-    /// connect is a customization point object.
-    /// For some subexpression `s` and `r`, let `S` be the type such that `decltype((s))`
-    /// is `S` and let `R` be the type such that `decltype((r))` is `R`. The result of
-    /// the expression `hpx::execution::experimental::connect(s, r)` is then equivalent to:
-    ///     * `s.connect(r)`, if that expression is valid and returns a type
-    ///       satisfying the `operation_state`
-    ///       (\see hpx::execution::experimental::traits::is_operation_state)
-    ///       and if `S` satisfies the `sender` concept.
-    ///     * `s.connect(r)`, if that expression is valid and returns a type
-    ///       satisfying the `operation_state`
-    ///       (\see hpx::execution::experimental::traits::is_operation_state)
-    ///       and if `S` satisfies the `sender` concept.
-    ///       Overload resolution is performed in a context that include the declaration
-    ///       `void connect();`
-    ///     * Otherwise, the expression is ill-formed.
-    ///
-    /// The customization is implemented in terms of
-    /// `hpx::functional::tag_invoke`.
-    template <typename S, typename R>
-    void connect(S&& s, R&& r);
-
-    /// The name schedule denotes a customization point object. For some
-    /// subexpression s, let S be decltype((s)). The expression schedule(s) is
-    /// expression-equivalent to:
-    ///
-    ///     * s.schedule(), if that expression is valid and its type models
-    ///       sender.
-    ///     * Otherwise, schedule(s), if that expression is valid and its type
-    ///       models sender with overload resolution performed in a context that
-    ///       includes the declaration
-    ///
-    ///           void schedule();
-    ///
-    ///       and that does not include a declaration of schedule.
-    ///
-    ///      * Otherwise, schedule(s) is ill-formed.
-    ///
-    /// The customization is implemented in terms of
-    /// `hpx::functional::tag_invoke`.
-
-#endif
-
-    // execution::connect is used to connect a sender with a receiver, producing
-    // an operation state object that represents the work that needs to be
-    // performed to satisfy the receiver contract of the receiver with values
-    // that are the result of the operations described by the sender.
-    //
-    // execution::connect is a customization point which connects senders with
-    // receivers, resulting in an operation state that will ensure that the
-    // receiver contract of the receiver passed to connect will be fulfilled.
-    //
-    //      execution::sender auto snd = some input sender;
-    //      execution::receiver auto rcv = some receiver;
-    //      execution::operation_state auto state = execution::connect(snd, rcv);
-    //
-    //      execution::start(state);
-    //
-    //      // at this point, it is guaranteed that the work represented by state
-    //      // has been submitted to an execution context, and that execution
-    //      // context will eventually fulfill receiver contract of rcv
-    //
-    //      // operation states are not movable, and therefore this operation
-    //      // state object must be kept alive until the operation finishes
-    //
-    struct connect_t;
-
-    namespace detail {
-
-        template <typename S, typename R, typename Enable = void>
-        struct connect_result_helper
-        {
-            struct dummy_operation_state
-            {
-            };
-
-            using type = dummy_operation_state;
-        };
-
-        template <typename S, typename R>
-        struct connect_result_helper<S, R,
-            std::enable_if_t<hpx::is_invocable<connect_t, S, R>::value>>
-          : hpx::util::invoke_result<connect_t, S, R>
-        {
-        };
-    }    // namespace detail
-
-    namespace detail {
-
-        template <typename F, typename E>
-        struct as_receiver
-        {
-            F f;
-
-            void set_value() noexcept(noexcept(HPX_INVOKE(f, )))
-            {
-                HPX_INVOKE(f, );
-            }
-
-            template <typename E_>
-            [[noreturn]] static void set_error(E_&&) noexcept
-            {
-                std::terminate();
-            }
-
-            static constexpr void set_stopped() noexcept {}
-        };
-    }    // namespace detail
-
-    // Returns a sender describing the start of a task graph on the provided
-    // scheduler.
-    //
-    // A scheduler is a lightweight handle that represents a strategy for
-    // scheduling work onto an execution context. Since execution contexts don't
-    // necessarily manifest in C++ code, it's not possible to program directly
-    // against their API. A scheduler is a solution to that problem: the
-    // scheduler concept is defined by a single sender algorithm, schedule,
-    // which returns a sender that will complete on an execution context
-    // determined by the scheduler. Logic that you want to run on that context
-    // can be placed in the receiver's completion-signalling method.
-    //
-    // snd is a sender describing the creation of a new execution resource on
-    // the execution context associated with sch
-    //
-    //      execution::scheduler auto sch = thread_pool.scheduler();
-    //      execution::sender auto snd = execution::schedule(sch);
-    //
-    // Note that a particular scheduler type may provide other kinds of
-    // scheduling operations which are supported by its associated execution
-    // context. It is not limited to scheduling purely using the
-    // execution::schedule API.
-    //
-    HPX_HOST_DEVICE_INLINE_CONSTEXPR_VARIABLE
-    struct schedule_t : hpx::functional::tag<schedule_t>
-    {
-    } schedule{};
-
-    template <typename Scheduler, typename Enable = void>
-    struct is_scheduler : std::false_type
-    {
-    };
-
-    // different versions of clang-format disagree
-    // clang-format off
-    template <typename Scheduler>
-    struct is_scheduler<Scheduler,
-        std::enable_if_t<
-            hpx::is_invocable_v<schedule_t, std::decay_t<Scheduler>> &&
-            std::is_copy_constructible_v<std::decay_t<Scheduler>> &&
-            hpx::traits::is_equality_comparable_v<std::decay_t<Scheduler>>>>
-      : std::true_type
-    {
-    };
-    // clang-format on
-
-    template <typename Scheduler>
-    inline constexpr bool is_scheduler_v = is_scheduler<Scheduler>::value;
-
-    template <typename S>
-    using schedule_result_t = hpx::util::invoke_result_t<schedule_t, S>;
-
-    namespace detail {
-
-        // Dummy type used in place of a scheduler if none is given
-        struct no_scheduler
-        {
-        };
-    }    // namespace detail
-}    // namespace hpx::execution::experimental
-
-#endif
diff --git a/libs/core/execution_base/include/hpx/execution_base/stdexec_forward.hpp b/libs/core/execution_base/include/hpx/execution_base/stdexec_forward.hpp
index 79a3d86a3654..54fc421ad90a 100644
--- a/libs/core/execution_base/include/hpx/execution_base/stdexec_forward.hpp
+++ b/libs/core/execution_base/include/hpx/execution_base/stdexec_forward.hpp
@@ -7,8 +7,6 @@
 #pragma once
 #include <hpx/config.hpp>
 
-#if defined(HPX_HAVE_STDEXEC)
-
 /* TODO: Find out what diagnostics should be disabled for stdexec to compile.
  * currently it seems to need at least "-Wgnu-zero-variadic-macro-arguments"
  * and "-Wmissing-braces" even though they are explicitly disabled inside
@@ -313,4 +311,3 @@ namespace hpx::execution::experimental {
 // Leaving this as a placeholder
 namespace hpx::this_thread {
 }
-#endif
diff --git a/libs/core/execution_base/include/hpx/execution_base/this_thread.hpp b/libs/core/execution_base/include/hpx/execution_base/this_thread.hpp
index 61c8034b9060..a62b8cca4da2 100644
--- a/libs/core/execution_base/include/hpx/execution_base/this_thread.hpp
+++ b/libs/core/execution_base/include/hpx/execution_base/this_thread.hpp
@@ -83,7 +83,6 @@ namespace hpx::execution_base {
     }    // namespace this_thread
 }    // namespace hpx::execution_base
 
-#if defined(HPX_HAVE_STDEXEC)
 #include <hpx/execution_base/stdexec_forward.hpp>
 namespace hpx::this_thread::experimental {
     using namespace std::this_thread;
@@ -92,57 +91,6 @@ namespace hpx::this_thread::experimental {
 
     // this_thread::sync_wait is loaded in the sync_wait.hpp file.
 }    // namespace hpx::this_thread::experimental
-#else
-namespace hpx::this_thread::experimental {
-
-    // [exec.sched_queries.execute_may_block_caller]
-    //
-    // 1. `this_thread::execute_may_block_caller` is used to ask a scheduler s
-    // whether a call `execution::execute(s, f)` with any invocable f may block
-    // the thread where such a call occurs.
-    //
-    // 2. The name `this_thread::execute_may_block_caller` denotes a
-    // customization point object. For some subexpression s, let S be
-    // decltype((s)). If S does not satisfy `execution::scheduler`,
-    // `this_thread::execute_may_block_caller` is ill-formed. Otherwise,
-    // `this_thread::execute_may_block_caller(s)` is expression equivalent to:
-    //
-    //      1. `tag_invoke(this_thread::execute_may_block_caller, as_const(s))`,
-    //          if this expression is well formed.
-    //
-    //          -- Mandates: The tag_invoke expression above is not
-    //                       potentially throwing and its type is bool.
-    //
-    //      2. Otherwise, true.
-    //
-    // 3. If `this_thread::execute_may_block_caller(s)` for some scheduler s
-    // returns false, no execution::execute(s, f) call with some invocable f
-    // shall block the calling thread.
-    namespace detail {
-
-        // apply this meta function to all tag_invoke variations
-        struct is_scheduler
-        {
-            template <typename EnableTag, typename... T>
-            using apply = hpx::execution::experimental::is_scheduler<T...>;
-        };
-    }    // namespace detail
-
-    HPX_HOST_DEVICE_INLINE_CONSTEXPR_VARIABLE struct execute_may_block_caller_t
-        final
-      : hpx::functional::detail::tag_fallback_noexcept<
-            execute_may_block_caller_t, detail::is_scheduler>
-    {
-    private:
-        template <typename T>
-        friend constexpr HPX_FORCEINLINE bool tag_fallback_invoke(
-            execute_may_block_caller_t, T const&) noexcept
-        {
-            return true;
-        }
-    } execute_may_block_caller{};
-}    // namespace hpx::this_thread::experimental
-#endif
 
 namespace hpx::util {
 
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 a70163df73d0..b8e9560e14cd 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
@@ -35,7 +35,6 @@ namespace hpx::execution::experimental {
             meta::value<meta::one_of<T, void, bool>> ||
             is_instance_of<T, hpx::coroutine_handle>;
 
-#if defined(HPX_HAVE_STDEXEC)
         // In P2300R7+ await ready also needs to be contextually convertible to bool.
         template <typename, typename = void>
         inline constexpr bool has_await_ready_contextually_convertible_to_bool =
@@ -45,7 +44,6 @@ namespace hpx::execution::experimental {
         inline constexpr bool has_await_ready_contextually_convertible_to_bool<
             T, std::void_t<decltype(std::declval<T>().await_ready() ? 0 : 1)>> =
             true;
-#endif
 
         template <typename, typename = void>
         inline constexpr bool has_await_ready = false;
@@ -86,13 +84,11 @@ namespace hpx::execution::experimental {
         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;
-#if defined(HPX_HAVE_STDEXEC)
         // In P2300R8 "T is bool" is a sufficient condition for T to be an
         // await suspend result type.
         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;
-#endif
 
     }    // namespace detail
 
@@ -113,11 +109,7 @@ namespace hpx::execution::experimental {
     template <typename Awaiter, typename Promise = void>
     struct is_awaiter
       : std::integral_constant<bool,
-#if defined(HPX_HAVE_STDEXEC)
             detail::has_await_ready_contextually_convertible_to_bool<Awaiter> &&
-#else
-            detail::has_await_ready<Awaiter> &&
-#endif
                 detail::has_await_resume<Awaiter> &&
                 detail::is_with_await_suspend_v<Awaiter, Promise>>
     {
diff --git a/libs/core/execution_base/tests/include/algorithm_test_utils.hpp b/libs/core/execution_base/tests/include/algorithm_test_utils.hpp
index 7c9b896fe5c6..bd6ef7e22a1d 100644
--- a/libs/core/execution_base/tests/include/algorithm_test_utils.hpp
+++ b/libs/core/execution_base/tests/include/algorithm_test_utils.hpp
@@ -21,7 +21,6 @@
 
 #pragma once
 
-#if defined(HPX_HAVE_STDEXEC)
 template <typename Scheduler>
 struct env_with_scheduler
 {
@@ -33,7 +32,6 @@ struct env_with_scheduler
         return {};
     }
 };
-#endif
 
 // Check that the value_types of a sender matches the expected type
 template <typename ExpectedValType,
@@ -78,16 +76,10 @@ template <bool Expected, typename Env = hpx::execution::experimental::empty_env,
     typename Sender>
 inline void check_sends_stopped(Sender&&)
 {
-#if defined(HPX_HAVE_STDEXEC)
     // See check_value_types
     using UnderlyingSender = std::remove_reference_t<Sender>;
     constexpr bool sends_stopped =
         hpx::execution::experimental::sends_stopped<UnderlyingSender, Env>;
-#else
-    constexpr bool sends_stopped =
-        hpx::execution::experimental::completion_signatures_of_t<Sender,
-            Env>::sends_stopped;
-#endif
     static_assert(sends_stopped == Expected);
 }
 
@@ -129,9 +121,7 @@ struct void_sender
 template <typename... Ts>
 struct error_sender
 {
-#if defined(HPX_HAVE_STDEXEC)
     using sender_concept = hpx::execution::experimental::sender_t;
-#endif
 
     template <typename R>
     struct operation_state
@@ -237,13 +227,7 @@ struct callback_receiver
     std::decay_t<F> f;
     std::atomic<bool>& set_value_called;
 
-#if defined(HPX_HAVE_STDEXEC)
     using is_receiver = void;
-#else
-    struct is_receiver
-    {
-    };
-#endif
 
     template <typename E>
     friend void tag_invoke(hpx::execution::experimental::set_error_t,
@@ -278,9 +262,7 @@ struct error_callback_receiver
     std::atomic<bool>& set_error_called;
     bool expect_set_value = false;
 
-#if defined(HPX_HAVE_STDEXEC)
     using is_receiver = void;
-#endif
 
     template <typename E>
     friend void tag_invoke(hpx::execution::experimental::set_error_t,
@@ -306,9 +288,7 @@ struct error_callback_receiver
 
 struct expect_stopped_receiver
 {
-#if defined(HPX_HAVE_STDEXEC)
     using is_receiver = void;
-#endif
 
     std::atomic<bool>& set_stopped_called;
 
@@ -536,17 +516,6 @@ struct custom_sender
             hpx::execution::experimental::set_value_t(),
             hpx::execution::experimental::set_error_t(std::exception_ptr)>;
 
-#if !defined(HPX_HAVE_STDEXEC)
-    template <template <class...> class Tuple,
-        template <class...> class Variant>
-    using value_types = Variant<Tuple<>>;
-
-    template <template <class...> class Variant>
-    using error_types = Variant<std::exception_ptr>;
-
-    static constexpr bool sends_stopped = false;
-#endif
-
     template <typename R>
     struct operation_state
     {
@@ -587,17 +556,6 @@ struct custom_sender_multi_tuple
             hpx::execution::experimental::set_value_t(std::string),
             hpx::execution::experimental::set_error_t(std::exception_ptr)>;
 
-#if !defined(HPX_HAVE_STDEXEC)
-    template <template <class...> class Tuple,
-        template <class...> class Variant>
-    using value_types = Variant<Tuple<>>;
-
-    template <template <class...> class Variant>
-    using error_types = Variant<std::exception_ptr>;
-
-    static constexpr bool sends_stopped = false;
-#endif
-
     template <typename R>
     struct operation_state
     {
@@ -745,7 +703,6 @@ struct example_scheduler_template
     struct my_sender
     {
         using is_sender = void;
-#if defined(HPX_HAVE_STDEXEC)
         friend env_with_scheduler<std::conditional_t<std::is_void_v<Derived>,
             example_scheduler_template, Derived>>
         tag_invoke(
@@ -753,7 +710,6 @@ struct example_scheduler_template
         {
             return {};
         }
-#endif
 
         template <typename R>
         struct operation_state
@@ -810,7 +766,6 @@ struct example_scheduler_template
 };
 
 using example_scheduler = example_scheduler_template<void>;
-#if defined(HPX_HAVE_STDEXEC)
 struct scheduler2 : example_scheduler_template<scheduler2>
 {
     explicit scheduler2(example_scheduler s)
@@ -818,15 +773,6 @@ struct scheduler2 : example_scheduler_template<scheduler2>
     {
     }
 };
-#else
-struct scheduler2 : example_scheduler
-{
-    explicit scheduler2(example_scheduler s)
-      : example_scheduler(std::move(s))
-    {
-    }
-};
-#endif
 
 namespace tag_namespace {
 
@@ -870,9 +816,7 @@ namespace my_namespace {
     {
         struct my_sender
         {
-#if defined(HPX_HAVE_STDEXEC)
             using sender_concept = hpx::execution::experimental::sender_t;
-#endif
             template <typename R>
             struct operation_state
             {
@@ -891,22 +835,12 @@ namespace my_namespace {
             {
                 return operation_state<R>{std::forward<R>(r)};
             }
-#if defined(HPX_HAVE_STDEXEC)
             friend env_with_scheduler<my_scheduler_template> tag_invoke(
                 hpx::execution::experimental::get_env_t,
                 my_sender const&) noexcept
             {
                 return {};
             }
-#else
-            friend my_scheduler_template tag_invoke(
-                hpx::execution::experimental::get_completion_scheduler_t<
-                    hpx::execution::experimental::set_value_t>,
-                my_sender const&) noexcept
-            {
-                return {};
-            }
-#endif
 
             template <typename Env>
             friend auto tag_invoke(
diff --git a/libs/core/execution_base/tests/include/coroutine_task.hpp b/libs/core/execution_base/tests/include/coroutine_task.hpp
index b89989ffab1d..875d02ee2eba 100644
--- a/libs/core/execution_base/tests/include/coroutine_task.hpp
+++ b/libs/core/execution_base/tests/include/coroutine_task.hpp
@@ -311,11 +311,7 @@ class basic_task
         static hpx::coroutine_handle<> await_suspend(
             hpx::coroutine_handle<_promise> h) noexcept
         {
-#if defined(HPX_HAVE_STDEXEC)
             return h.promise().continuation().handle();
-#else
-            return h.promise().continuation();
-#endif
         }
         static void await_resume() noexcept {}
     };
diff --git a/libs/core/execution_base/tests/unit/any_sender.cpp b/libs/core/execution_base/tests/unit/any_sender.cpp
index 50c6b1ea7e19..486a1fc5fea6 100644
--- a/libs/core/execution_base/tests/unit/any_sender.cpp
+++ b/libs/core/execution_base/tests/unit/any_sender.cpp
@@ -47,11 +47,7 @@ class immovable
 template <typename... Ts>
 struct non_copyable_sender
 {
-#if defined(HPX_HAVE_STDEXEC)
     using sender_concept = ex::sender_t;
-#else
-    using is_sender = void;
-#endif
 
     hpx::tuple<std::decay_t<Ts>...> ts;
 
@@ -276,20 +272,12 @@ void test_any_sender(F&& f, Ts&&... ts)
     ex::any_sender<std::decay_t<Ts>...> as1{s};
 
     static_assert(ex::is_sender_v<decltype(as1)>);
-#if defined(HPX_HAVE_STDEXEC)
     static_assert(ex::is_sender_in_v<decltype(as1), ex::empty_env>);
-#else
-    static_assert(ex::is_sender_v<decltype(as1), ex::empty_env>);
-#endif
 
     auto as2 = as1;
 
     static_assert(ex::is_sender_v<decltype(as2)>);
-#if defined(HPX_HAVE_STDEXEC)
     static_assert(ex::is_sender_in_v<decltype(as2), ex::empty_env>);
-#else
-    static_assert(ex::is_sender_v<decltype(as2), ex::empty_env>);
-#endif
 
     check_value_types<hpx::variant<hpx::tuple<Ts...>>>(as2);
     check_error_types<hpx::variant<std::exception_ptr>>(as2);
@@ -379,11 +367,7 @@ void test_unique_any_sender(F&& f, Ts&&... ts)
     ex::unique_any_sender<std::decay_t<Ts>...> as1{std::move(s)};
 
     static_assert(ex::is_sender_v<decltype(as1)>);
-#if defined(HPX_HAVE_STDEXEC)
     static_assert(ex::is_sender_in_v<decltype(as1), ex::empty_env>);
-#else
-    static_assert(ex::is_sender_v<decltype(as1), ex::empty_env>);
-#endif
 
     check_value_types<hpx::variant<hpx::tuple<Ts...>>>(as1);
     check_error_types<hpx::variant<std::exception_ptr>>(as1);
@@ -392,11 +376,7 @@ void test_unique_any_sender(F&& f, Ts&&... ts)
     auto as2 = std::move(as1);
 
     static_assert(ex::is_sender_v<decltype(as2)>);
-#if defined(HPX_HAVE_STDEXEC)
     static_assert(ex::is_sender_in_v<decltype(as2), ex::empty_env>);
-#else
-    static_assert(ex::is_sender_v<decltype(as2), ex::empty_env>);
-#endif
 
     check_value_types<hpx::variant<hpx::tuple<Ts...>>>(as2);
     check_error_types<hpx::variant<std::exception_ptr>>(as2);
@@ -579,14 +559,10 @@ void test_globals()
 {
     global_unique_any_sender =
         std::move(global_unique_any_sender) | ex::ensure_started();
-#if defined(HPX_HAVE_STDEXEC)
     // P2300R8's ensure started returns non-copyable senders, so we need to split
     // to pass it to a global_any_sender.
     global_any_sender =
         std::move(global_any_sender) | ex::ensure_started() | ex::split();
-#else
-    global_any_sender = std::move(global_any_sender) | ex::ensure_started();
-#endif
 }
 
 int main()
diff --git a/libs/core/execution_base/tests/unit/basic_operation_state.cpp b/libs/core/execution_base/tests/unit/basic_operation_state.cpp
index 2cdcd6e990c1..31317a7e095b 100644
--- a/libs/core/execution_base/tests/unit/basic_operation_state.cpp
+++ b/libs/core/execution_base/tests/unit/basic_operation_state.cpp
@@ -94,22 +94,6 @@ namespace mylib {
 int main()
 {
     {
-#if !defined(HPX_HAVE_STDEXEC)
-        //        Normally the operation states should be invalid but the
-        //        STDEXEC implementation does not match the proposed standard
-        //        yet.
-        //
-        //        The standard requires:
-        //            { start(opstate) } noexcept;
-        //
-        //        The current implementation requires:
-        //            { start(opstate) };
-
-        static_assert(!ex::is_operation_state<mylib::state_2>::value,
-            "mylib::state_2 is not an operation state");
-        static_assert(!ex::is_operation_state<mylib::state_4>::value,
-            "mylib::state_4 is not an operation state");
-#endif
         static_assert(!ex::is_operation_state<mylib::state_1>::value,
             "mylib::state_1 is not an operation state");
         static_assert(ex::is_operation_state<mylib::state_3>::value,
@@ -156,24 +140,16 @@ int main()
             tag_invoke(ex::start, std::declval<mylib::state<false> const&>())));
 
         // none of the operations work via the start CPO if they'd throw
-#if defined(HPX_HAVE_STDEXEC)
         /*TODO: Check if the following way of invoking the start cpo leads to
          * the required checks by the execution.op_state concept check. That
          * check goes through the operator() of start_t but I am not sure if
          * we ever reach that point when calling the tag_invoke directly.
          */
-//        static_assert(!hpx::is_invocable_v<ex::start_t, mylib::state<false>>);
-//        static_assert(!hpx::is_invocable_v<ex::start_t, mylib::state<false>&&>);
-//        static_assert(!hpx::is_invocable_v<ex::start_t, mylib::state<false>&>);
-//        static_assert(
-//            !hpx::is_invocable_v<ex::start_t, mylib::state<false> const&>);
-#else
-        static_assert(!hpx::is_invocable_v<ex::start_t, mylib::state<false>>);
-        static_assert(!hpx::is_invocable_v<ex::start_t, mylib::state<false>&&>);
-        static_assert(!hpx::is_invocable_v<ex::start_t, mylib::state<false>&>);
-        static_assert(
-            !hpx::is_invocable_v<ex::start_t, mylib::state<false> const&>);
-#endif
+        //        static_assert(!hpx::is_invocable_v<ex::start_t, mylib::state<false>>);
+        //        static_assert(!hpx::is_invocable_v<ex::start_t, mylib::state<false>&&>);
+        //        static_assert(!hpx::is_invocable_v<ex::start_t, mylib::state<false>&>);
+        //        static_assert(
+        //            !hpx::is_invocable_v<ex::start_t, mylib::state<false> const&>);
     }
 
     {
diff --git a/libs/core/execution_base/tests/unit/basic_receiver.cpp b/libs/core/execution_base/tests/unit/basic_receiver.cpp
index f62c12fba8c7..6c0018b9da48 100644
--- a/libs/core/execution_base/tests/unit/basic_receiver.cpp
+++ b/libs/core/execution_base/tests/unit/basic_receiver.cpp
@@ -22,9 +22,7 @@ bool value_called = false;
 namespace mylib {
     struct receiver_1
     {
-#if defined(HPX_HAVE_STDEXEC)
         using is_receiver = void;
-#endif
         friend void tag_invoke(ex::set_stopped_t, receiver_1&&) noexcept
         {
             done_called = true;
@@ -36,10 +34,7 @@ namespace mylib {
             error_called = true;
         }
 
-        friend void tag_invoke(ex::set_value_t, receiver_1&&, int)
-#if defined(HPX_HAVE_STDEXEC)
-            noexcept
-#endif
+        friend void tag_invoke(ex::set_value_t, receiver_1&&, int) noexcept
         {
             value_called = true;
         }
@@ -47,9 +42,7 @@ namespace mylib {
 
     struct receiver_2
     {
-#if defined(HPX_HAVE_STDEXEC)
         using is_receiver = void;
-#endif
         friend void tag_invoke(ex::set_stopped_t, receiver_2&&) noexcept
         {
             done_called = true;
@@ -63,9 +56,7 @@ namespace mylib {
 
     struct receiver_3
     {
-#if defined(HPX_HAVE_STDEXEC)
         using is_receiver = void;
-#endif
         friend void tag_invoke(ex::set_stopped_t, receiver_3&&) noexcept
         {
             done_called = true;
@@ -142,9 +133,7 @@ namespace mylib {
 
     struct non_receiver_4
     {
-#if defined(HPX_HAVE_STDEXEC)
         using is_receiver = void;
-#endif
         friend void tag_invoke(ex::set_stopped_t, non_receiver_4&&) noexcept
         {
             done_called = true;
@@ -205,41 +194,10 @@ namespace mylib {
     };
 }    // namespace mylib
 
-#if defined(HPX_HAVE_STDEXEC)
-#endif
-
 int main()
 {
     using ex::is_receiver;
     using ex::is_receiver_of;
-#if !defined(HPX_HAVE_STDEXEC)
-    using ex::is_nothrow_receiver_of;
-
-    static_assert(!is_nothrow_receiver_of<mylib::receiver_1,
-                      ex::completion_signatures<ex::set_value_t(int),
-                          ex::set_error_t(std::exception_ptr),
-                          ex::set_stopped_t()>>::value,
-        "mylib::receiver_1 should not be a nothrow receiver of an int");
-
-    static_assert(!is_nothrow_receiver_of<mylib::receiver_2,
-                      ex::completion_signatures<ex::set_value_t(int),
-                          ex::set_error_t(std::exception_ptr),
-                          ex::set_stopped_t()>>::value,
-        "mylib::receiver_2 should not be a nothrow receiver of int");
-
-    static_assert(is_nothrow_receiver_of<mylib::receiver_3,
-                      ex::completion_signatures<ex::set_value_t(int),
-                          ex::set_error_t(std::exception_ptr),
-                          ex::set_stopped_t()>>::value,
-        "mylib::receiver_3 should be a nothrow receiver of an int");
-
-    // set_error is not mandatory
-    static_assert(!is_receiver<mylib::receiver_2>::value,
-        "mylib::receiver_2 should not be a receiver of std::exception_ptr");
-
-    static_assert(is_receiver<mylib::receiver_2, int>::value,
-        "mylib::receiver_2 should be a receiver");
-#endif
 
     static_assert(is_receiver<mylib::receiver_1>::value,
         "mylib::receiver_1 should be a receiver");
diff --git a/libs/core/execution_base/tests/unit/basic_schedule.cpp b/libs/core/execution_base/tests/unit/basic_schedule.cpp
index 9740ef494730..11be543ee33e 100644
--- a/libs/core/execution_base/tests/unit/basic_schedule.cpp
+++ b/libs/core/execution_base/tests/unit/basic_schedule.cpp
@@ -18,16 +18,13 @@ namespace ex = hpx::execution::experimental;
 static std::size_t friend_tag_invoke_schedule_calls = 0;
 static std::size_t tag_invoke_schedule_calls = 0;
 
-#if defined(HPX_HAVE_STDEXEC)
 struct dummy_scheduler
 {
 };
 
 template <typename Scheduler = dummy_scheduler>
-#endif
 struct example_sender_template
 {
-#if defined(HPX_HAVE_STDEXEC)
     using is_sender = void;
 
     using completion_signatures = ex::completion_signatures<ex::set_value_t(),
@@ -38,16 +35,6 @@ struct example_sender_template
     {
         return {};
     }
-#else
-    template <template <class...> class Tuple,
-        template <class...> class Variant>
-    using value_types = Variant<Tuple<>>;
-
-    template <template <class...> class Variant>
-    using error_types = Variant<std::exception_ptr>;
-
-    static constexpr bool sends_stopped = false;
-#endif
 
     struct operation_state
     {
@@ -60,11 +47,7 @@ struct example_sender_template
         return {};
     }
 };
-#if defined(HPX_HAVE_STDEXEC)
 using example_sender = example_sender_template<>;
-#else
-using example_sender = example_sender_template;
-#endif
 
 struct non_scheduler_1
 {
@@ -85,7 +68,6 @@ struct non_scheduler_3
 
 struct scheduler_1
 {
-#if defined(HPX_HAVE_STDEXEC)
     using sender_1 = example_sender_template<scheduler_1>;
 
     friend sender_1 tag_invoke(ex::schedule_t, scheduler_1)
@@ -93,13 +75,6 @@ struct scheduler_1
         ++friend_tag_invoke_schedule_calls;
         return {};
     }
-#else
-    friend example_sender tag_invoke(ex::schedule_t, scheduler_1)
-    {
-        ++friend_tag_invoke_schedule_calls;
-        return {};
-    }
-#endif
 
     constexpr bool operator==(scheduler_1 const&) const noexcept
     {
@@ -114,9 +89,7 @@ struct scheduler_1
 
 struct scheduler_2
 {
-#if defined(HPX_HAVE_STDEXEC)
     using sender_2 = example_sender_template<scheduler_2>;
-#endif
 
     constexpr bool operator==(scheduler_2 const&) const noexcept
     {
@@ -129,11 +102,7 @@ struct scheduler_2
     }
 };
 
-#if defined(HPX_HAVE_STDEXEC)
 example_sender_template<scheduler_2> tag_invoke(ex::schedule_t, scheduler_2)
-#else
-example_sender tag_invoke(ex::schedule_t, scheduler_2)
-#endif
 {
     ++tag_invoke_schedule_calls;
     return {};
@@ -145,12 +114,6 @@ int main()
 
     static_assert(
         !is_scheduler_v<non_scheduler_1>, "non_scheduler_1 is not a scheduler");
-#if !defined(HPX_HAVE_STDEXEC)
-    // In P2300 the result of a `schedule` member function is mandated to be a sender,
-    // so the evaluation of the following triggers a compilation error.
-    static_assert(
-        !is_scheduler_v<non_scheduler_2>, "non_scheduler_2 is not a scheduler");
-#endif
     static_assert(
         !is_scheduler_v<non_scheduler_3>, "non_scheduler_3 is not a scheduler");
     static_assert(is_scheduler_v<scheduler_1>, "scheduler_1 is a scheduler");
@@ -169,20 +132,10 @@ int main()
     HPX_TEST_EQ(tag_invoke_schedule_calls, std::size_t(1));
 
     static_assert(std::is_same_v<ex::schedule_result_t<scheduler_1>,
-#if defined(HPX_HAVE_STDEXEC)
-                      example_sender_template<scheduler_1>
-#else
-                      example_sender
-#endif
-                      >,
+                      example_sender_template<scheduler_1>>,
         "Result of scheduler is a example_sender");
     static_assert(std::is_same_v<ex::schedule_result_t<scheduler_2>,
-#if defined(HPX_HAVE_STDEXEC)
-                      example_sender_template<scheduler_2>
-#else
-                      example_sender
-#endif
-                      >,
+                      example_sender_template<scheduler_2>>,
         "Result of scheduler is a example_sender");
 
     return hpx::util::report_errors();
diff --git a/libs/core/execution_base/tests/unit/basic_sender.cpp b/libs/core/execution_base/tests/unit/basic_sender.cpp
index 1e2d1e3f4be3..253f4fffdbac 100644
--- a/libs/core/execution_base/tests/unit/basic_sender.cpp
+++ b/libs/core/execution_base/tests/unit/basic_sender.cpp
@@ -97,20 +97,14 @@ struct non_sender_7
 
 struct example_receiver
 {
-#if defined(HPX_HAVE_STDEXEC)
     using receiver_concept = ex::receiver_t;
-#else
-    using is_receiver = void;
-#endif
     friend void tag_invoke(
         ex::set_error_t, example_receiver&&, std::exception_ptr) noexcept
     {
     }
     friend void tag_invoke(ex::set_stopped_t, example_receiver&&) noexcept {}
-    friend void tag_invoke(ex::set_value_t, example_receiver&& r, int v)
-#if defined(HPX_HAVE_STDEXEC)
-        noexcept
-#endif
+    friend void tag_invoke(
+        ex::set_value_t, example_receiver&& r, int v) noexcept
     {
         r.i = v;
     }
@@ -121,44 +115,21 @@ struct example_receiver
 template <typename... T>
 struct receiver_2
 {
-#if defined(HPX_HAVE_STDEXEC)
     using receiver_concept = ex::receiver_t;
-#else
-    using is_receiver = void;
-#endif
     friend void tag_invoke(
         ex::set_error_t, receiver_2&&, std::exception_ptr) noexcept
     {
     }
     friend void tag_invoke(ex::set_stopped_t, receiver_2&&) noexcept {}
-    friend void tag_invoke(ex::set_value_t, receiver_2&&, T...)
-#if defined(HPX_HAVE_STDEXEC)
-        noexcept
-#endif
-    {
-    }
+    friend void tag_invoke(ex::set_value_t, receiver_2&&, T...) noexcept {}
 };
 
 struct sender_1
 {
     using is_sender = void;
-#if defined(HPX_HAVE_STDEXEC)
     using completion_signatures =
         ex::completion_signatures<ex::set_value_t(int),
             ex::set_error_t(std::exception_ptr)>;
-#else
-    struct completion_signatures
-    {
-        template <template <class...> class Tuple,
-            template <class...> class Variant>
-        using value_types = Variant<Tuple<int>>;
-
-        template <template <class...> class Variant>
-        using error_types = Variant<std::exception_ptr>;
-
-        static constexpr bool sends_stopped = false;
-    };
-#endif
 
     struct operation_state : immovable
     {
@@ -180,23 +151,9 @@ struct sender_1
 struct sender_2
 {
     using is_sender = void;
-#if defined(HPX_HAVE_STDEXEC)
     using completion_signatures =
         ex::completion_signatures<ex::set_value_t(int),
             ex::set_error_t(std::exception_ptr)>;
-#else
-    struct completion_signatures
-    {
-        template <template <class...> class Tuple,
-            template <class...> class Variant>
-        using value_types = Variant<Tuple<int>>;
-
-        template <template <class...> class Variant>
-        using error_types = Variant<std::exception_ptr>;
-
-        static constexpr bool sends_stopped = false;
-    };
-#endif
 
     struct operation_state : immovable
     {
@@ -244,25 +201,11 @@ template <bool val, typename T>
 struct sender_4
 {
     using is_sender = void;
-#if defined(HPX_HAVE_STDEXEC)
     using completion_signatures = std::conditional_t<val,
         ex::completion_signatures<ex::set_value_t(T),
             ex::set_error_t(std::exception_ptr), ex::set_stopped_t()>,
         ex::completion_signatures<ex::set_value_t(T),
             ex::set_error_t(std::exception_ptr)>>;
-#else
-    struct completion_signatures
-    {
-        template <template <class...> class Tuple,
-            template <class...> class Variant>
-        using value_types = Variant<Tuple<T>>;
-
-        template <template <class...> class Variant>
-        using error_types = Variant<std::exception_ptr>;
-
-        static constexpr bool sends_stopped = val;
-    };
-#endif
 };
 
 static std::size_t void_receiver_set_value_calls = 0;
@@ -274,10 +217,7 @@ struct void_receiver
     {
     }
     friend void tag_invoke(ex::set_stopped_t, void_receiver&&) noexcept {}
-    friend void tag_invoke(ex::set_value_t, void_receiver&&)
-#if defined(HPX_HAVE_STDEXEC)
-        noexcept
-#endif
+    friend void tag_invoke(ex::set_value_t, void_receiver&&) noexcept
     {
         ++void_receiver_set_value_calls;
     }
@@ -285,33 +225,7 @@ struct void_receiver
 
 int main()
 {
-#if defined(HPX_HAVE_STDEXEC)
     // different requirements
-#else
-    using ex::detail::has_sender_types_v;
-    static_assert(!has_sender_types_v<void>,
-        "void should not have completion_signatures");
-    static_assert(!has_sender_types_v<std::nullptr_t>,
-        "std::nullptr_t should not have completion_signatures");
-    static_assert(!has_sender_types_v<int>,
-        "non_sender_1 should not have completion_signatures");
-    static_assert(!has_sender_types_v<double>,
-        "non_sender_1 should not have completion_signatures");
-    static_assert(!has_sender_types_v<non_sender_1>,
-        "non_sender_1 should not have completion_signatures");
-    static_assert(!has_sender_types_v<non_sender_2>,
-        "non_sender_2 should not have completion_signatures");
-    static_assert(!has_sender_types_v<non_sender_3>,
-        "non_sender_3 should not have completion_signatures");
-    static_assert(!has_sender_types_v<non_sender_4>,
-        "non_sender_4 should not have completion_signatures");
-    static_assert(!has_sender_types_v<non_sender_5>,
-        "non_sender_5 should not have completion_signatures");
-    static_assert(!has_sender_types_v<non_sender_6>,
-        "non_sender_6 should not have completion_signatures");
-    static_assert(!has_sender_types_v<non_sender_7>,
-        "non_sender_7 should not have completion_signatures");
-#endif
 
     using ex::is_sender_to_v;
     using ex::is_sender_v;
@@ -334,14 +248,9 @@ int main()
     static_assert(is_sender_v<sender_4<true, int>>, "sender_4 is a sender");
     static_assert(is_sender_v<sender_4<false, int>>, "sender_4 is a sender");
 
-#if defined(HPX_HAVE_STDEXEC)
     // we need to be more specific now
     static_assert(ex::sender_to<sender_1, example_receiver&>,
         "sender_1 is a sender to example_receiver");
-#else
-    static_assert(ex::is_sender_to_v<sender_1, example_receiver>,
-        "sender_1 is a sender to example_receiver");
-#endif
     static_assert(!is_sender_to_v<sender_1, non_sender_1>,
         "sender_1 is not a sender to non_sender_1");
     static_assert(!is_sender_to_v<sender_1, sender_1>,
@@ -368,7 +277,6 @@ int main()
                           ex::env_of_t<receiver_2<std::string>>>>,
         "receiver_2<int>  does not support completion signatures of "
         "sender_4<true,std::string>");
-#if defined(HPX_HAVE_STDEXEC)
     /*TODO: CHECK THAT THE RECEIVER HAVING MORE COMPLETIONS THAT THE SENDER
      * IS ACTUALLY AN ERROR IN THE OLD VERSION*/
 
@@ -391,85 +299,9 @@ int main()
                           ex::env_of_t<example_receiver>>>,
         "example_receiver does not support completion signatures of sender_1");
 
-#else
-    static_assert(!ex::is_receiver_of_v<receiver_2<int>,
-                      ex::completion_signatures_of_t<sender_4<false, int>,
-                          ex::env_of_t<receiver_2<int>>>>,
-        "receiver_2<int>  does not support completion signatures of "
-        "sender_4<false,int>");
-
-    static_assert(!ex::is_receiver_of_v<example_receiver,
-                      ex::completion_signatures_of_t<sender_4<false, int>,
-                          ex::env_of_t<example_receiver>>>,
-        "example_receiver does not support completion signatures of "
-        "sender_4<false,int>");
-
-    static_assert(!ex::is_receiver_of_v<example_receiver,
-                      ex::completion_signatures_of_t<sender_1,
-                          ex::env_of_t<example_receiver>>>,
-        "example_receiver does not support completion signatures of sender_1");
-#endif
-
-#if defined(HPX_HAVE_STDEXEC)
     // Now sender_of checks for the existence of function signatures in the
     // completion signatures of the sender, not for the available set_value(...)
     // specializations.
-#else
-    static_assert(
-        ex::is_sender_of_v<sender_1, ex::env_of_t<example_receiver>, int>,
-        "sender_1 is a sender of env_of_t<example_receiver> and value types "
-        "int");
-    static_assert(
-        ex::is_sender_of_v<sender_2, ex::env_of_t<example_receiver>, int>,
-        "sender_2 is a sender of env_of_t<example_receiver> and value types "
-        "int");
-    static_assert(
-        ex::is_sender_of_v<sender_3, ex::env_of_t<example_receiver>, int>,
-        "sender_3 is a sender of env_of_t<example_receiver> and value types "
-        "int");
-    static_assert(ex::is_sender_of_v<sender_4<true, int>,
-                      ex::env_of_t<example_receiver>, int>,
-        "sender_4<true,int> is a sender of env_of_t<example_receiver> and "
-        "value types "
-        "int");
-    static_assert(ex::is_sender_of_v<sender_4<false, int>,
-                      ex::env_of_t<example_receiver>, int>,
-        "sender_4<false,int> is a sender of env_of_t<example_receiver> and "
-        "value types "
-        "int");
-    static_assert(
-        ex::is_sender_of_v<sender_1, ex::env_of_t<receiver_2<int>>, int>,
-        "sender_1 is a sender of env_of_t<receiver_2<int>> and value types "
-        "int");
-    static_assert(
-        ex::is_sender_of_v<sender_2, ex::env_of_t<receiver_2<int>>, int>,
-        "sender_2 is a sender of env_of_t<receiver_2<int>> and value types "
-        "int");
-    static_assert(
-        ex::is_sender_of_v<sender_3, ex::env_of_t<receiver_2<int>>, int>,
-        "sender_3 is a sender of env_of_t<receiver_2<int>> and value types "
-        "int");
-    static_assert(ex::is_sender_of_v<sender_4<true, std::string>,
-                      ex::env_of_t<receiver_2<std::string>>, std::string>,
-        "sender_4<true,std::string> is a sender of "
-        "env_of_t<receiver_2<std::string>> and value types std::string");
-    static_assert(ex::is_sender_of_v<sender_4<true, std::string>,
-                      ex::env_of_t<receiver_2<std::string>>, std::string>,
-        "sender_4<false,std::string> is a sender of "
-        "env_of_t<receiver_2<std::string>> and value types std::string");
-    static_assert(!ex::is_sender_of_v<sender_1,
-                      ex::env_of_t<receiver_2<std::string>>, std::string>,
-        "sender_1 is not a sender of env_of_t<receiver_2<std::string>> and "
-        "value types std::string");
-    static_assert(!ex::is_sender_of_v<sender_2,
-                      ex::env_of_t<receiver_2<std::string>>, std::string>,
-        "sender_2 is not a sender of env_of_t<receiver_2<std::string>> and "
-        "value types std::string");
-    static_assert(!ex::is_sender_of_v<sender_3,
-                      ex::env_of_t<receiver_2<std::string>>, std::string>,
-        "sender_3 is not a sender of env_of_t<receiver_2<std::string>> and "
-        "value types std::string");
-#endif
 
     {
         example_receiver r1;
diff --git a/libs/core/execution_base/tests/unit/completion_signatures.cpp b/libs/core/execution_base/tests/unit/completion_signatures.cpp
index 1c76d464f8bd..a05357ff9e40 100644
--- a/libs/core/execution_base/tests/unit/completion_signatures.cpp
+++ b/libs/core/execution_base/tests/unit/completion_signatures.cpp
@@ -67,7 +67,6 @@ auto signature_all(
 }
 // clang-format on
 
-#if defined(HPX_HAVE_STDEXEC)
 template <typename CompletionSignatures>
 struct test_helper
 {
@@ -86,7 +85,6 @@ struct test_helper
     static inline constexpr bool sends_stopped =
         ex::sends_stopped<my_sender, ex::empty_env>;
 };
-#endif
 
 ///////////////////////////////////////////////////////////////////////////////
 template <typename... Values>
@@ -94,20 +92,11 @@ void test_values(Values...)
 {
     using completion_signatures = decltype(signature_values(Values()...));
 
-#if defined(HPX_HAVE_STDEXEC)
     using value_types =
         typename test_helper<completion_signatures>::value_types;
     using error_types =
         typename test_helper<completion_signatures>::error_types;
     static_assert(!test_helper<completion_signatures>::sends_stopped);
-#else
-    using value_types =
-        typename completion_signatures::template value_types<hpx::tuple,
-            hpx::variant>;
-    using error_types =
-        typename completion_signatures::template error_types<hpx::variant>;
-    static_assert(!completion_signatures::sends_stopped);
-#endif
 
     static_assert(
         std::is_same_v<value_types, hpx::variant<hpx::tuple<Values...>>>);
@@ -119,20 +108,11 @@ void test_error(Error)
 {
     using completion_signatures = decltype(signature_error(Error()));
 
-#if defined(HPX_HAVE_STDEXEC)
     using value_types =
         typename test_helper<completion_signatures>::value_types;
     using error_types =
         typename test_helper<completion_signatures>::error_types;
     static_assert(!test_helper<completion_signatures>::sends_stopped);
-#else
-    using value_types =
-        typename completion_signatures::template value_types<hpx::tuple,
-            hpx::variant>;
-    using error_types =
-        typename completion_signatures::template error_types<hpx::variant>;
-    static_assert(!completion_signatures::sends_stopped);
-#endif
 
     static_assert(std::is_same_v<value_types, hpx::variant<>>);
     static_assert(std::is_same_v<error_types, hpx::variant<Error>>);
@@ -142,20 +122,11 @@ void test_stopped()
 {
     using completion_signatures = decltype(signature_stopped());
 
-#if defined(HPX_HAVE_STDEXEC)
     using value_types =
         typename test_helper<completion_signatures>::value_types;
     using error_types =
         typename test_helper<completion_signatures>::error_types;
     static_assert(test_helper<completion_signatures>::sends_stopped);
-#else
-    using value_types =
-        typename completion_signatures::template value_types<hpx::tuple,
-            hpx::variant>;
-    using error_types =
-        typename completion_signatures::template error_types<hpx::variant>;
-    static_assert(completion_signatures::sends_stopped);
-#endif
 
     static_assert(std::is_same_v<value_types, hpx::variant<>>);
     static_assert(std::is_same_v<error_types, hpx::variant<>>);
@@ -167,20 +138,11 @@ void test_error_values(Error, Values...)
     using completion_signatures =
         decltype(signature_error_values(Error(), Values()...));
 
-#if defined(HPX_HAVE_STDEXEC)
     using value_types =
         typename test_helper<completion_signatures>::value_types;
     using error_types =
         typename test_helper<completion_signatures>::error_types;
     static_assert(!test_helper<completion_signatures>::sends_stopped);
-#else
-    using value_types =
-        typename completion_signatures::template value_types<hpx::tuple,
-            hpx::variant>;
-    using error_types =
-        typename completion_signatures::template error_types<hpx::variant>;
-    static_assert(!completion_signatures::sends_stopped);
-#endif
 
     static_assert(
         std::is_same_v<value_types, hpx::variant<hpx::tuple<Values...>>>);
@@ -193,20 +155,11 @@ void test_values_stopped(Values...)
     using completion_signatures =
         decltype(signature_values_stopped(Values()...));
 
-#if defined(HPX_HAVE_STDEXEC)
     using value_types =
         typename test_helper<completion_signatures>::value_types;
     using error_types =
         typename test_helper<completion_signatures>::error_types;
     static_assert(test_helper<completion_signatures>::sends_stopped);
-#else
-    using value_types =
-        typename completion_signatures::template value_types<hpx::tuple,
-            hpx::variant>;
-    using error_types =
-        typename completion_signatures::template error_types<hpx::variant>;
-    static_assert(completion_signatures::sends_stopped);
-#endif
 
     static_assert(
         std::is_same_v<value_types, hpx::variant<hpx::tuple<Values...>>>);
@@ -218,20 +171,11 @@ void test_error_stopped(Error)
 {
     using completion_signatures = decltype(signature_error_stopped(Error()));
 
-#if defined(HPX_HAVE_STDEXEC)
     using value_types =
         typename test_helper<completion_signatures>::value_types;
     using error_types =
         typename test_helper<completion_signatures>::error_types;
     static_assert(test_helper<completion_signatures>::sends_stopped);
-#else
-    using value_types =
-        typename completion_signatures::template value_types<hpx::tuple,
-            hpx::variant>;
-    using error_types =
-        typename completion_signatures::template error_types<hpx::variant>;
-    static_assert(completion_signatures::sends_stopped);
-#endif
 
     static_assert(std::is_same_v<value_types, hpx::variant<>>);
     static_assert(std::is_same_v<error_types, hpx::variant<Error>>);
@@ -242,20 +186,11 @@ void test_all(Error, Values...)
 {
     using completion_signatures = decltype(signature_all(Error(), Values()...));
 
-#if defined(HPX_HAVE_STDEXEC)
     using value_types =
         typename test_helper<completion_signatures>::value_types;
     using error_types =
         typename test_helper<completion_signatures>::error_types;
     static_assert(test_helper<completion_signatures>::sends_stopped);
-#else
-    using value_types =
-        typename completion_signatures::template value_types<hpx::tuple,
-            hpx::variant>;
-    using error_types =
-        typename completion_signatures::template error_types<hpx::variant>;
-    static_assert(completion_signatures::sends_stopped);
-#endif
 
     static_assert(
         std::is_same_v<value_types, hpx::variant<hpx::tuple<Values...>>>);
@@ -284,9 +219,7 @@ using possibly_empty_variant_t =
 template <typename Signatures>
 struct sender_1
 {
-#if defined(HPX_HAVE_STDEXEC)
     using is_sender = void;
-#endif
     using completion_signatures = Signatures;
 };
 
@@ -299,47 +232,22 @@ void test_sender1(Signatures)
     static_assert(hpx::meta::value<
         ex::detail::has_completion_signatures<sender_1<Signatures>>>);
 
-#if defined(HPX_HAVE_STDEXEC)
     static_assert(std::is_same_v<decltype(ex::get_completion_signatures(
                                      s, ex::empty_env{})),
         Signatures>);
-#else
-    static_assert(
-        std::is_same_v<decltype(ex::get_completion_signatures(s)), Signatures>);
-#endif
 
     static_assert(
         std::is_same_v<ex::completion_signatures_of_t<sender_1<Signatures>>,
             Signatures>);
-
-#if !defined(HPX_HAVE_STDEXEC)
-    using value_types_of = ex::value_types_of_t<sender_1<Signatures>>;
-    using value_types = possibly_empty_variant_t<
-        typename Signatures::template value_types<hpx::tuple, hpx::variant>>;
-
-    static_assert(std::is_same_v<value_types_of, value_types>);
-
-    using error_types_of = ex::error_types_of_t<sender_1<Signatures>>;
-    using error_types = possibly_empty_variant_t<
-        typename Signatures::template error_types<hpx::variant>>;
-
-    static_assert(std::is_same_v<error_types_of, error_types>);
-#endif
 }
 
 template <typename Signatures>
 struct sender_2
 {
-#if defined(HPX_HAVE_STDEXEC)
     using is_sender = void;
-#endif
 };
 
-#if defined(HPX_HAVE_STDEXEC)
 template <typename Signatures, typename Env = ex::empty_env>
-#else
-template <typename Signatures, typename Env = ex::no_env>
-#endif
 constexpr auto tag_invoke(ex::get_completion_signatures_t,
     sender_2<Signatures> const&, Env = Env{}) noexcept -> Signatures
 {
@@ -356,44 +264,18 @@ void test_sender2(Signatures)
         static_assert(
             hpx::functional::is_tag_invocable_v<ex::get_completion_signatures_t,
                 sender_2<Signatures>>);
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(std::is_same_v<decltype(ex::get_completion_signatures(
                                          s1, ex::empty_env{})),
             Signatures>);
-#else
-        static_assert(
-            std::is_same_v<decltype(ex::get_completion_signatures(s1)),
-                Signatures>);
-#endif
 
         static_assert(
             std::is_same_v<ex::completion_signatures_of_t<sender_2<Signatures>>,
                 Signatures>);
-
-#if !defined(HPX_HAVE_STDEXEC)
-        using value_types_of = ex::value_types_of_t<sender_2<Signatures>>;
-        using value_types =
-            possibly_empty_variant_t<typename Signatures::template value_types<
-                hpx::tuple, hpx::variant>>;
-
-        static_assert(std::is_same_v<value_types_of, value_types>);
-
-        using error_types_of = ex::error_types_of_t<sender_2<Signatures>>;
-        using error_types = possibly_empty_variant_t<
-            typename Signatures::template error_types<hpx::variant>>;
-
-        static_assert(std::is_same_v<error_types_of, error_types>);
-#endif
     }
     {
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(ex::is_sender_in_v<sender_2<Signatures>, ex::empty_env>);
-#else
-        static_assert(ex::is_sender_v<sender_2<Signatures>, ex::no_env>);
-#endif
 
         sender_2<Signatures> s2;
-#if defined(HPX_HAVE_STDEXEC)
         static_assert(
             hpx::functional::is_tag_invocable_v<ex::get_completion_signatures_t,
                 sender_2<Signatures>, ex::empty_env>);
@@ -403,50 +285,9 @@ void test_sender2(Signatures)
         static_assert(std::is_same_v<
             ex::completion_signatures_of_t<sender_2<Signatures>, ex::empty_env>,
             Signatures>);
-#else
-        static_assert(
-            hpx::functional::is_tag_invocable_v<ex::get_completion_signatures_t,
-                sender_2<Signatures>, ex::no_env>);
-        static_assert(
-            std::is_same_v<decltype(ex::get_completion_signatures(s2)),
-                Signatures>);
-        static_assert(std::is_same_v<
-            ex::completion_signatures_of_t<sender_2<Signatures>, ex::no_env>,
-            Signatures>);
-#endif
-
-#if !defined(HPX_HAVE_STDEXEC)
-        using value_types_of =
-            ex::value_types_of_t<sender_2<Signatures>, ex::no_env>;
-        using value_types =
-            possibly_empty_variant_t<typename Signatures::template value_types<
-                hpx::tuple, hpx::variant>>;
-
-        static_assert(std::is_same_v<value_types_of, value_types>);
-
-        using error_types_of =
-            ex::error_types_of_t<sender_2<Signatures>, ex::no_env>;
-        using error_types = possibly_empty_variant_t<
-            typename Signatures::template error_types<hpx::variant>>;
-
-        static_assert(std::is_same_v<error_types_of, error_types>);
-#endif
     }
 }
 
-#if !defined(HPX_HAVE_STDEXEC)
-struct sender_3
-{
-};
-
-void test_sender3()
-{
-    sender_3 s;
-    static_assert(std::is_same_v<decltype(ex::get_completion_signatures(s)),
-        ex::detail::no_completion_signatures>);
-}
-#endif
-
 #if defined(HPX_HAVE_CXX20_COROUTINES)
 
 template <typename Awaiter>
@@ -476,14 +317,10 @@ struct promise
 
 struct awaiter
 {
-#if defined(HPX_HAVE_STDEXEC)
     bool await_ready()
     {
         return true;
     }
-#else
-    void await_ready() {}
-#endif
     bool await_suspend(hpx::coroutine_handle<>)
     {
         return false;
@@ -519,14 +356,9 @@ void test_awaitable_sender1(Signatures&&, Awaiter&&)
     awaitable_sender_1<Awaiter> s;
     static_assert(!hpx::meta::value<ex::detail::has_completion_signatures<
                       awaitable_sender_1<Awaiter>>>);
-#if defined(HPX_HAVE_STDEXEC)
     static_assert(std::is_same_v<decltype(ex::get_completion_signatures(
                                      s, ex::empty_env{})),
         Signatures>);
-#else
-    static_assert(
-        std::is_same_v<decltype(ex::get_completion_signatures(s)), Signatures>);
-#endif
     static_assert(std::is_same_v<
         ex::completion_signatures_of_t<awaitable_sender_1<Awaiter>>,
         Signatures>);
@@ -534,7 +366,6 @@ void test_awaitable_sender1(Signatures&&, Awaiter&&)
     using value_types_of = ex::value_types_of_t<awaitable_sender_1<Awaiter>>;
     using error_types_of = ex::error_types_of_t<awaitable_sender_1<Awaiter>>;
 
-#if defined(HPX_HAVE_STDEXEC)
     struct sender_with_given_signatures
     {
         using sender_concept = ex::sender_t;
@@ -542,12 +373,6 @@ void test_awaitable_sender1(Signatures&&, Awaiter&&)
     };
     using value_types = ex::value_types_of_t<sender_with_given_signatures>;
     using error_types = ex::error_types_of_t<sender_with_given_signatures>;
-#else
-    using value_types = possibly_empty_variant_t<
-        typename Signatures::template value_types<hpx::tuple, hpx::variant>>;
-    using error_types = possibly_empty_variant_t<
-        typename Signatures::template error_types<hpx::variant>>;
-#endif
 
     static_assert(std::is_same_v<value_types_of, value_types>);
     static_assert(std::is_same_v<error_types_of, error_types>);
@@ -694,14 +519,9 @@ int main()
         test_sender2(signature_all(std::exception_ptr(), int(), double()));
     }
 
-#if !defined(HPX_HAVE_STDEXEC)
-    test_sender3();
-#endif
-
 #if defined(HPX_HAVE_CXX20_COROUTINES)
 
     {
-#if defined(HPX_HAVE_STDEXEC)
         test_awaitable_sender1(
             ex::completion_signatures<ex::set_value_t(),
                 ex::set_error_t(std::exception_ptr), ex::set_stopped_t()>{},
@@ -711,13 +531,6 @@ int main()
             ex::completion_signatures<ex::set_value_t(bool),
                 ex::set_error_t(std::exception_ptr), ex::set_stopped_t()>{},
             awaiter{});
-#else
-        test_awaitable_sender1(signature_error_values(std::exception_ptr()),
-            hpx::suspend_always{});
-
-        test_awaitable_sender1(
-            signature_error_values(std::exception_ptr(), bool()), awaiter{});
-#endif
 
         // TODO: handle for awaitables that do not have co_await free/member
         // operator
diff --git a/libs/core/execution_base/tests/unit/coroutine_traits.cpp b/libs/core/execution_base/tests/unit/coroutine_traits.cpp
index 25ca06d71423..54be78b12ca4 100644
--- a/libs/core/execution_base/tests/unit/coroutine_traits.cpp
+++ b/libs/core/execution_base/tests/unit/coroutine_traits.cpp
@@ -22,42 +22,30 @@ struct awaiter_1
 
 struct awaiter_2
 {
-#if defined(HPX_HAVE_STDEXEC)
     bool await_ready()
     {
         return false;
     }
-#else
-    void await_ready() {}
-#endif
     void await_suspend(hpx::coroutine_handle<>) {}
     void await_resume() {}
 };
 
 struct awaiter_3
 {
-#if defined(HPX_HAVE_STDEXEC)
     bool await_ready()
     {
         return false;
     }
-#else
-    void await_ready() {}
-#endif
     void await_suspend(hpx::coroutine_handle<>) {}
     void await_resume() {}
 };
 
 struct awaiter_4
 {
-#if defined(HPX_HAVE_STDEXEC)
     bool await_ready()
     {
         return false;
     }
-#else
-    void await_ready() {}
-#endif
     bool await_suspend(hpx::coroutine_handle<>)
     {
         return false;
@@ -67,14 +55,10 @@ struct awaiter_4
 
 struct awaiter_5
 {
-#if defined(HPX_HAVE_STDEXEC)
     bool await_ready()
     {
         return false;
     }
-#else
-    void await_ready() {}
-#endif
     bool await_suspend(hpx::coroutine_handle<>)
     {
         return false;
diff --git a/libs/core/execution_base/tests/unit/coroutine_utils.cpp b/libs/core/execution_base/tests/unit/coroutine_utils.cpp
index 56df51d7597f..46c5a9c721b7 100644
--- a/libs/core/execution_base/tests/unit/coroutine_utils.cpp
+++ b/libs/core/execution_base/tests/unit/coroutine_utils.cpp
@@ -34,11 +34,6 @@ struct non_awaitable_sender
     using completion_signatures = Signatures;
 };
 
-#if !defined(HPX_HAVE_STDEXEC)
-using dependent = hpx::execution::experimental::dependent_completion_signatures<
-    hpx::execution::experimental::no_env>;
-#endif
-
 template <typename Awaiter>
 struct promise
 {
@@ -89,26 +84,12 @@ struct awaitable_sender_1
     }
 };
 
-#if !defined(HPX_HAVE_STDEXEC)
-struct awaitable_sender_2
-{
-    using promise_type = promise<hpx::suspend_always>;
-
-private:
-    friend dependent operator co_await(awaitable_sender_2);
-};
-#endif
-
 struct awaitable_sender_3
 {
     using promise_type = promise<awaiter>;
 
 private:
-#if defined(HPX_HAVE_STDEXEC)
     friend awaiter operator co_await(awaitable_sender_3);
-#else
-    friend dependent operator co_await(awaitable_sender_3);
-#endif
 };
 
 struct awaitable_sender_4
@@ -122,15 +103,6 @@ struct awaitable_sender_4
     {
         return {};
     }
-#if !defined(HPX_HAVE_STDEXEC)
-    friend dependent tag_invoke(hpx::execution::experimental::as_awaitable_t,
-        awaitable_sender_4,
-        hpx::execution::experimental::detail::env_promise<
-            hpx::execution::experimental::no_env>&)
-    {
-        return {};
-    }
-#endif
 };
 
 struct awaitable_sender_5
@@ -242,10 +214,6 @@ int main()
 
         static_assert(!ex::detail::has_free_operator_co_await_v<
                       awaitable_sender_1<awaiter>>);
-#if !defined(HPX_HAVE_STDEXEC)
-        static_assert(
-            ex::detail::has_free_operator_co_await_v<awaitable_sender_2>);
-#endif
         static_assert(
             ex::detail::has_free_operator_co_await_v<awaitable_sender_3>);
         static_assert(
@@ -255,10 +223,6 @@ int main()
 
         static_assert(ex::detail::has_member_operator_co_await_v<
             awaitable_sender_1<awaiter>>);
-#if !defined(HPX_HAVE_STDEXEC)
-        static_assert(
-            !ex::detail::has_member_operator_co_await_v<awaitable_sender_2>);
-#endif
         static_assert(
             !ex::detail::has_member_operator_co_await_v<awaitable_sender_3>);
         static_assert(
@@ -267,16 +231,9 @@ int main()
             !ex::detail::has_member_operator_co_await_v<awaitable_sender_5>);
 
         static_assert(ex::is_awaitable_v<awaitable_sender_1<awaiter>>);
-#if !defined(HPX_HAVE_STDEXEC)
-        static_assert(ex::is_awaitable_v<awaitable_sender_2>);
-#endif
         static_assert(ex::is_awaitable_v<awaitable_sender_3>);
         static_assert(!ex::is_awaitable_v<awaitable_sender_4>);
         static_assert(!ex::is_awaitable_v<awaitable_sender_5>);
-#if !defined(HPX_HAVE_STDEXEC)
-        static_assert(ex::is_awaitable_v<awaitable_sender_2,
-            ::promise<hpx::suspend_always>>);
-#endif
         static_assert(
             ex::is_awaitable_v<awaitable_sender_3, ::promise<awaiter>>);
         static_assert(
@@ -287,37 +244,6 @@ int main()
             hpx::functional::tag_invoke_result_t<ex::as_awaitable_t,
                 awaitable_sender_4, ::promise<awaiter>&>,
             awaiter>);
-#if !defined(HPX_HAVE_STDEXEC)
-        // P2300 does not have dependent completion signatures.
-        static_assert(std::is_same_v<
-            hpx::functional::tag_invoke_result_t<ex::as_awaitable_t,
-                awaitable_sender_4, ex::detail::env_promise<ex::no_env>&>,
-            ex::detail::dependent_completion_signatures<ex::no_env>>);
-        static_assert(std::is_same_v<
-            decltype(ex::get_awaiter(std::declval<awaitable_sender_4>(),
-                static_cast<ex::detail::env_promise<ex::no_env>*>(nullptr))),
-            ex::detail::dependent_completion_signatures<ex::no_env>>);
-        // clang-format off
-        static_assert(ex::is_awaiter_v<decltype(
-                ex::get_awaiter(std::declval<awaitable_sender_4>(),
-                    static_cast<ex::detail::env_promise<ex::no_env>*>(nullptr)))>);
-        static_assert(ex::detail::has_await_suspend_v<decltype(
-                ex::get_awaiter(std::declval<awaitable_sender_4>(),
-                    static_cast<ex::detail::env_promise<ex::no_env>*>(nullptr)))>);
-        static_assert(ex::detail::is_with_await_suspend_v<
-            decltype(ex::get_awaiter(std::declval<awaitable_sender_4>(),
-                static_cast<ex::detail::env_promise<ex::no_env>*>(nullptr))),
-            ex::detail::env_promise<ex::no_env>>);
-        // clang-format on
-        static_assert(ex::is_awaitable_v<awaitable_sender_4,
-            ex::detail::env_promise<ex::no_env>>);
-        static_assert(ex::is_awaitable_v<awaitable_sender_4,
-            ex::detail::env_promise<ex::empty_env>>);
-        static_assert(ex::is_awaitable_v<awaitable_sender_5,
-            ex::detail::env_promise<ex::no_env>>);
-        static_assert(ex::is_awaitable_v<awaitable_sender_5,
-            ex::detail::env_promise<ex::empty_env>>);
-#endif
     }
 
     // Operation base
@@ -346,12 +272,6 @@ int main()
     // sender
     {
         static_assert(ex::is_sender_v<awaitable_sender_1<awaiter>>);
-#if !defined(HPX_HAVE_STDEXEC)
-        static_assert(ex::is_sender_v<awaitable_sender_2>);
-        static_assert(ex::detail::is_enable_sender_v<awaitable_sender_2>);
-        static_assert(
-            ex::detail::is_sender_plain_v<awaitable_sender_2, ex::no_env>);
-#endif
         static_assert(ex::is_sender_v<awaitable_sender_3>);
         static_assert(ex::is_sender_v<awaitable_sender_4>);
     }
@@ -359,9 +279,6 @@ int main()
     // env promise
     {
         static_assert(is_sender_with_env_v<awaitable_sender_1<awaiter>>);
-#if !defined(HPX_HAVE_STDEXEC)
-        static_assert(is_sender_with_env_v<awaitable_sender_2>);
-#endif
         static_assert(is_sender_with_env_v<awaitable_sender_3>);
         static_assert(is_sender_with_env_v<awaitable_sender_4>);
     }
diff --git a/libs/core/execution_base/tests/unit/execute_may_block_caller.cpp b/libs/core/execution_base/tests/unit/execute_may_block_caller.cpp
index fc1a958f8aa2..400fd08a5bef 100644
--- a/libs/core/execution_base/tests/unit/execute_may_block_caller.cpp
+++ b/libs/core/execution_base/tests/unit/execute_may_block_caller.cpp
@@ -14,7 +14,6 @@ namespace tt = hpx::this_thread::experimental;
 
 struct this_test_example_scheduler
 {
-#if defined(HPX_HAVE_STDEXEC)
     struct example_sender
     {
         using is_sender = void;
@@ -26,20 +25,12 @@ struct this_test_example_scheduler
             return {};
         }
     };
-#endif
 
-#if defined(HPX_HAVE_STDEXEC)
     friend constexpr example_sender tag_invoke(
         ex::schedule_t, this_test_example_scheduler) noexcept
     {
         return {};
     }
-#else
-    friend constexpr void tag_invoke(
-        ex::schedule_t, this_test_example_scheduler) noexcept
-    {
-    }
-#endif
 
     friend constexpr bool tag_invoke(
         tt::execute_may_block_caller_t, this_test_example_scheduler) noexcept
diff --git a/libs/core/execution_base/tests/unit/get_env.cpp b/libs/core/execution_base/tests/unit/get_env.cpp
index 04a30addda09..957d60e779e5 100644
--- a/libs/core/execution_base/tests/unit/get_env.cpp
+++ b/libs/core/execution_base/tests/unit/get_env.cpp
@@ -31,17 +31,12 @@ namespace mylib {
     {
         using is_receiver = void;
 
-#if defined(HPX_HAVE_STDEXEC)
         decltype(auto) get_env() const noexcept
-#else
-        friend some_env tag_invoke(ex::get_env_t, receiver_2 const&) noexcept
-#endif
         {
             return some_env{};
         }
     };
 
-#if defined(HPX_HAVE_STDEXEC)
     inline constexpr struct receiver_env_t final : ex::forwarding_query_t
     {
         // clang-format off
@@ -52,54 +47,31 @@ namespace mylib {
         }
         // clang-format on
     } receiver_env{};
-#else
-    inline constexpr struct receiver_env_t final
-      : hpx::functional::tag<receiver_env_t>
-    {
-    } receiver_env{};
-#endif
 
-#if defined(HPX_HAVE_STDEXEC)
     auto env3 = ex::prop(receiver_env, 42);
     using env3_t = decltype(env3);
-#else
-    using env3_t = ex::make_env_t<receiver_env_t, int>;
-#endif
 
     struct receiver_3
     {
         using is_receiver = void;
 
-#if defined(HPX_HAVE_STDEXEC)
         decltype(auto) get_env() const noexcept
         {
             auto f = ex::prop(receiver_env, 42);
             return f;
         }
-#else
-        friend constexpr auto tag_invoke(
-            ex::get_env_t, receiver_3 const&) noexcept
-        {
-            return ex::make_env<receiver_env_t>(42);
-        }
-#endif
     };
 
-#if defined(HPX_HAVE_STDEXEC)
     // clang-format off
     auto env4 = ex::env(
         std::move(env3), ex::prop(receiver_env, std::string("42")));
     // clang-format on
     using env4_t = decltype(env4);
-#else
-    using env4_t = ex::make_env_t<receiver_env_t, std::string, env3_t>;
-#endif
 
     struct receiver_4
     {
         using is_receiver = void;
 
-#if defined(HPX_HAVE_STDEXEC)
         decltype(auto) get_env() const noexcept
         {
             receiver_3 rcv;
@@ -118,18 +90,8 @@ namespace mylib {
 
             return ex::env(std::move(e), std::move(p));
         }
-#else
-        friend auto tag_invoke(ex::get_env_t, receiver_4 const&) noexcept
-        {
-            receiver_3 rcv;
-
-            return ex::make_env<receiver_env_t>(
-                std::string("42"), ex::get_env(std::move(rcv)));
-        }
-#endif
     };
 
-#if defined(HPX_HAVE_STDEXEC)
     inline constexpr struct receiver_env1_t final : ex::forwarding_query_t
     {
         template <typename Env>
@@ -138,28 +100,17 @@ namespace mylib {
             return e.query(*this);
         }
     } receiver_env1{};
-#else
-    inline constexpr struct receiver_env1_t final
-      : hpx::functional::tag<receiver_env1_t>
-    {
-    } receiver_env1{};
-#endif
 
-#if defined(HPX_HAVE_STDEXEC)
     // clang-format off
     auto env5 =
         ex::env(std::move(env3), ex::prop(receiver_env1, std::string("42")));
     // clang-format on
     using env5_t = decltype(env5);
-#else
-    using env5_t = ex::make_env_t<receiver_env1_t, std::string, env3_t>;
-#endif
 
     struct receiver_5
     {
         using is_receiver = void;
 
-#if defined(HPX_HAVE_STDEXEC)
         decltype(auto) get_env() const noexcept
         {
             receiver_3 rcv;
@@ -172,82 +123,42 @@ namespace mylib {
             auto p = ex::prop(receiver_env1, std::string("42"));
             return ex::env(std::move(e), std::move(p));
         }
-#else
-        friend auto tag_invoke(ex::get_env_t, receiver_5 const&) noexcept
-        {
-            receiver_3 rcv;
-            return ex::make_env<receiver_env1_t>(
-                std::string("42"), ex::get_env(std::move(rcv)));
-        }
-#endif
     };
 }    // namespace mylib
 
 int main()
 {
     using ex::empty_env;
-#if !defined(HPX_HAVE_STDEXEC)
-    using ex::is_no_env_v;
-    using ex::no_env;
-
-    static_assert(
-        is_no_env_v<no_env>, "no_env is a (possibly cv-qualified) no_env");
-    static_assert(is_no_env_v<no_env const&>,
-        "no_env is a (possibly cv-qualified) no_env");
-    static_assert(!is_no_env_v<some_env>,
-        "some_env is not a (possibly cv-qualified) no_env");
-#endif
 
     {
         mylib::receiver_1 rcv;
-#if defined(HPX_HAVE_STDEXEC)
         auto env = ex::get_env(rcv);
-#else
-        auto env = ex::get_env(std::move(rcv));
-#endif
         static_assert(
             std::is_same_v<decltype(env), empty_env>, "must return empty_env");
     }
     {
         mylib::receiver_2 rcv;
-#if defined(HPX_HAVE_STDEXEC)
         auto env = ex::get_env(rcv);
-#else
-        auto env = ex::get_env(std::move(rcv));
-#endif
         static_assert(
             std::is_same_v<decltype(env), some_env>, "must return some_env");
     }
     {
         mylib::receiver_3 rcv;
-#if defined(HPX_HAVE_STDEXEC)
         auto env = ex::get_env(rcv);
-#else
-        auto env = ex::get_env(std::move(rcv));
-#endif
         HPX_TEST_EQ(mylib::receiver_env(env), 42);
     }
     {
         mylib::receiver_4 rcv;
-#if defined(HPX_HAVE_STDEXEC)
         // The resulting env_ = env(env1, env2) will query env1 first and env2
         // in that order, in order to find the resulting value of some query.
         // In cases when both env1 and env2 support the same query, as seen here
         // with receiver_env the result of env1 is picked.
         auto env = ex::get_env(rcv);
         HPX_TEST_EQ(mylib::receiver_env(env), 42);
-#else
-        auto env = ex::get_env(std::move(rcv));
-        HPX_TEST_EQ(mylib::receiver_env(env), std::string("42"));
-#endif
     }
     {
         mylib::receiver_5 rcv;
-#if defined(HPX_HAVE_STDEXEC)
         auto env = ex::get_env(rcv);
-#else
-        auto env = ex::get_env(std::move(rcv));
-#endif
         HPX_TEST_EQ(mylib::receiver_env(env), 42);
         HPX_TEST_EQ(mylib::receiver_env1(env), std::string("42"));
     }
diff --git a/libs/core/execution_base/tests/unit/stdexec.cpp b/libs/core/execution_base/tests/unit/stdexec.cpp
index fb75b5bc6c48..526a8a98e14b 100644
--- a/libs/core/execution_base/tests/unit/stdexec.cpp
+++ b/libs/core/execution_base/tests/unit/stdexec.cpp
@@ -9,7 +9,6 @@
 #include <hpx/config.hpp>
 #include <utility>
 
-#if defined(HPX_HAVE_STDEXEC)
 #include <hpx/execution_base/stdexec_forward.hpp>
 
 int main()
@@ -22,6 +21,3 @@ int main()
 
     return hpx::util::report_errors();
 }
-#else
-int main() {}
-#endif
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 9192cf84fd6b..71624acb52d1 100644
--- a/libs/core/executors/include/hpx/executors/explicit_scheduler_executor.hpp
+++ b/libs/core/executors/include/hpx/executors/explicit_scheduler_executor.hpp
@@ -188,14 +188,12 @@ namespace hpx::execution::experimental {
             explicit_scheduler_executor const& exec, F&& f, S const& shape,
             Ts&&... ts)
         {
-#if defined(HPX_HAVE_STDEXEC)
-//            We are using HPX's bulk implementation for now, so this works for
-//            other types too.
-//            static_assert(
-//                std::is_integral_v<S>,
-//                "P2300 expects bulk to be called only with integral types"
-//            );
-#endif
+            //            We are using HPX's bulk implementation for now, so this works for
+            //            other types too.
+            //            static_assert(
+            //                std::is_integral_v<S>,
+            //                "P2300 expects bulk to be called only with integral types"
+            //            );
 
             using shape_element =
                 typename hpx::traits::range_traits<S>::value_type;
@@ -235,18 +233,11 @@ namespace hpx::execution::experimental {
                     return HPX_MOVE(result_vector);
                 };
 
-#if defined(HPX_HAVE_STDEXEC)
                 return just(HPX_MOVE(result_vector), shape, HPX_FORWARD(F, f),
                            HPX_FORWARD(Ts, ts)...) |
                     continue_on(exec.sched_) |
                     bulk(shape_size, HPX_MOVE(f_wrapper)) |
                     then(HPX_MOVE(get_result));
-#else
-                return transfer_just(exec.sched_, HPX_MOVE(result_vector),
-                           shape, HPX_FORWARD(F, f), HPX_FORWARD(Ts, ts)...) |
-                    bulk(shape_size, HPX_MOVE(f_wrapper)) |
-                    then(HPX_MOVE(get_result));
-#endif
             }
         }
 
diff --git a/libs/core/executors/include/hpx/executors/thread_pool_scheduler.hpp b/libs/core/executors/include/hpx/executors/thread_pool_scheduler.hpp
index c86d48df9e14..1534ef1ce1b8 100644
--- a/libs/core/executors/include/hpx/executors/thread_pool_scheduler.hpp
+++ b/libs/core/executors/include/hpx/executors/thread_pool_scheduler.hpp
@@ -275,9 +275,7 @@ namespace hpx::execution::experimental {
         struct sender
         {
             HPX_NO_UNIQUE_ADDRESS std::decay_t<Scheduler> scheduler;
-#if defined(HPX_HAVE_STDEXEC)
             using sender_concept = hpx::execution::experimental::sender_t;
-#endif
             using completion_signatures =
                 hpx::execution::experimental::completion_signatures<
                     hpx::execution::experimental::set_value_t(),
@@ -303,7 +301,6 @@ namespace hpx::execution::experimental {
             {
                 return {s.scheduler, HPX_FORWARD(Receiver, receiver)};
             }
-#if defined(HPX_HAVE_STDEXEC)
             struct env
             {
                 std::decay_t<Scheduler> const& sched;
@@ -329,21 +326,6 @@ namespace hpx::execution::experimental {
             {
                 return {s.scheduler};
             };
-#else
-            // clang-format off
-            template <typename CPO,
-                HPX_CONCEPT_REQUIRES_(
-                    meta::value<meta::one_of<
-                        CPO, set_value_t, set_stopped_t>>
-                )>
-            // clang-format on
-            friend constexpr auto tag_invoke(
-                hpx::execution::experimental::get_completion_scheduler_t<CPO>,
-                sender const& s)
-            {
-                return s.scheduler;
-            }
-#endif
         };
 
         friend constexpr hpx::execution::experimental::
diff --git a/libs/core/executors/include/hpx/executors/thread_pool_scheduler_bulk.hpp b/libs/core/executors/include/hpx/executors/thread_pool_scheduler_bulk.hpp
index 66aecce58f5e..9fdc604b3021 100644
--- a/libs/core/executors/include/hpx/executors/thread_pool_scheduler_bulk.hpp
+++ b/libs/core/executors/include/hpx/executors/thread_pool_scheduler_bulk.hpp
@@ -8,9 +8,7 @@
 #pragma once
 
 #include <hpx/config.hpp>
-#if defined(HPX_HAVE_STDEXEC)
 #include <hpx/execution_base/stdexec_forward.hpp>
-#endif
 
 #include <hpx/assert.hpp>
 #include <hpx/concepts/concepts.hpp>
@@ -339,9 +337,7 @@ namespace hpx::execution::experimental::detail {
     template <typename OperationState, typename F, typename Shape>
     struct bulk_receiver
     {
-#if defined(HPX_HAVE_STDEXEC)
         using receiver_concept = hpx::execution::experimental::receiver_t;
-#endif
         OperationState* op_state;
 
         template <typename E>
@@ -663,7 +659,6 @@ namespace hpx::execution::experimental::detail {
         thread_pool_bulk_sender& operator=(
             thread_pool_bulk_sender const&) = default;
 
-#if defined(HPX_HAVE_STDEXEC)
         using sender_concept = hpx::execution::experimental::sender_t;
 
         template <typename Env>
@@ -716,54 +711,6 @@ namespace hpx::execution::experimental::detail {
         {
             return env{s.sender, s.scheduler};
         }
-#else
-        template <typename Env>
-        struct generate_completion_signatures
-        {
-            template <template <typename...> typename Tuple,
-                template <typename...> typename Variant>
-            using value_types = value_types_of_t<Sender, Env, Tuple, Variant>;
-
-            template <template <typename...> typename Variant>
-            using error_types = hpx::util::detail::unique_concat_t<
-                error_types_of_t<Sender, Env, Variant>,
-                Variant<std::exception_ptr>>;
-
-            static constexpr bool sends_stopped =
-                sends_stopped_of_v<Sender, Env>;
-        };
-
-        // clang-format off
-        template <typename Env>
-        friend auto tag_invoke(
-            hpx::execution::experimental::get_completion_signatures_t,
-            thread_pool_bulk_sender const&,
-            Env) -> generate_completion_signatures<Env>;
-
-        template <typename CPO,
-            HPX_CONCEPT_REQUIRES_(
-                meta::value<meta::one_of<CPO,
-                    hpx::execution::experimental::set_error_t,
-                    hpx::execution::experimental::set_stopped_t>> &&
-                hpx::execution::experimental::detail::has_completion_scheduler_v<
-                    CPO, std::decay_t<Sender>>
-            )>
-        // clang-format on
-        friend constexpr auto tag_invoke(
-            hpx::execution::experimental::get_completion_scheduler_t<CPO> tag,
-            thread_pool_bulk_sender const& s)
-        {
-            return tag(s.sender);
-        }
-
-        friend constexpr auto tag_invoke(
-            hpx::execution::experimental::get_completion_scheduler_t<
-                hpx::execution::experimental::set_value_t>,
-            thread_pool_bulk_sender const& s)
-        {
-            return s.scheduler;
-        }
-#endif
 
     private:
         template <typename Receiver>
@@ -886,15 +833,9 @@ namespace hpx::execution::experimental {
         if constexpr (std::is_same_v<Policy, launch::sync_policy>)
         {
             // fall back to non-bulk scheduling if sync execution was requested
-#if defined(HPX_HAVE_STDEXEC)
             return hpx::execution::experimental::bulk(
                 HPX_FORWARD(Sender, sender), hpx::util::counting_shape(count),
                 HPX_FORWARD(F, f));
-#else
-            return detail::bulk_sender<Sender, hpx::util::counting_shape<Count>,
-                F>{HPX_FORWARD(Sender, sender),
-                hpx::util::counting_shape(count), HPX_FORWARD(F, f)};
-#endif
         }
         else
         {
diff --git a/libs/core/executors/tests/unit/thread_pool_scheduler.cpp b/libs/core/executors/tests/unit/thread_pool_scheduler.cpp
index 6bdbf6a1258f..ce8b21e22f1d 100644
--- a/libs/core/executors/tests/unit/thread_pool_scheduler.cpp
+++ b/libs/core/executors/tests/unit/thread_pool_scheduler.cpp
@@ -67,9 +67,7 @@ struct check_context_receiver
     hpx::mutex& mtx;
     hpx::condition_variable& cond;
     bool& executed;
-#if defined(HPX_HAVE_STDEXEC)
     using receiver_concept = ex::receiver_t;
-#endif
     template <typename E>
     friend void tag_invoke(
         ex::set_error_t, check_context_receiver&&, E&&) noexcept
@@ -232,9 +230,7 @@ struct callback_receiver
     hpx::mutex& mtx;
     hpx::condition_variable& cond;
     bool& executed;
-#if defined(HPX_HAVE_STDEXEC)
     using receiver_concept = ex::receiver_t;
-#endif
 
     template <typename E>
     friend void tag_invoke(ex::set_error_t, callback_receiver&&, E&&) noexcept
@@ -583,7 +579,6 @@ void test_when_all()
             ex::when_all(std::move(work1), std::move(work2), std::move(work3));
 
         bool executed{false};
-#if defined(HPX_HAVE_STDEXEC)
         tt::sync_wait(std::move(when1) |
             ex::then([parent_id, &executed](int x, std::string y, double z) {
                 HPX_TEST_NEQ(parent_id, hpx::this_thread::get_id());
@@ -592,17 +587,6 @@ void test_when_all()
                 HPX_TEST_EQ(z, 3.14);
                 executed = true;
             }));
-#else
-        std::move(when1) |
-            ex::then([parent_id, &executed](int x, std::string y, double z) {
-                HPX_TEST_NEQ(parent_id, hpx::this_thread::get_id());
-                HPX_TEST_EQ(x, 42);
-                HPX_TEST_EQ(y, std::string("hello"));
-                HPX_TEST_EQ(z, 3.14);
-                executed = true;
-            }) |
-            tt::sync_wait();
-#endif
         HPX_TEST(executed);
     }
 
@@ -626,22 +610,12 @@ void test_when_all()
 
         try
         {
-#if defined(HPX_HAVE_STDEXEC)
             tt::sync_wait(ex::when_all(std::move(work1), std::move(work2)) |
                 ex::then([parent_id](int x, std::string y) {
                     HPX_TEST_NEQ(parent_id, hpx::this_thread::get_id());
                     HPX_TEST_EQ(x, 42);
                     HPX_TEST_EQ(y, std::string("hello"));
                 }));
-#else
-            ex::when_all(std::move(work1), std::move(work2)) |
-                ex::then([parent_id](int x, std::string y) {
-                    HPX_TEST_NEQ(parent_id, hpx::this_thread::get_id());
-                    HPX_TEST_EQ(x, 42);
-                    HPX_TEST_EQ(y, std::string("hello"));
-                }) |
-                tt::sync_wait();
-#endif
             HPX_TEST(false);
         }
         catch (std::runtime_error const& e)
@@ -673,22 +647,12 @@ void test_when_all()
 
         try
         {
-#if defined(HPX_HAVE_STDEXEC)
             tt::sync_wait(ex::when_all(std::move(work1), std::move(work2)) |
                 ex::then([parent_id](int x, std::string y) {
                     HPX_TEST_NEQ(parent_id, hpx::this_thread::get_id());
                     HPX_TEST_EQ(x, 42);
                     HPX_TEST_EQ(y, std::string("hello"));
                 }));
-#else
-            ex::when_all(std::move(work1), std::move(work2)) |
-                ex::then([parent_id](int x, std::string y) {
-                    HPX_TEST_NEQ(parent_id, hpx::this_thread::get_id());
-                    HPX_TEST_EQ(x, 42);
-                    HPX_TEST_EQ(y, std::string("hello"));
-                }) |
-                tt::sync_wait();
-#endif
             HPX_TEST(false);
         }
         catch (std::runtime_error const& e)
@@ -713,11 +677,7 @@ void test_future_sender()
             "a future should be adaptable to a sender");
         static_assert(std::is_same_v<
                           std::decay_t<decltype(*tt::sync_wait(std::move(fs)))>,
-#if defined(HPX_HAVE_STDEXEC)
                           std::tuple<>>,
-#else
-                          hpx::tuple<>>,
-#endif
             "sync_wait should return hpx::tuple<>");
 
         tt::sync_wait(std::move(fs));
@@ -790,11 +750,7 @@ void test_future_sender()
             "a shared_future should be adaptable as a sender");
         static_assert(
             std::is_same_v<std::decay_t<decltype(*tt::sync_wait(sfs))>,
-#if defined(HPX_HAVE_STDEXEC)
                 std::tuple<>>,
-#else
-                hpx::tuple<>>,
-#endif
             "sync_wait should return hpx::tuple<>");
 
         tt::sync_wait(sfs);
@@ -933,11 +889,7 @@ void test_ensure_started()
     ex::thread_pool_scheduler sched{};
 
     {
-#if defined(HPX_HAVE_STDEXEC)
         tt::sync_wait(ex::schedule(sched) | ex::ensure_started());
-#else
-        ex::schedule(sched) | ex::ensure_started() | tt::sync_wait();
-#endif
     }
 
     {
@@ -952,11 +904,8 @@ void test_ensure_started()
     }
 
     {
-        auto s = ex::transfer_just(sched, 42) | ex::ensure_started()
-#if defined(HPX_HAVE_STDEXEC)
-            | ex::split()
-#endif
-            ;
+        auto s =
+            ex::transfer_just(sched, 42) | ex::ensure_started() | ex::split();
         HPX_TEST_EQ(hpx::get<0>(*tt::sync_wait(s)), 42);
         HPX_TEST_EQ(hpx::get<0>(*tt::sync_wait(s)), 42);
         HPX_TEST_EQ(hpx::get<0>(*tt::sync_wait(s)), 42);
@@ -979,10 +928,8 @@ void test_ensure_started_when_all()
             std::lock_guard l{mtx};
             started = true;
             cond.notify_one();
-        }) | ex::ensure_started()
-#if defined(HPX_HAVE_STDEXEC)
-            | ex::split();
-#endif
+        }) | ex::ensure_started() |
+            ex::split();
         ;
         {
             std::unique_lock l{mtx};
@@ -996,18 +943,10 @@ void test_ensure_started_when_all()
             ++successor_task_calls;
             return 2;
         });
-#if defined(HPX_HAVE_STDEXEC)
         HPX_TEST_EQ(
             hpx::get<0>(*tt::sync_wait(ex::when_all(succ1, succ2) |
                 ex::then([](int const& x, int const& y) { return x + y; }))),
             3);
-#else
-        HPX_TEST_EQ(
-            hpx::get<0>(*(ex::when_all(succ1, succ2) |
-                ex::then([](int const& x, int const& y) { return x + y; }) |
-                tt::sync_wait())),
-            3);
-#endif
         HPX_TEST_EQ(first_task_calls, std::size_t(1));
         HPX_TEST_EQ(successor_task_calls, std::size_t(2));
     }
@@ -1024,11 +963,8 @@ void test_ensure_started_when_all()
             started = true;
             cond.notify_one();
             return 3;
-        }) | ex::ensure_started()
-#if defined(HPX_HAVE_STDEXEC)
-            | ex::split()
-#endif
-            ;
+        }) | ex::ensure_started() |
+            ex::split();
         {
             std::unique_lock l{mtx};
             cond.wait(l, [&]() { return started; });
@@ -1042,18 +978,10 @@ void test_ensure_started_when_all()
             ++successor_task_calls;
             return x + 2;
         });
-#if defined(HPX_HAVE_STDEXEC)
         HPX_TEST_EQ(
             hpx::get<0>(*tt::sync_wait(ex::when_all(succ1, succ2) |
                 ex::then([](int const& x, int const& y) { return x + y; }))),
             9);
-#else
-        HPX_TEST_EQ(
-            hpx::get<0>(*(ex::when_all(succ1, succ2) |
-                ex::then([](int const& x, int const& y) { return x + y; }) |
-                tt::sync_wait())),
-            9);
-#endif
         HPX_TEST_EQ(first_task_calls, std::size_t(1));
         HPX_TEST_EQ(successor_task_calls, std::size_t(2));
     }
@@ -1070,11 +998,8 @@ void test_ensure_started_when_all()
             started = true;
             cond.notify_one();
             return 3;
-        }) | ex::ensure_started()
-#if defined(HPX_HAVE_STDEXEC)
-            | ex::split()
-#endif
-            ;
+        }) | ex::ensure_started() |
+            ex::split();
         {
             std::unique_lock l{mtx};
             cond.wait(l, [&]() { return started; });
@@ -1087,18 +1012,10 @@ void test_ensure_started_when_all()
             ++successor_task_calls;
             return x + 2;
         });
-#if defined(HPX_HAVE_STDEXEC)
         HPX_TEST_EQ(
             hpx::get<0>(*tt::sync_wait(ex::when_all(succ1, succ2) |
                 ex::then([](int const& x, int const& y) { return x + y; }))),
             9);
-#else
-        HPX_TEST_EQ(
-            hpx::get<0>(*(ex::when_all(succ1, succ2) |
-                ex::then([](int const& x, int const& y) { return x + y; }) |
-                tt::sync_wait())),
-            9);
-#endif
         HPX_TEST_EQ(first_task_calls, std::size_t(1));
         HPX_TEST_EQ(successor_task_calls, std::size_t(2));
     }
@@ -1109,11 +1026,7 @@ void test_split()
     ex::thread_pool_scheduler sched{};
 
     {
-#if defined(HPX_HAVE_STDEXEC)
         tt::sync_wait(ex::schedule(sched) | ex::split());
-#else
-        ex::schedule(sched) | ex::split() | tt::sync_wait();
-#endif
     }
 
     {
@@ -1153,18 +1066,10 @@ void test_split_when_all()
             ++successor_task_calls;
             return 2;
         });
-#if defined(HPX_HAVE_STDEXEC)
         HPX_TEST_EQ(
             hpx::get<0>(*tt::sync_wait(ex::when_all(succ1, succ2) |
                 ex::then([](int const& x, int const& y) { return x + y; }))),
             3);
-#else
-        HPX_TEST_EQ(
-            hpx::get<0>(*(ex::when_all(succ1, succ2) |
-                ex::then([](int const& x, int const& y) { return x + y; }) |
-                tt::sync_wait())),
-            3);
-#endif
         HPX_TEST_EQ(first_task_calls, std::size_t(1));
         HPX_TEST_EQ(successor_task_calls, std::size_t(2));
     }
@@ -1184,19 +1089,10 @@ void test_split_when_all()
             ++successor_task_calls;
             return x + 2;
         });
-#if defined(HPX_HAVE_STDEXEC)
         HPX_TEST_EQ(
             hpx::get<0>(*tt::sync_wait(ex::when_all(succ1, succ2) |
                 ex::then([](int const& x, int const& y) { return x + y; }))),
             9);
-#else
-
-        HPX_TEST_EQ(
-            hpx::get<0>(*(ex::when_all(succ1, succ2) |
-                ex::then([](int const& x, int const& y) { return x + y; }) |
-                tt::sync_wait())),
-            9);
-#endif
         HPX_TEST_EQ(first_task_calls, std::size_t(1));
         HPX_TEST_EQ(successor_task_calls, std::size_t(2));
     }
@@ -1216,18 +1112,10 @@ void test_split_when_all()
             ++successor_task_calls;
             return x + 2;
         });
-#if defined(HPX_HAVE_STDEXEC)
         HPX_TEST_EQ(
             hpx::get<0>(*(tt::sync_wait(ex::when_all(succ1, succ2) |
                 ex::then([](int const& x, int const& y) { return x + y; })))),
             9);
-#else
-        HPX_TEST_EQ(
-            hpx::get<0>(*(ex::when_all(succ1, succ2) |
-                ex::then([](int const& x, int const& y) { return x + y; }) |
-                tt::sync_wait())),
-            9);
-#endif
         HPX_TEST_EQ(first_task_calls, std::size_t(1));
         HPX_TEST_EQ(successor_task_calls, std::size_t(2));
     }
@@ -1239,127 +1127,70 @@ void test_let_value()
 
     // void predecessor
     {
-#if defined(HPX_HAVE_STDEXEC)
         auto result = hpx::get<0>(*(tt::sync_wait(ex::schedule(sched) |
             ex::let_value([]() { return ex::just(42); }))));
-#else
-        auto result = hpx::get<0>(*(ex::schedule(sched) |
-            ex::let_value([]() { return ex::just(42); }) | tt::sync_wait()));
-#endif
         HPX_TEST_EQ(result, 42);
     }
 
     {
-#if defined(HPX_HAVE_STDEXEC)
         auto result = hpx::get<0>(*(tt::sync_wait(ex::schedule(sched) |
             ex::let_value([=]() { return ex::transfer_just(sched, 42); }))));
-#else
-        auto result = hpx::get<0>(*(ex::schedule(sched) | ex::let_value([=]() {
-            return ex::transfer_just(sched, 42);
-        }) | tt::sync_wait()));
-#endif
         HPX_TEST_EQ(result, 42);
     }
 
     {
-#if defined(HPX_HAVE_STDEXEC)
         auto result = hpx::get<0>(*tt::sync_wait((ex::just() |
             ex::let_value([=]() { return ex::transfer_just(sched, 42); }))));
-#else
-        auto result = hpx::get<0>(*(ex::just() | ex::let_value([=]() {
-            return ex::transfer_just(sched, 42);
-        }) | tt::sync_wait()));
-#endif
         HPX_TEST_EQ(result, 42);
     }
 
     // int predecessor, value ignored
     {
-#if defined(HPX_HAVE_STDEXEC)
         auto result = hpx::get<0>(*(tt::sync_wait(ex::transfer_just(sched, 43) |
             ex::let_value([](int&) { return ex::just(42); }))));
-#else
-        auto result = hpx::get<0>(*(ex::transfer_just(sched, 43) |
-            ex::let_value([](int&) { return ex::just(42); }) |
-            tt::sync_wait()));
-#endif
         HPX_TEST_EQ(result, 42);
     }
 
     {
-#if defined(HPX_HAVE_STDEXEC)
         auto result = hpx::get<0>(*(tt::sync_wait(ex::transfer_just(sched, 43) |
             ex::let_value(
                 [=](int&) { return ex::transfer_just(sched, 42); }))));
-#else
-        auto result = hpx::get<0>(*(ex::transfer_just(sched, 43) |
-            ex::let_value([=](int&) { return ex::transfer_just(sched, 42); }) |
-            tt::sync_wait()));
-#endif
         HPX_TEST_EQ(result, 42);
     }
 
     {
-#if defined(HPX_HAVE_STDEXEC)
         auto result =
             hpx::get<0>(*(tt::sync_wait(ex::just(43) | ex::let_value([=](int&) {
                 return ex::transfer_just(sched, 42);
             }))));
-#else
-        auto result = hpx::get<0>(*(ex::just(43) | ex::let_value([=](int&) {
-            return ex::transfer_just(sched, 42);
-        }) | tt::sync_wait()));
-#endif
         HPX_TEST_EQ(result, 42);
     }
 
     // int predecessor, value used
     {
-#if defined(HPX_HAVE_STDEXEC)
         auto result = hpx::get<0>(*(tt::sync_wait(
             ex::transfer_just(sched, 43) | ex::let_value([](int& x) {
                 return ex::just(42) | ex::then([&](int y) { return x + y; });
             }))));
 
-#else
-        auto result = hpx::get<0>(
-            *(ex::transfer_just(sched, 43) | ex::let_value([](int& x) {
-                return ex::just(42) | ex::then([&](int y) { return x + y; });
-            }) | tt::sync_wait()));
-#endif
         HPX_TEST_EQ(result, 85);
     }
 
     {
-#if defined(HPX_HAVE_STDEXEC)
         auto result = hpx::get<0>(*(tt::sync_wait(
             ex::transfer_just(sched, 43) | ex::let_value([=](int& x) {
                 return ex::transfer_just(sched, 42) |
                     ex::then([&](int y) { return x + y; });
             }))));
-#else
-        auto result = hpx::get<0>(
-            *(ex::transfer_just(sched, 43) | ex::let_value([=](int& x) {
-                return ex::transfer_just(sched, 42) |
-                    ex::then([&](int y) { return x + y; });
-            }) | tt::sync_wait()));
-#endif
         HPX_TEST_EQ(result, 85);
     }
 
     {
-#if defined(HPX_HAVE_STDEXEC)
         auto result = hpx::get<0>(
             *(tt::sync_wait(ex::just(43) | ex::let_value([=](int& x) {
                 return ex::transfer_just(sched, 42) |
                     ex::then([&](int y) { return x + y; });
             }))));
-#else
-        auto result = hpx::get<0>(*(ex::just(43) | ex::let_value([=](int& x) {
-            return ex::transfer_just(sched, 42) |
-                ex::then([&](int y) { return x + y; });
-        }) | tt::sync_wait()));
-#endif
         HPX_TEST_EQ(result, 85);
     }
 
@@ -1369,7 +1200,6 @@ void test_let_value()
 
         try
         {
-#if defined(HPX_HAVE_STDEXEC)
             tt::sync_wait(ex::transfer_just(sched, 43) | ex::then([](int x) {
                 throw std::runtime_error("error");
                 return x;
@@ -1377,15 +1207,6 @@ void test_let_value()
                 HPX_TEST(false);
                 return ex::just(0);
             }));
-#else
-            ex::transfer_just(sched, 43) | ex::then([](int x) {
-                throw std::runtime_error("error");
-                return x;
-            }) | ex::let_value([](int&) {
-                HPX_TEST(false);
-                return ex::just(0);
-            }) | tt::sync_wait();
-#endif
             HPX_TEST(false);
         }
         catch (std::runtime_error const& e)
@@ -1421,7 +1242,6 @@ void test_let_error()
     // void predecessor
     {
         std::atomic<bool> called{false};
-#if defined(HPX_HAVE_STDEXEC)
         tt::sync_wait(ex::schedule(sched) | ex::then([]() {
             throw std::runtime_error("error");
         }) | ex::let_error([&called](std::exception_ptr& ep) {
@@ -1429,21 +1249,11 @@ void test_let_error()
             check_exception_ptr_message(ep, "error");
             return ex::just();
         }));
-#else
-        ex::schedule(sched) | ex::then([]() {
-            throw std::runtime_error("error");
-        }) | ex::let_error([&called](std::exception_ptr& ep) {
-            called = true;
-            check_exception_ptr_message(ep, "error");
-            return ex::just();
-        }) | tt::sync_wait();
-#endif
         HPX_TEST(called);
     }
 
     {
         std::atomic<bool> called{false};
-#if defined(HPX_HAVE_STDEXEC)
         tt::sync_wait(ex::schedule(sched) | ex::then([]() {
             throw std::runtime_error("error");
         }) | ex::let_error([=, &called](std::exception_ptr& ep) {
@@ -1451,21 +1261,11 @@ void test_let_error()
             check_exception_ptr_message(ep, "error");
             return ex::transfer_just(sched);
         }));
-#else
-        ex::schedule(sched) | ex::then([]() {
-            throw std::runtime_error("error");
-        }) | ex::let_error([=, &called](std::exception_ptr& ep) {
-            called = true;
-            check_exception_ptr_message(ep, "error");
-            return ex::transfer_just(sched);
-        }) | tt::sync_wait();
-#endif
         HPX_TEST(called);
     }
 
     {
         std::atomic<bool> called{false};
-#if defined(HPX_HAVE_STDEXEC)
         tt::sync_wait(ex::just() | ex::then([]() {
             throw std::runtime_error("error");
         }) | ex::let_error([=, &called](std::exception_ptr& ep) {
@@ -1473,21 +1273,11 @@ void test_let_error()
             check_exception_ptr_message(ep, "error");
             return ex::transfer_just(sched);
         }));
-#else
-        ex::just() | ex::then([]() { throw std::runtime_error("error"); }) |
-            ex::let_error([=, &called](std::exception_ptr& ep) {
-                called = true;
-                check_exception_ptr_message(ep, "error");
-                return ex::transfer_just(sched);
-            }) |
-            tt::sync_wait();
-#endif
         HPX_TEST(called);
     }
 
     // int predecessor
     {
-#if defined(HPX_HAVE_STDEXEC)
         auto result =
             hpx::get<0>(*(tt::sync_wait(ex::schedule(sched) | ex::then([]() {
                 throw std::runtime_error("error");
@@ -1496,20 +1286,10 @@ void test_let_error()
                 check_exception_ptr_message(ep, "error");
                 return ex::just(42);
             }))));
-#else
-        auto result = hpx::get<0>(*(ex::schedule(sched) | ex::then([]() {
-            throw std::runtime_error("error");
-            return 43;
-        }) | ex::let_error([](std::exception_ptr& ep) {
-            check_exception_ptr_message(ep, "error");
-            return ex::just(42);
-        }) | tt::sync_wait()));
-#endif
         HPX_TEST_EQ(result, 42);
     }
 
     {
-#if defined(HPX_HAVE_STDEXEC)
         auto result =
             hpx::get<0>(*(tt::sync_wait(ex::schedule(sched) | ex::then([]() {
                 throw std::runtime_error("error");
@@ -1518,20 +1298,10 @@ void test_let_error()
                 check_exception_ptr_message(ep, "error");
                 return ex::transfer_just(sched, 42);
             }))));
-#else
-        auto result = hpx::get<0>(*(ex::schedule(sched) | ex::then([]() {
-            throw std::runtime_error("error");
-            return 43;
-        }) | ex::let_error([=](std::exception_ptr& ep) {
-            check_exception_ptr_message(ep, "error");
-            return ex::transfer_just(sched, 42);
-        }) | tt::sync_wait()));
-#endif
         HPX_TEST_EQ(result, 42);
     }
 
     {
-#if defined(HPX_HAVE_STDEXEC)
         auto result = hpx::get<0>(*(tt::sync_wait(ex::just() | ex::then([]() {
             throw std::runtime_error("error");
             return 43;
@@ -1539,69 +1309,34 @@ void test_let_error()
             check_exception_ptr_message(ep, "error");
             return ex::transfer_just(sched, 42);
         }))));
-#else
-        auto result = hpx::get<0>(*(ex::just() | ex::then([]() {
-            throw std::runtime_error("error");
-            return 43;
-        }) | ex::let_error([=](std::exception_ptr& ep) {
-            check_exception_ptr_message(ep, "error");
-            return ex::transfer_just(sched, 42);
-        }) | tt::sync_wait()));
-#endif
         HPX_TEST_EQ(result, 42);
     }
 
     // predecessor doesn't throw, let sender is ignored
     {
-#if defined(HPX_HAVE_STDEXEC)
         auto result = hpx::get<0>(*(tt::sync_wait(ex::transfer_just(sched, 42) |
             ex::let_error([](std::exception_ptr) {
                 HPX_TEST(false);
                 return ex::just(43);
             }))));
-#else
-        auto result = hpx::get<0>(*(ex::transfer_just(sched, 42) |
-            ex::let_error([](std::exception_ptr) {
-                HPX_TEST(false);
-                return ex::just(43);
-            }) |
-            tt::sync_wait()));
-#endif
         HPX_TEST_EQ(result, 42);
     }
 
     {
-#if defined(HPX_HAVE_STDEXEC)
         auto result = hpx::get<0>(*(tt::sync_wait(ex::transfer_just(sched, 42) |
             ex::let_error([=](std::exception_ptr) {
                 HPX_TEST(false);
                 return ex::transfer_just(sched, 43);
             }))));
-#else
-        auto result = hpx::get<0>(*(ex::transfer_just(sched, 42) |
-            ex::let_error([=](std::exception_ptr) {
-                HPX_TEST(false);
-                return ex::transfer_just(sched, 43);
-            }) |
-            tt::sync_wait()));
-#endif
         HPX_TEST_EQ(result, 42);
     }
 
     {
-#if defined(HPX_HAVE_STDEXEC)
         auto result = hpx::get<0>(*(
             tt::sync_wait(ex::just(42) | ex::let_error([=](std::exception_ptr) {
                 HPX_TEST(false);
                 return ex::transfer_just(sched, 43);
             }))));
-#else
-        auto result =
-            hpx::get<0>(*(ex::just(42) | ex::let_error([=](std::exception_ptr) {
-                HPX_TEST(false);
-                return ex::transfer_just(sched, 43);
-            }) | tt::sync_wait()));
-#endif
         HPX_TEST_EQ(result, 42);
     }
 }
@@ -1614,19 +1349,11 @@ void test_detach()
         bool called = false;
         hpx::mutex mtx;
         hpx::condition_variable cond;
-#if defined(HPX_HAVE_STDEXEC)
         ex::start_detached(ex::schedule(sched) | ex::then([&]() {
             std::unique_lock l{mtx};
             called = true;
             cond.notify_one();
         }));
-#else
-        ex::schedule(sched) | ex::then([&]() {
-            std::unique_lock l{mtx};
-            called = true;
-            cond.notify_one();
-        }) | ex::start_detached();
-#endif
 
         {
             std::unique_lock l{mtx};
@@ -1641,21 +1368,12 @@ void test_detach()
         bool called = false;
         hpx::mutex mtx;
         hpx::condition_variable cond;
-#if defined(HPX_HAVE_STDEXEC)
         ex::start_detached(ex::schedule(sched) | ex::then([&]() {
             std::lock_guard l{mtx};
             called = true;
             cond.notify_one();
             return 42;
         }));
-#else
-        ex::schedule(sched) | ex::then([&]() {
-            std::lock_guard l{mtx};
-            called = true;
-            cond.notify_one();
-            return 42;
-        }) | ex::start_detached();
-#endif
 
         {
             std::unique_lock l{mtx};
@@ -1670,61 +1388,30 @@ void test_keep_future_sender()
 {
     // the future should be passed to then, not it's contained value
     {
-#if defined(HPX_HAVE_STDEXEC)
         tt::sync_wait(ex::keep_future(hpx::make_ready_future<void>()) |
             ex::then([](hpx::future<void>&& f) { HPX_TEST(f.is_ready()); }));
-#else
-        ex::keep_future(hpx::make_ready_future<void>()) |
-            ex::then([](hpx::future<void>&& f) { HPX_TEST(f.is_ready()); }) |
-            tt::sync_wait();
-#endif
     }
 
     {
-#if defined(HPX_HAVE_STDEXEC)
         tt::sync_wait(ex::keep_future(hpx::make_ready_future<void>().share()) |
             ex::then(
                 [](hpx::shared_future<void>&& f) { HPX_TEST(f.is_ready()); }));
-#else
-        ex::keep_future(hpx::make_ready_future<void>().share()) |
-            ex::then(
-                [](hpx::shared_future<void>&& f) { HPX_TEST(f.is_ready()); }) |
-            tt::sync_wait();
-#endif
     }
 
     {
-#if defined(HPX_HAVE_STDEXEC)
         tt::sync_wait(ex::keep_future(hpx::make_ready_future<int>(42)) |
             ex::then([](hpx::future<int>&& f) {
                 HPX_TEST(f.is_ready());
                 HPX_TEST_EQ(f.get(), 42);
             }));
-#else
-        ex::keep_future(hpx::make_ready_future<int>(42)) |
-            ex::then([](hpx::future<int>&& f) {
-                HPX_TEST(f.is_ready());
-                HPX_TEST_EQ(f.get(), 42);
-            }) |
-            tt::sync_wait();
-#endif
     }
 
     {
-#if defined(HPX_HAVE_STDEXEC)
         tt::sync_wait(ex::keep_future(hpx::make_ready_future<int>(42).share()) |
             ex::then([](hpx::shared_future<int>&& f) {
                 HPX_TEST(f.is_ready());
                 HPX_TEST_EQ(f.get(), 42);
             }));
-#else
-        ex::keep_future(hpx::make_ready_future<int>(42).share()) |
-            ex::then([](hpx::shared_future<int>&& f) {
-                HPX_TEST(f.is_ready());
-                HPX_TEST_EQ(f.get(), 42);
-            }) |
-            tt::sync_wait();
-#endif
     }
 
     {
@@ -1851,26 +1538,16 @@ void test_keep_future_sender()
     // Keep future alive across on
     {
         auto f = hpx::async([&]() { return 42; });
-#if defined(HPX_HAVE_STDEXEC)
         auto r = hpx::get<0>(*(tt::sync_wait(ex::keep_future(std::move(f)) |
             ex::transfer(ex::thread_pool_scheduler{}))));
-#else
-        auto r = hpx::get<0>(*(ex::keep_future(std::move(f)) |
-            ex::transfer(ex::thread_pool_scheduler{}) | tt::sync_wait()));
-#endif
         HPX_TEST(r.is_ready());
         HPX_TEST_EQ(r.get(), 42);
     }
 
     {
         auto sf = hpx::async([&]() { return 42; }).share();
-#if defined(HPX_HAVE_STDEXEC)
         auto r = hpx::get<0>(*(tt::sync_wait(ex::keep_future(std::move(sf)) |
             ex::transfer(ex::thread_pool_scheduler{}))));
-#else
-        auto r = hpx::get<0>(*(ex::keep_future(std::move(sf)) |
-            ex::transfer(ex::thread_pool_scheduler{}) | tt::sync_wait()));
-#endif
         HPX_TEST(r.is_ready());
         HPX_TEST_EQ(r.get(), 42);
     }
@@ -1885,13 +1562,8 @@ void test_keep_future_sender()
         // or storing a const&. The copy is not possible because the type is
         // noncopyable, and storing a reference is not acceptable since the
         // reference may outlive the value.
-#if defined(HPX_HAVE_STDEXEC)
         auto r = hpx::get<0>(*(tt::sync_wait(ex::keep_future(std::move(sf)) |
             ex::transfer(ex::thread_pool_scheduler{}))));
-#else
-        auto r = hpx::get<0>(*(ex::keep_future(std::move(sf)) |
-            ex::transfer(ex::thread_pool_scheduler{}) | tt::sync_wait()));
-#endif
         HPX_TEST(r.is_ready());
         HPX_TEST_EQ(r.get().x, 42);
     }
@@ -1903,18 +1575,11 @@ void test_keep_future_sender()
 
         auto fun = hpx::unwrapping(
             [](int&& x, double const& y) { return x * 2 + (int(y) / 2); });
-#if defined(HPX_HAVE_STDEXEC)
         HPX_TEST_EQ(hpx::get<0>(*(tt::sync_wait(
                         ex::when_all(ex::keep_future(std::move(f)),
                             ex::keep_future(sf)) |
                         ex::then(fun)))),
             85);
-#else
-        HPX_TEST_EQ(hpx::get<0>(*(ex::when_all(ex::keep_future(std::move(f)),
-                                      ex::keep_future(sf)) |
-                        ex::then(fun) | tt::sync_wait())),
-            85);
-#endif
     }
 
     {
@@ -1923,20 +1588,12 @@ void test_keep_future_sender()
 
         auto fun = hpx::unwrapping(
             [](int&& x, double const& y) { return x * 2 + (int(y) / 2); });
-#if defined(HPX_HAVE_STDEXEC)
         HPX_TEST_EQ(
             hpx::get<0>(*(tt::sync_wait(
                 ex::when_all(
                     ex::keep_future(std::move(f)), ex::keep_future(sf)) |
                 ex::transfer(ex::thread_pool_scheduler{}) | ex::then(fun)))),
             85);
-#else
-        HPX_TEST_EQ(hpx::get<0>(*(ex::when_all(ex::keep_future(std::move(f)),
-                                      ex::keep_future(sf)) |
-                        ex::transfer(ex::thread_pool_scheduler{}) |
-                        ex::then(fun) | tt::sync_wait())),
-            85);
-#endif
     }
 }
 
@@ -1949,18 +1606,11 @@ void test_bulk()
         std::vector<int> v(n, 0);
         hpx::thread::id parent_id = hpx::this_thread::get_id();
 
-#if defined(HPX_HAVE_STDEXEC)
         tt::sync_wait(
             ex::schedule(ex::thread_pool_scheduler{}) | ex::bulk(n, [&](int i) {
                 ++v[i];
                 HPX_TEST_NEQ(parent_id, hpx::this_thread::get_id());
             }));
-#else
-        ex::schedule(ex::thread_pool_scheduler{}) | ex::bulk(n, [&](int i) {
-            ++v[i];
-            HPX_TEST_NEQ(parent_id, hpx::this_thread::get_id());
-        }) | tt::sync_wait();
-#endif
 
         for (int i = 0; i < n; ++i)
         {
@@ -1973,23 +1623,12 @@ void test_bulk()
         std::vector<int> v(n, -1);
         hpx::thread::id parent_id = hpx::this_thread::get_id();
 
-#if defined(HPX_HAVE_STDEXEC)
         auto v_out = hpx::get<0>(*(tt::sync_wait(
             ex::transfer_just(ex::thread_pool_scheduler{}, std::move(v)) |
             ex::bulk(n, [&parent_id](int i, std::vector<int>& v) {
                 v[i] = i;
                 HPX_TEST_NEQ(parent_id, hpx::this_thread::get_id());
             }))));
-#else
-        auto v_out = hpx::get<0>(
-            *(ex::transfer_just(ex::thread_pool_scheduler{}, std::move(v)) |
-                ex::bulk(n,
-                    [&parent_id](int i, std::vector<int>& v) {
-                        v[i] = i;
-                        HPX_TEST_NEQ(parent_id, hpx::this_thread::get_id());
-                    }) |
-                tt::sync_wait()));
-#endif
 
         for (int i = 0; i < n; ++i)
         {
@@ -2003,21 +1642,11 @@ void test_bulk()
         std::vector<std::string> v_ref = v;
 
         hpx::mutex mtx;
-#if defined(HPX_HAVE_STDEXEC)
         tt::sync_wait(ex::schedule(ex::thread_pool_scheduler{}) |
             ex::bulk(std::move(v), [&](std::string const& s) {
                 std::lock_guard lk(mtx);
                 string_map.insert(s);
             }));
-#else
-        ex::schedule(ex::thread_pool_scheduler{}) |
-            ex::bulk(std::move(v),
-                [&](std::string const& s) {
-                    std::lock_guard lk(mtx);
-                    string_map.insert(s);
-                }) |
-            tt::sync_wait();
-#endif
 
         for (auto const& s : v_ref)
         {
@@ -2034,7 +1663,6 @@ void test_bulk()
 
         try
         {
-#if defined(HPX_HAVE_STDEXEC)
             tt::sync_wait(ex::transfer_just(ex::thread_pool_scheduler{}) |
                 ex::bulk(n, [&v, i_fail](int i) {
                     if (i == i_fail)
@@ -2043,19 +1671,6 @@ void test_bulk()
                     }
                     v[i] = i;
                 }));
-#else
-            ex::transfer_just(ex::thread_pool_scheduler{}) |
-                ex::bulk(n,
-                    [&v, i_fail](int i) {
-                        if (i == i_fail)
-                        {
-                            throw std::runtime_error("error");
-                        }
-                        v[i] = i;
-                    }) |
-                tt::sync_wait();
-
-#endif
 
             if (expect_exception)
             {
@@ -2092,13 +1707,7 @@ void test_completion_scheduler()
     {
         auto sender = ex::schedule(ex::thread_pool_scheduler{});
         auto completion_scheduler =
-            ex::get_completion_scheduler<ex::set_value_t>(
-#if defined(HPX_HAVE_STDEXEC)
-                ex::get_env(sender)
-#else
-                sender
-#endif
-            );
+            ex::get_completion_scheduler<ex::set_value_t>(ex::get_env(sender));
         static_assert(
             std::is_same_v<std::decay_t<decltype(completion_scheduler)>,
                 ex::thread_pool_scheduler>,
@@ -2112,13 +1721,7 @@ void test_completion_scheduler()
             ex::then(ex::schedule(ex::thread_pool_scheduler{}), []() {});
         using hpx::functional::tag_invoke;
         auto completion_scheduler =
-            ex::get_completion_scheduler<ex::set_value_t>(
-#if defined(HPX_HAVE_STDEXEC)
-                ex::get_env(sender)
-#else
-                sender
-#endif
-            );
+            ex::get_completion_scheduler<ex::set_value_t>(ex::get_env(sender));
         static_assert(
             std::is_same_v<std::decay_t<decltype(completion_scheduler)>,
                 ex::thread_pool_scheduler>,
@@ -2128,13 +1731,7 @@ void test_completion_scheduler()
     {
         auto sender = ex::transfer_just(ex::thread_pool_scheduler{}, 42);
         auto completion_scheduler =
-            ex::get_completion_scheduler<ex::set_value_t>(
-#if defined(HPX_HAVE_STDEXEC)
-                ex::get_env(sender)
-#else
-                sender
-#endif
-            );
+            ex::get_completion_scheduler<ex::set_value_t>(ex::get_env(sender));
         static_assert(
             std::is_same_v<std::decay_t<decltype(completion_scheduler)>,
                 ex::thread_pool_scheduler>,
@@ -2145,13 +1742,7 @@ void test_completion_scheduler()
         auto sender =
             ex::bulk(ex::schedule(ex::thread_pool_scheduler{}), 10, [](int) {});
         auto completion_scheduler =
-            ex::get_completion_scheduler<ex::set_value_t>(
-#if defined(HPX_HAVE_STDEXEC)
-                ex::get_env(sender)
-#else
-                sender
-#endif
-            );
+            ex::get_completion_scheduler<ex::set_value_t>(ex::get_env(sender));
         static_assert(
             std::is_same_v<std::decay_t<decltype(completion_scheduler)>,
                 ex::thread_pool_scheduler>,
@@ -2164,13 +1755,7 @@ void test_completion_scheduler()
                 [](int, int) {}),
             [](int) {});
         auto completion_scheduler =
-            ex::get_completion_scheduler<ex::set_value_t>(
-#if defined(HPX_HAVE_STDEXEC)
-                ex::get_env(sender)
-#else
-                sender
-#endif
-            );
+            ex::get_completion_scheduler<ex::set_value_t>(ex::get_env(sender));
         static_assert(
             std::is_same_v<std::decay_t<decltype(completion_scheduler)>,
                 ex::thread_pool_scheduler>,
@@ -2183,13 +1768,7 @@ void test_completion_scheduler()
                 ex::transfer_just(ex::thread_pool_scheduler{}, 42), [](int) {}),
             10, [](int, int) {});
         auto completion_scheduler =
-            ex::get_completion_scheduler<ex::set_value_t>(
-#if defined(HPX_HAVE_STDEXEC)
-                ex::get_env(sender)
-#else
-                sender
-#endif
-            );
+            ex::get_completion_scheduler<ex::set_value_t>(ex::get_env(sender));
         static_assert(
             std::is_same_v<std::decay_t<decltype(completion_scheduler)>,
                 ex::thread_pool_scheduler>,
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 0715f239a8b5..bdcd3978d50b 100644
--- a/libs/core/synchronization/include/hpx/synchronization/async_rw_mutex.hpp
+++ b/libs/core/synchronization/include/hpx/synchronization/async_rw_mutex.hpp
@@ -438,7 +438,6 @@ namespace hpx::experimental {
             using access_type =
                 detail::async_rw_mutex_access_wrapper<readwrite_type, read_type,
                     AccessType>;
-#if defined(HPX_HAVE_STDEXEC)
             using sender_concept = hpx::execution::experimental::sender_t;
 
             template <typename Env>
@@ -449,25 +448,6 @@ namespace hpx::experimental {
                     hpx::execution::experimental::set_value_t(access_type),
                     hpx::execution::experimental::set_error_t(
                         std::exception_ptr)>;
-#else
-            template <typename Env>
-            struct generate_completion_signatures
-            {
-                template <template <typename...> typename Tuple,
-                    template <typename...> typename Variant>
-                using value_types = Variant<Tuple<access_type>>;
-
-                template <template <typename...> typename Variant>
-                using error_types = Variant<std::exception_ptr>;
-
-                static constexpr bool sends_stopped = false;
-            };
-
-            template <typename Env>
-            friend auto tag_invoke(
-                hpx::execution::experimental::get_completion_signatures_t,
-                sender const&, Env) -> generate_completion_signatures<Env>;
-#endif
 
             template <typename R>
             struct operation_state
@@ -653,7 +633,6 @@ namespace hpx::experimental {
                 detail::async_rw_mutex_access_wrapper<readwrite_type, read_type,
                     AccessType>;
 
-#if defined(HPX_HAVE_STDEXEC)
             using sender_concept = hpx::execution::experimental::sender_t;
 
             template <typename Env>
@@ -664,25 +643,6 @@ namespace hpx::experimental {
                     hpx::execution::experimental::set_value_t(access_type),
                     hpx::execution::experimental::set_error_t(
                         std::exception_ptr)>;
-#else
-            template <typename Env>
-            struct generate_completion_signatures
-            {
-                template <template <typename...> typename Tuple,
-                    template <typename...> typename Variant>
-                using value_types = Variant<Tuple<access_type>>;
-
-                template <template <typename...> typename Variant>
-                using error_types = Variant<std::exception_ptr>;
-
-                static constexpr bool sends_stopped = false;
-            };
-
-            template <typename Env>
-            friend auto tag_invoke(
-                hpx::execution::experimental::get_completion_signatures_t,
-                sender const&, Env) -> generate_completion_signatures<Env>;
-#endif
 
             template <typename R>
             struct operation_state
diff --git a/libs/core/synchronization/tests/unit/async_rw_mutex.cpp b/libs/core/synchronization/tests/unit/async_rw_mutex.cpp
index 2d0f61fbba86..f59194a9caf7 100644
--- a/libs/core/synchronization/tests/unit/async_rw_mutex.cpp
+++ b/libs/core/synchronization/tests/unit/async_rw_mutex.cpp
@@ -158,18 +158,12 @@ void submit_senders(Executor&& exec, Senders& senders)
 {
     for (auto& sender : senders)
     {
-// Original code uses sync_wait inside an hpx scheduler. Sync_wait completely
-// blocks the thread with std synchronization primitives which causes it to hang
-#if defined(HPX_HAVE_STDEXEC)
+        // Original code uses sync_wait inside an hpx scheduler. Sync_wait completely
+        // blocks the thread with std synchronization primitives which causes it to hang
         hpx::execution::experimental::start_detached(
             hpx::execution::experimental::schedule(exec) |
             hpx::execution::experimental::let_value(
                 [s = std::move(sender)]() mutable { return std::move(s); }));
-#else
-        execute(exec, [sender = std::move(sender)]() mutable {
-            sync_wait(std::move(sender));
-        });
-#endif
     }
 }