diff --git a/include/hibf/contrib/std/all_view.hpp b/include/hibf/contrib/std/all_view.hpp
index fee45f49..db31a8d6 100644
--- a/include/hibf/contrib/std/all_view.hpp
+++ b/include/hibf/contrib/std/all_view.hpp
@@ -7,7 +7,7 @@
 
 /*!\file
  * \author Enrico Seiler <enrico.seiler AT fu-berlin.de>
- * \brief Provides seqan::std::views::{all, all_t}, and seqan::std::ranges::owning_view.
+ * \brief Provides seqan::stl::views::{all, all_t}, and seqan::stl::ranges::owning_view.
  */
 
 // File might be included from multiple libraries.
@@ -18,33 +18,33 @@
 
 #if __cpp_lib_ranges >= 202110L
 
-namespace seqan::std::ranges
+namespace seqan::stl::ranges
 {
 
 using ::std::ranges::owning_view;
 
-} // namespace seqan::std::ranges
+} // namespace seqan::stl::ranges
 
-namespace seqan::std::views
+namespace seqan::stl::views
 {
 
 using ::std::ranges::views::all;
 using ::std::ranges::views::all_t;
 
-} // namespace seqan::std::views
+} // namespace seqan::stl::views
 #else
 #    include "concepts.hpp"
 #    include "detail/adaptor_base.hpp"
 #    include "detail/exposition_only.hpp"
 
-namespace seqan::std::ranges
+namespace seqan::stl::ranges
 {
 
 /*!\brief A move-only view that takes unique ownership of a range.
  * \sa https://en.cppreference.com/w/cpp/ranges/owning_view
  */
 template <::std::ranges::range rng_t>
-    requires ::std::movable<rng_t> && (!seqan::std::detail::is_initializer_list<::std::remove_cvref_t<rng_t>>)
+    requires ::std::movable<rng_t> && (!seqan::stl::detail::is_initializer_list<::std::remove_cvref_t<rng_t>>)
 class owning_view : public ::std::ranges::view_interface<owning_view<rng_t>>
 {
 private:
@@ -158,13 +158,13 @@ class owning_view : public ::std::ranges::view_interface<owning_view<rng_t>>
     }
 };
 
-/*!\brief The functor for seqan::std::views::all.
+/*!\brief The functor for seqan::stl::views::all.
  */
-class all_fn : public seqan::std::detail::adaptor_base<all_fn>
+class all_fn : public seqan::stl::detail::adaptor_base<all_fn>
 {
 private:
     //!\brief Befriend the base class.
-    friend seqan::std::detail::adaptor_base<all_fn>;
+    friend seqan::stl::detail::adaptor_base<all_fn>;
 
     //!\brief Checks whether a type is a view.
     template <typename t>
@@ -179,7 +179,7 @@ class all_fn : public seqan::std::detail::adaptor_base<all_fn>
     static constexpr bool valid_for_owning_view = requires { owning_view(::std::declval<t>()); };
 
 public:
-    using seqan::std::detail::adaptor_base<all_fn>::adaptor_base;
+    using seqan::stl::detail::adaptor_base<all_fn>::adaptor_base;
 
     /*!\brief Returns a view that includes all elements of the range argument.
      * \sa https://en.cppreference.com/w/cpp/ranges/all_view
@@ -191,7 +191,7 @@ class all_fn : public seqan::std::detail::adaptor_base<all_fn>
      *   * A ::std::ranges::ref_view of `rng` if that expression is valid.
      *   * Otherwise, a seqan3::detail::owning_view of `rng`.
      */
-    template <seqan::std::ranges::viewable_range rng_t>
+    template <seqan::stl::ranges::viewable_range rng_t>
         requires decays_to_view<rng_t> || valid_for_ref_view<rng_t> || valid_for_owning_view<rng_t>
     static auto impl(rng_t && rng)
     {
@@ -204,21 +204,21 @@ class all_fn : public seqan::std::detail::adaptor_base<all_fn>
     }
 };
 
-} // namespace seqan::std::ranges
+} // namespace seqan::stl::ranges
 
-namespace seqan::std::views
+namespace seqan::stl::views
 {
 
 /*!\copydoc all_fn::impl
  */
-inline constexpr auto all = seqan::std::ranges::all_fn{};
+inline constexpr auto all = seqan::stl::ranges::all_fn{};
 
 /*!\brief Returns the type that results from appying seqan3::detail::all to a range.
  */
-template <seqan::std::ranges::viewable_range rng_t>
+template <seqan::stl::ranges::viewable_range rng_t>
 using all_t = decltype(all(::std::declval<rng_t>()));
 
-} // namespace seqan::std::views
+} // namespace seqan::stl::views
 
 #endif // __cpp_lib_ranges >= 202110L
 
diff --git a/include/hibf/contrib/std/chunk_view.hpp b/include/hibf/contrib/std/chunk_view.hpp
index 82f089e4..8657d41c 100644
--- a/include/hibf/contrib/std/chunk_view.hpp
+++ b/include/hibf/contrib/std/chunk_view.hpp
@@ -7,7 +7,7 @@
 
 /*!\file
  * \author Enrico Seiler <enrico.seiler AT fu-berlin.de>
- * \brief Provides seqan::std::views::chunk.
+ * \brief Provides seqan::stl::views::chunk.
  */
 
 // File might be included from multiple libraries.
@@ -18,12 +18,12 @@
 
 #ifdef __cpp_lib_ranges_chunk
 
-namespace seqan::std::views
+namespace seqan::stl::views
 {
 
 using ::std::ranges::views::chunk;
 
-} // namespace seqan::std::views
+} // namespace seqan::stl::views
 
 #else
 
@@ -37,7 +37,7 @@ using ::std::ranges::views::chunk;
 #    include "detail/exposition_only.hpp"
 #    include "detail/non_propagating_cache.hpp"
 
-namespace seqan::std::detail::chunk
+namespace seqan::stl::detail::chunk
 {
 
 template <class I>
@@ -55,9 +55,9 @@ constexpr auto to_unsigned_like(T v) noexcept
     return static_cast<::std::make_unsigned_t<T>>(v);
 }
 
-} // namespace seqan::std::detail::chunk
+} // namespace seqan::stl::detail::chunk
 
-namespace seqan::std::ranges
+namespace seqan::stl::ranges
 {
 
 template <::std::ranges::view V>
@@ -74,7 +74,7 @@ SEQAN_STD_NESTED_VISIBILITY
     ::std::ranges::range_difference_t<V> n_;
     ::std::ranges::range_difference_t<V> remainder_ = 0;
 
-    seqan::std::detail::non_propagating_cache<::std::ranges::iterator_t<V>> current_;
+    seqan::stl::detail::non_propagating_cache<::std::ranges::iterator_t<V>> current_;
 
 private:
     class outer_iterator;
@@ -115,19 +115,19 @@ SEQAN_STD_NESTED_VISIBILITY
     constexpr auto size()
         requires ::std::ranges::sized_range<V>
     {
-        return seqan::std::detail::chunk::to_unsigned_like(
-            seqan::std::detail::chunk::div_ceil(::std::ranges::distance(base_), n_));
+        return seqan::stl::detail::chunk::to_unsigned_like(
+            seqan::stl::detail::chunk::div_ceil(::std::ranges::distance(base_), n_));
     }
     constexpr auto size() const
         requires ::std::ranges::sized_range<V const>
     {
-        return seqan::std::detail::chunk::to_unsigned_like(
-            seqan::std::detail::chunk::div_ceil(::std::ranges::distance(base_), n_));
+        return seqan::stl::detail::chunk::to_unsigned_like(
+            seqan::stl::detail::chunk::div_ceil(::std::ranges::distance(base_), n_));
     }
 };
 
 template <class R>
-chunk_view(R &&, ::std::ranges::range_difference_t<R>) -> chunk_view<seqan::std::views::all_t<R>>;
+chunk_view(R &&, ::std::ranges::range_difference_t<R>) -> chunk_view<seqan::stl::views::all_t<R>>;
 
 template <::std::ranges::view V>
     requires ::std::ranges::input_range<V>
@@ -180,7 +180,7 @@ class chunk_view<V>::outer_iterator
         {
             return dist == 0 ? 0 : 1;
         }
-        return seqan::std::detail::chunk::div_ceil(dist - x.parent_->remainder_, x.parent_->n_) + 1;
+        return seqan::stl::detail::chunk::div_ceil(dist - x.parent_->remainder_, x.parent_->n_) + 1;
     }
     friend constexpr difference_type operator-(outer_iterator const & x, ::std::default_sentinel_t y)
         requires ::std::sized_sentinel_for<::std::ranges::sentinel_t<V>, ::std::ranges::iterator_t<V>>
@@ -214,7 +214,7 @@ struct chunk_view<V>::outer_iterator::value_type : ::std::ranges::view_interface
     constexpr auto size() const
         requires ::std::sized_sentinel_for<::std::ranges::sentinel_t<V>, ::std::ranges::iterator_t<V>>
     {
-        return seqan::std::detail::chunk::to_unsigned_like(
+        return seqan::stl::detail::chunk::to_unsigned_like(
             ::std::ranges::min(parent_->remainder_, ::std::ranges::end(parent_->base_) - *parent_->current_));
     }
 };
@@ -326,7 +326,7 @@ class chunk_view<V> : public ::std::ranges::view_interface<chunk_view<V>>
     }
 
     constexpr auto begin()
-        requires (!seqan::std::detail::simple_view<V>)
+        requires (!seqan::stl::detail::simple_view<V>)
     {
         return iterator<false>{this, ::std::ranges::begin(base_)};
     }
@@ -338,7 +338,7 @@ class chunk_view<V> : public ::std::ranges::view_interface<chunk_view<V>>
     }
 
     constexpr auto end()
-        requires (!seqan::std::detail::simple_view<V>)
+        requires (!seqan::stl::detail::simple_view<V>)
     {
         if constexpr (::std::ranges::common_range<V> && ::std::ranges::sized_range<V>)
         {
@@ -376,14 +376,14 @@ class chunk_view<V> : public ::std::ranges::view_interface<chunk_view<V>>
     constexpr auto size()
         requires ::std::ranges::sized_range<V>
     {
-        return seqan::std::detail::chunk::to_unsigned_like(
-            seqan::std::detail::chunk::div_ceil(::std::ranges::distance(base_), n_));
+        return seqan::stl::detail::chunk::to_unsigned_like(
+            seqan::stl::detail::chunk::div_ceil(::std::ranges::distance(base_), n_));
     }
     constexpr auto size() const
         requires ::std::ranges::sized_range<V const>
     {
-        return seqan::std::detail::chunk::to_unsigned_like(
-            seqan::std::detail::chunk::div_ceil(::std::ranges::distance(base_), n_));
+        return seqan::stl::detail::chunk::to_unsigned_like(
+            seqan::stl::detail::chunk::div_ceil(::std::ranges::distance(base_), n_));
     }
 };
 
@@ -393,8 +393,8 @@ template <bool Const>
 class chunk_view<V>::iterator
 {
 private:
-    using Parent = seqan::std::detail::maybe_const<Const, chunk_view>;
-    using Base = seqan::std::detail::maybe_const<Const, V>;
+    using Parent = seqan::stl::detail::maybe_const<Const, chunk_view>;
+    using Base = seqan::stl::detail::maybe_const<Const, V>;
 
     ::std::ranges::iterator_t<Base> current_ = ::std::ranges::iterator_t<Base>{};
     ::std::ranges::sentinel_t<Base> end_ = ::std::ranges::sentinel_t<Base>{};
@@ -575,7 +575,7 @@ class chunk_view<V>::iterator
     friend constexpr difference_type operator-(::std::default_sentinel_t y, iterator const & x)
         requires ::std::sized_sentinel_for<::std::ranges::sentinel_t<Base>, ::std::ranges::iterator_t<Base>>
     {
-        return seqan::std::detail::chunk::div_ceil(x.end_ - x.current_, x.n_);
+        return seqan::stl::detail::chunk::div_ceil(x.end_ - x.current_, x.n_);
     }
 
     friend constexpr difference_type operator-(iterator const & x, ::std::default_sentinel_t y)
@@ -590,24 +590,24 @@ struct chunk_fn
     template <typename Difference>
     constexpr auto operator()(Difference n) const
     {
-        return seqan::std::detail::adaptor_from_functor{*this, n};
+        return seqan::stl::detail::adaptor_from_functor{*this, n};
     }
 
-    template <seqan::std::ranges::viewable_range Range, typename Difference = ::std::ranges::range_difference_t<Range>>
+    template <seqan::stl::ranges::viewable_range Range, typename Difference = ::std::ranges::range_difference_t<Range>>
     constexpr auto operator()(Range && range, ::std::type_identity_t<Difference> n) const
     {
         return chunk_view{::std::forward<Range>(range), n};
     }
 };
 
-} // namespace seqan::std::ranges
+} // namespace seqan::stl::ranges
 
-namespace seqan::std::views
+namespace seqan::stl::views
 {
 
-inline constexpr auto chunk = seqan::std::ranges::chunk_fn{};
+inline constexpr auto chunk = seqan::stl::ranges::chunk_fn{};
 
-} // namespace seqan::std::views
+} // namespace seqan::stl::views
 
 #endif // ifdef __cpp_lib_ranges_chunk
 
diff --git a/include/hibf/contrib/std/concepts.hpp b/include/hibf/contrib/std/concepts.hpp
index c2456221..aed5614e 100644
--- a/include/hibf/contrib/std/concepts.hpp
+++ b/include/hibf/contrib/std/concepts.hpp
@@ -7,7 +7,7 @@
 
 /*!\file
  * \author Enrico Seiler <enrico.seiler AT fu-berlin.de>
- * \brief Provides seqan::std concepts.
+ * \brief Provides seqan::stl concepts.
  */
 
 // File might be included from multiple libraries.
@@ -17,7 +17,7 @@
 #include <ranges>
 
 #if __cpp_lib_ranges >= 202110L
-namespace seqan::std::ranges
+namespace seqan::stl::ranges
 {
 
 using ::std::ranges::viewable_range;
@@ -25,7 +25,7 @@ using ::std::ranges::viewable_range;
 }
 #else
 #    include "detail/exposition_only.hpp"
-namespace seqan::std::ranges
+namespace seqan::stl::ranges
 {
 
 template <class T>
@@ -35,9 +35,9 @@ concept viewable_range = ::std::ranges::range<T>
                           || (!::std::ranges::view<::std::remove_cvref_t<T>>
                               && (::std::is_lvalue_reference_v<T>
                                   || (::std::movable<::std::remove_reference_t<T>>
-                                      && !seqan::std::detail::is_initializer_list<::std::remove_cvref_t<T>>))));
+                                      && !seqan::stl::detail::is_initializer_list<::std::remove_cvref_t<T>>))));
 
-} // namespace seqan::std::ranges
+} // namespace seqan::stl::ranges
 
 #endif
 
diff --git a/include/hibf/contrib/std/detail/adaptor_base.hpp b/include/hibf/contrib/std/detail/adaptor_base.hpp
index b80f6f59..b790e29f 100644
--- a/include/hibf/contrib/std/detail/adaptor_base.hpp
+++ b/include/hibf/contrib/std/detail/adaptor_base.hpp
@@ -6,7 +6,7 @@
 // -----------------------------------------------------------------------------------------------------
 
 /*!\file
- * \brief Provides seqan::std::detail::adaptor_base and seqan::std::detail::combined_adaptor
+ * \brief Provides seqan::stl::detail::adaptor_base and seqan::stl::detail::combined_adaptor
  * \author Hannes Hauswedell <hannes.hauswedell AT fu-berlin.de>
  */
 
@@ -17,7 +17,7 @@
 #include <ranges>
 #include <tuple>
 
-namespace seqan::std::detail
+namespace seqan::stl::detail
 {
 
 // ============================================================================
@@ -210,6 +210,6 @@ class combined_adaptor :
     //!\}
 };
 
-} // namespace seqan::std::detail
+} // namespace seqan::stl::detail
 
 #endif // SEQAN_STD_DETAIL_ADAPTOR_BASE
diff --git a/include/hibf/contrib/std/detail/adaptor_for_view_without_args.hpp b/include/hibf/contrib/std/detail/adaptor_for_view_without_args.hpp
index 61ee565e..7a73fe34 100644
--- a/include/hibf/contrib/std/detail/adaptor_for_view_without_args.hpp
+++ b/include/hibf/contrib/std/detail/adaptor_for_view_without_args.hpp
@@ -6,7 +6,7 @@
 // -----------------------------------------------------------------------------------------------------
 
 /*!\file
- * \brief Provides seqan::std::detail::adaptor_for_view_without_args
+ * \brief Provides seqan::stl::detail::adaptor_for_view_without_args
  * \author Hannes Hauswedell <hannes.hauswedell AT fu-berlin.de>
  */
 
@@ -16,7 +16,7 @@
 
 #include "adaptor_base.hpp"
 
-namespace seqan::std::detail
+namespace seqan::stl::detail
 {
 
 // ============================================================================
@@ -68,6 +68,6 @@ class adaptor_for_view_without_args : public adaptor_base<adaptor_for_view_witho
     //!\}
 };
 
-} // namespace seqan::std::detail
+} // namespace seqan::stl::detail
 
 #endif // SEQAN_STD_DETAIL_ADAPTOR_FOR_VIEW_WITHOUT_ARGS
diff --git a/include/hibf/contrib/std/detail/adaptor_from_functor.hpp b/include/hibf/contrib/std/detail/adaptor_from_functor.hpp
index 89d0b31d..ad6727f4 100644
--- a/include/hibf/contrib/std/detail/adaptor_from_functor.hpp
+++ b/include/hibf/contrib/std/detail/adaptor_from_functor.hpp
@@ -6,7 +6,7 @@
 // -----------------------------------------------------------------------------------------------------
 
 /*!\file
- * \brief Provides seqan::std::detail::adaptor_from_functor
+ * \brief Provides seqan::stl::detail::adaptor_from_functor
  * \author Hannes Hauswedell <hannes.hauswedell AT fu-berlin.de>
  */
 
@@ -16,7 +16,7 @@
 
 #include "adaptor_base.hpp"
 
-namespace seqan::std::detail
+namespace seqan::stl::detail
 {
 
 // ============================================================================
@@ -70,6 +70,6 @@ class adaptor_from_functor :
     //!\}
 };
 
-} // namespace seqan::std::detail
+} // namespace seqan::stl::detail
 
 #endif // SEQAN_STD_DETAIL_ADAPTOR_FROM_FUNCTOR
diff --git a/include/hibf/contrib/std/detail/compiler_definitions.hpp b/include/hibf/contrib/std/detail/compiler_definitions.hpp
index 39aa7877..417205b8 100644
--- a/include/hibf/contrib/std/detail/compiler_definitions.hpp
+++ b/include/hibf/contrib/std/detail/compiler_definitions.hpp
@@ -7,7 +7,7 @@
 
 /*!\file
  * \author Enrico Seiler <enrico.seiler AT fu-berlin.de>
- * \brief Provides compiler definitions for seqan::std.
+ * \brief Provides compiler definitions for seqan::stl.
  */
 
 // File might be included from multiple libraries.
diff --git a/include/hibf/contrib/std/detail/exposition_only.hpp b/include/hibf/contrib/std/detail/exposition_only.hpp
index 1ff1584a..4dbf6156 100644
--- a/include/hibf/contrib/std/detail/exposition_only.hpp
+++ b/include/hibf/contrib/std/detail/exposition_only.hpp
@@ -7,7 +7,7 @@
 
 /*!\file
  * \author Enrico Seiler <enrico.seiler AT fu-berlin.de>
- * \brief Provides seqan::std::detail implementation helper that are used in multiple files.
+ * \brief Provides seqan::stl::detail implementation helper that are used in multiple files.
  */
 
 // File might be included from multiple libraries.
@@ -16,7 +16,7 @@
 
 #include <ranges>
 
-namespace seqan::std::detail
+namespace seqan::stl::detail
 {
 
 template <typename T>
@@ -33,6 +33,6 @@ concept simple_view = ::std::ranges::view<range_t> && ::std::ranges::range<range
 template <bool is_const, typename t>
 using maybe_const = ::std::conditional_t<is_const, t const, t>;
 
-} // namespace seqan::std::detail
+} // namespace seqan::stl::detail
 
 #endif // SEQAN_STD_DETAIL_EXPOSITION_ONLY
diff --git a/include/hibf/contrib/std/detail/non_propagating_cache.hpp b/include/hibf/contrib/std/detail/non_propagating_cache.hpp
index 424dac38..6965fb6c 100644
--- a/include/hibf/contrib/std/detail/non_propagating_cache.hpp
+++ b/include/hibf/contrib/std/detail/non_propagating_cache.hpp
@@ -7,7 +7,7 @@
 
 /*!\file
  * \author Enrico Seiler <enrico.seiler AT fu-berlin.de>
- * \brief Provides [seqan::std::detail::non_propagating_cache](https://eel.is/c++draft/range.nonprop.cache).
+ * \brief Provides [seqan::stl::detail::non_propagating_cache](https://eel.is/c++draft/range.nonprop.cache).
  */
 
 // File might be included from multiple libraries.
@@ -16,7 +16,7 @@
 
 #include <optional>
 
-namespace seqan::std::detail
+namespace seqan::stl::detail
 {
 
 /*!\brief A helper that enables an input view to temporarily cache values as it is iterated over.
@@ -78,6 +78,6 @@ class non_propagating_cache : public ::std::optional<T>
     }
 };
 
-} // namespace seqan::std::detail
+} // namespace seqan::stl::detail
 
 #endif // SEQAN_STD_DETAIL_NON_PROPAGATING_CACHE
diff --git a/include/hibf/contrib/std/join_with_view.hpp b/include/hibf/contrib/std/join_with_view.hpp
index 25825cdd..c2a6ca4d 100644
--- a/include/hibf/contrib/std/join_with_view.hpp
+++ b/include/hibf/contrib/std/join_with_view.hpp
@@ -7,7 +7,7 @@
 
 /*!\file
  * \author Enrico Seiler <enrico.seiler AT fu-berlin.de>
- * \brief Provides seqan::std::views::join_with.
+ * \brief Provides seqan::stl::views::join_with.
  */
 
 // File might be included from multiple libraries.
@@ -18,12 +18,12 @@
 
 #ifdef __cpp_lib_ranges_join_with
 
-namespace seqan::std::views
+namespace seqan::stl::views
 {
 
 using ::std::ranges::views::join_with;
 
-} // namespace seqan::std::views
+} // namespace seqan::stl::views
 
 #else
 
@@ -36,7 +36,7 @@ using ::std::ranges::views::join_with;
 #    include "detail/exposition_only.hpp"
 #    include "detail/non_propagating_cache.hpp"
 
-namespace seqan::std::detail::join_with
+namespace seqan::stl::detail::join_with
 {
 
 template <class R, class P>
@@ -68,18 +68,18 @@ struct cache_helper<InnerRng>
     non_propagating_cache<::std::remove_cv_t<InnerRng>> inner_;
 };
 
-} // namespace seqan::std::detail::join_with
+} // namespace seqan::stl::detail::join_with
 
-namespace seqan::std::ranges
+namespace seqan::stl::ranges
 {
 
 template <::std::ranges::input_range V, ::std::ranges::forward_range Pattern>
     requires ::std::ranges::view<V> && ::std::ranges::input_range<::std::ranges::range_reference_t<V>>
               && ::std::ranges::view<Pattern>
-              && seqan::std::detail::join_with::compatible_joinable_ranges<::std::ranges::range_reference_t<V>, Pattern>
+              && seqan::stl::detail::join_with::compatible_joinable_ranges<::std::ranges::range_reference_t<V>, Pattern>
 class join_with_view :
     public ::std::ranges::view_interface<join_with_view<V, Pattern>>,
-    private seqan::std::detail::join_with::cache_helper<::std::ranges::range_reference_t<V>>
+    private seqan::stl::detail::join_with::cache_helper<::std::ranges::range_reference_t<V>>
 {
 private:
     using InnerRng = ::std::ranges::range_reference_t<V>;
@@ -128,8 +128,8 @@ class join_with_view :
         // the sentinels of the non-const view and const range are the same.
         // If ::std::is_reference_v<InnerRng>, we do not have a cache to store the value. Hence, we do not change
         // any members and can use the const iterator.
-        constexpr bool use_const = seqan::std::detail::simple_view<V> && ::std::is_reference_v<InnerRng>
-                                && seqan::std::detail::simple_view<Pattern>;
+        constexpr bool use_const = seqan::stl::detail::simple_view<V> && ::std::is_reference_v<InnerRng>
+                                && seqan::stl::detail::simple_view<Pattern>;
         return iterator<use_const>{*this, ::std::ranges::begin(base_)};
     }
 
@@ -142,7 +142,7 @@ class join_with_view :
 
     constexpr auto end()
     {
-        constexpr bool is_simple = seqan::std::detail::simple_view<V> && seqan::std::detail::simple_view<Pattern>;
+        constexpr bool is_simple = seqan::stl::detail::simple_view<V> && seqan::stl::detail::simple_view<Pattern>;
         if constexpr (::std::ranges::forward_range<V> && ::std::is_reference_v<InnerRng>
                       && ::std::ranges::forward_range<InnerRng> && ::std::ranges::common_range<V>
                       && ::std::ranges::common_range<InnerRng>)
@@ -165,25 +165,25 @@ class join_with_view :
 };
 
 template <class R, class P>
-join_with_view(R &&, P &&) -> join_with_view<seqan::std::views::all_t<R>, seqan::std::views::all_t<P>>;
+join_with_view(R &&, P &&) -> join_with_view<seqan::stl::views::all_t<R>, seqan::stl::views::all_t<P>>;
 
 template <::std::ranges::input_range R>
 join_with_view(R &&, ::std::ranges::range_value_t<::std::ranges::range_reference_t<R>>)
-    -> join_with_view<seqan::std::views::all_t<R>,
+    -> join_with_view<seqan::stl::views::all_t<R>,
                       ::std::ranges::single_view<::std::ranges::range_value_t<::std::ranges::range_reference_t<R>>>>;
 
-} // namespace seqan::std::ranges
+} // namespace seqan::stl::ranges
 
-namespace seqan::std::detail::join_with
+namespace seqan::stl::detail::join_with
 {
 
 template <bool Const, typename V, typename Pattern>
 struct helper
 {
-    using Parent = seqan::std::detail::maybe_const<Const, seqan::std::ranges::join_with_view<V, Pattern>>;
-    using Base = seqan::std::detail::maybe_const<Const, V>;
+    using Parent = seqan::stl::detail::maybe_const<Const, seqan::stl::ranges::join_with_view<V, Pattern>>;
+    using Base = seqan::stl::detail::maybe_const<Const, V>;
     using InnerBase = ::std::ranges::range_reference_t<Base>;
-    using PatternBase = seqan::std::detail::maybe_const<Const, Pattern>;
+    using PatternBase = seqan::stl::detail::maybe_const<Const, Pattern>;
 
     using OuterIter = ::std::ranges::iterator_t<Base>;
     using InnerIter = ::std::ranges::iterator_t<InnerBase>;
@@ -237,22 +237,22 @@ template <bool Const, typename V, typename Pattern>
 struct iterator_category_t<Const, V, Pattern, false>
 {};
 
-} // namespace seqan::std::detail::join_with
+} // namespace seqan::stl::detail::join_with
 
-namespace seqan::std::ranges
+namespace seqan::stl::ranges
 {
 
 template <::std::ranges::input_range V, ::std::ranges::forward_range Pattern>
     requires ::std::ranges::view<V> && ::std::ranges::input_range<::std::ranges::range_reference_t<V>>
           && ::std::ranges::view<Pattern>
-          && seqan::std::detail::join_with::compatible_joinable_ranges<::std::ranges::range_reference_t<V>, Pattern>
+          && seqan::stl::detail::join_with::compatible_joinable_ranges<::std::ranges::range_reference_t<V>, Pattern>
 template <bool Const>
 class join_with_view<V, Pattern>::iterator :
-    public seqan::std::detail::join_with::
-        iterator_category_t<Const, V, Pattern, seqan::std::detail::join_with::helper<Const, V, Pattern>::ref_is_glvalue>
+    public seqan::stl::detail::join_with::
+        iterator_category_t<Const, V, Pattern, seqan::stl::detail::join_with::helper<Const, V, Pattern>::ref_is_glvalue>
 {
 private:
-    using helper_t = seqan::std::detail::join_with::helper<Const, V, Pattern>;
+    using helper_t = seqan::stl::detail::join_with::helper<Const, V, Pattern>;
     using Parent = helper_t::Parent;
     using Base = helper_t::Base;
     using InnerBase = helper_t::InnerBase;
@@ -338,8 +338,8 @@ SEQAN_STD_NESTED_VISIBILITY
         !ref_is_glvalue,
         ::std::input_iterator_tag,
         ::std::conditional_t<
-            ::std::ranges::bidirectional_range<Base> && seqan::std::detail::join_with::bidirectional_common<InnerBase>
-                && seqan::std::detail::join_with::bidirectional_common<PatternBase>,
+            ::std::ranges::bidirectional_range<Base> && seqan::stl::detail::join_with::bidirectional_common<InnerBase>
+                && seqan::stl::detail::join_with::bidirectional_common<PatternBase>,
             ::std::bidirectional_iterator_tag,
             ::std::conditional_t<::std::ranges::forward_range<Base> && ::std::ranges::forward_range<InnerBase>,
                                  ::std::forward_iterator_tag,
@@ -405,8 +405,8 @@ SEQAN_STD_NESTED_VISIBILITY
 
     constexpr iterator & operator--()
         requires ref_is_glvalue && ::std::ranges::bidirectional_range<Base>
-              && seqan::std::detail::join_with::bidirectional_common<InnerBase>
-              && seqan::std::detail::join_with::bidirectional_common<PatternBase>
+              && seqan::stl::detail::join_with::bidirectional_common<InnerBase>
+              && seqan::stl::detail::join_with::bidirectional_common<PatternBase>
     {
         if (outer_it_ == ::std::ranges::end(parent_->base_))
         {
@@ -456,8 +456,8 @@ SEQAN_STD_NESTED_VISIBILITY
 
     constexpr iterator operator--(int)
         requires ref_is_glvalue && ::std::ranges::bidirectional_range<Base>
-              && seqan::std::detail::join_with::bidirectional_common<InnerBase>
-              && seqan::std::detail::join_with::bidirectional_common<PatternBase>
+              && seqan::stl::detail::join_with::bidirectional_common<InnerBase>
+              && seqan::stl::detail::join_with::bidirectional_common<PatternBase>
     {
         iterator tmp = *this;
         --*this;
@@ -487,13 +487,13 @@ SEQAN_STD_NESTED_VISIBILITY
 template <::std::ranges::input_range V, ::std::ranges::forward_range Pattern>
     requires ::std::ranges::view<V> && ::std::ranges::input_range<::std::ranges::range_reference_t<V>>
           && ::std::ranges::view<Pattern>
-          && seqan::std::detail::join_with::compatible_joinable_ranges<::std::ranges::range_reference_t<V>, Pattern>
+          && seqan::stl::detail::join_with::compatible_joinable_ranges<::std::ranges::range_reference_t<V>, Pattern>
 template <bool Const>
 class join_with_view<V, Pattern>::sentinel
 {
 private:
-    using Parent = seqan::std::detail::maybe_const<Const, join_with_view>;
-    using Base = seqan::std::detail::maybe_const<Const, V>;
+    using Parent = seqan::stl::detail::maybe_const<Const, join_with_view>;
+    using Base = seqan::stl::detail::maybe_const<Const, V>;
     ::std::ranges::sentinel_t<Base> end_ = ::std::ranges::sentinel_t<Base>();
 
     friend class join_with_view<V, Pattern>;
@@ -510,7 +510,7 @@ class join_with_view<V, Pattern>::sentinel
 
     template <bool OtherConst>
         requires ::std::sentinel_for<::std::ranges::sentinel_t<Base>,
-                                     ::std::ranges::iterator_t<seqan::std::detail::maybe_const<OtherConst, V>>>
+                                     ::std::ranges::iterator_t<seqan::stl::detail::maybe_const<OtherConst, V>>>
     friend constexpr bool operator==(iterator<OtherConst> const & x, sentinel const & y)
     {
         return x.outer_it_ == y.end_;
@@ -522,24 +522,24 @@ struct join_with_fn
     template <typename Pattern>
     constexpr auto operator()(Pattern && pattern) const
     {
-        return seqan::std::detail::adaptor_from_functor{*this, ::std::forward<Pattern>(pattern)};
+        return seqan::stl::detail::adaptor_from_functor{*this, ::std::forward<Pattern>(pattern)};
     }
 
-    template <seqan::std::ranges::viewable_range urng_t, typename Pattern>
+    template <seqan::stl::ranges::viewable_range urng_t, typename Pattern>
     constexpr auto operator()(urng_t && urange, Pattern && pattern) const
     {
         return join_with_view{::std::forward<urng_t>(urange), ::std::forward<Pattern>(pattern)};
     }
 };
 
-} // namespace seqan::std::ranges
+} // namespace seqan::stl::ranges
 
-namespace seqan::std::views
+namespace seqan::stl::views
 {
 
-inline constexpr auto join_with = seqan::std::ranges::join_with_fn{};
+inline constexpr auto join_with = seqan::stl::ranges::join_with_fn{};
 
-} // namespace seqan::std::views
+} // namespace seqan::stl::views
 
 #endif // ifdef __cpp_lib_ranges_join_with
 
diff --git a/include/hibf/contrib/std/pair.hpp b/include/hibf/contrib/std/pair.hpp
index e6d66f13..6e7dc400 100644
--- a/include/hibf/contrib/std/pair.hpp
+++ b/include/hibf/contrib/std/pair.hpp
@@ -6,7 +6,7 @@
 // -----------------------------------------------------------------------------------------------------
 
 /*!\file
- * \brief Provides seqan::std::pair.
+ * \brief Provides seqan::stl::pair.
  * \author Enrico Seiler <enrico.seiler AT fu-berlin.de>
  */
 
@@ -17,16 +17,16 @@
 
 #ifdef __cpp_lib_tuple_like
 
-namespace seqan::std
+namespace seqan::stl
 {
 
 using ::std::pair;
 
-} // namespace seqan::std
+} // namespace seqan::stl
 
 #else
 
-namespace seqan::std
+namespace seqan::stl
 {
 
 template <class T1, class T2>
@@ -544,124 +544,124 @@ struct pair : public ::std::pair<T1, T2>
 template <class T1, class T2>
 pair(T1, T2) -> pair<T1, T2>;
 
-} // namespace seqan::std
+} // namespace seqan::stl
 
 namespace std
 {
 
 template <class T1, class T2>
-struct tuple_size<seqan::std::pair<T1, T2>> : public tuple_size<::std::pair<T1, T2>>
+struct tuple_size<seqan::stl::pair<T1, T2>> : public tuple_size<::std::pair<T1, T2>>
 {};
 
 template <size_t index, class T1, class T2>
-struct tuple_element<index, seqan::std::pair<T1, T2>> : public tuple_element<index, ::std::pair<T1, T2>>
+struct tuple_element<index, seqan::stl::pair<T1, T2>> : public tuple_element<index, ::std::pair<T1, T2>>
 {};
 
 template <class T1, class T2, class U1, class U2>
-    requires requires { typename seqan::std::pair<::std::common_type_t<T1, U1>, ::std::common_type_t<T2, U2>>; }
-struct common_type<seqan::std::pair<T1, T2>, seqan::std::pair<U1, U2>>
+    requires requires { typename seqan::stl::pair<::std::common_type_t<T1, U1>, ::std::common_type_t<T2, U2>>; }
+struct common_type<seqan::stl::pair<T1, T2>, seqan::stl::pair<U1, U2>>
 {
-    using type = seqan::std::pair<::std::common_type_t<T1, U1>, ::std::common_type_t<T2, U2>>;
+    using type = seqan::stl::pair<::std::common_type_t<T1, U1>, ::std::common_type_t<T2, U2>>;
 };
 
 template <class T1, class T2, class U1, class U2>
-    requires requires { typename seqan::std::pair<::std::common_type_t<T1, U1>, ::std::common_type_t<T2, U2>>; }
-struct common_type<::std::pair<T1, T2>, seqan::std::pair<U1, U2>>
+    requires requires { typename seqan::stl::pair<::std::common_type_t<T1, U1>, ::std::common_type_t<T2, U2>>; }
+struct common_type<::std::pair<T1, T2>, seqan::stl::pair<U1, U2>>
 {
-    using type = seqan::std::pair<::std::common_type_t<T1, U1>, ::std::common_type_t<T2, U2>>;
+    using type = seqan::stl::pair<::std::common_type_t<T1, U1>, ::std::common_type_t<T2, U2>>;
 };
 
 template <class T1, class T2, class U1, class U2>
-    requires requires { typename seqan::std::pair<::std::common_type_t<T1, U1>, ::std::common_type_t<T2, U2>>; }
-struct common_type<seqan::std::pair<T1, T2>, ::std::pair<U1, U2>>
+    requires requires { typename seqan::stl::pair<::std::common_type_t<T1, U1>, ::std::common_type_t<T2, U2>>; }
+struct common_type<seqan::stl::pair<T1, T2>, ::std::pair<U1, U2>>
 {
-    using type = seqan::std::pair<::std::common_type_t<T1, U1>, ::std::common_type_t<T2, U2>>;
+    using type = seqan::stl::pair<::std::common_type_t<T1, U1>, ::std::common_type_t<T2, U2>>;
 };
 
 template <class T1, class T2, class U1, class U2, template <class> class TQual, template <class> class UQual>
     requires requires {
-                 typename seqan::std::pair<::std::common_reference_t<TQual<T1>, UQual<U1>>,
+                 typename seqan::stl::pair<::std::common_reference_t<TQual<T1>, UQual<U1>>,
                                            ::std::common_reference_t<TQual<T2>, UQual<U2>>>;
              }
-struct basic_common_reference<seqan::std::pair<T1, T2>, seqan::std::pair<U1, U2>, TQual, UQual>
+struct basic_common_reference<seqan::stl::pair<T1, T2>, seqan::stl::pair<U1, U2>, TQual, UQual>
 {
-    using type = seqan::std::pair<::std::common_reference_t<TQual<T1>, UQual<U1>>,
+    using type = seqan::stl::pair<::std::common_reference_t<TQual<T1>, UQual<U1>>,
                                   ::std::common_reference_t<TQual<T2>, UQual<U2>>>;
 };
 
 template <class T1, class T2, class U1, class U2, template <class> class TQual, template <class> class UQual>
     requires requires {
-                 typename seqan::std::pair<::std::common_reference_t<TQual<T1>, UQual<U1>>,
+                 typename seqan::stl::pair<::std::common_reference_t<TQual<T1>, UQual<U1>>,
                                            ::std::common_reference_t<TQual<T2>, UQual<U2>>>;
              }
-struct basic_common_reference<::std::pair<T1, T2>, seqan::std::pair<U1, U2>, TQual, UQual>
+struct basic_common_reference<::std::pair<T1, T2>, seqan::stl::pair<U1, U2>, TQual, UQual>
 {
-    using type = seqan::std::pair<::std::common_reference_t<TQual<T1>, UQual<U1>>,
+    using type = seqan::stl::pair<::std::common_reference_t<TQual<T1>, UQual<U1>>,
                                   ::std::common_reference_t<TQual<T2>, UQual<U2>>>;
 };
 
 template <class T1, class T2, class U1, class U2, template <class> class TQual, template <class> class UQual>
     requires requires {
-                 typename seqan::std::pair<::std::common_reference_t<TQual<T1>, UQual<U1>>,
+                 typename seqan::stl::pair<::std::common_reference_t<TQual<T1>, UQual<U1>>,
                                            ::std::common_reference_t<TQual<T2>, UQual<U2>>>;
              }
-struct basic_common_reference<seqan::std::pair<T1, T2>, ::std::pair<U1, U2>, TQual, UQual>
+struct basic_common_reference<seqan::stl::pair<T1, T2>, ::std::pair<U1, U2>, TQual, UQual>
 {
-    using type = seqan::std::pair<::std::common_reference_t<TQual<T1>, UQual<U1>>,
+    using type = seqan::stl::pair<::std::common_reference_t<TQual<T1>, UQual<U1>>,
                                   ::std::common_reference_t<TQual<T2>, UQual<U2>>>;
 };
 
 template <::std::size_t i, class T1, class T2>
-constexpr ::std::tuple_element_t<i, seqan::std::pair<T1, T2>> & get(seqan::std::pair<T1, T2> & t) noexcept
+constexpr ::std::tuple_element_t<i, seqan::stl::pair<T1, T2>> & get(seqan::stl::pair<T1, T2> & t) noexcept
     requires (i < 2)
 {
     return ::std::get<i>(static_cast<::std::pair<T1, T2> &>(t));
 }
 
 template <::std::size_t i, class T1, class T2>
-constexpr ::std::tuple_element_t<i, seqan::std::pair<T1, T2>> const & get(seqan::std::pair<T1, T2> const & t) noexcept
+constexpr ::std::tuple_element_t<i, seqan::stl::pair<T1, T2>> const & get(seqan::stl::pair<T1, T2> const & t) noexcept
     requires (i < 2)
 {
     return ::std::get<i>(static_cast<::std::pair<T1, T2> const &>(t));
 }
 
 template <::std::size_t i, class T1, class T2>
-constexpr ::std::tuple_element_t<i, seqan::std::pair<T1, T2>> && get(seqan::std::pair<T1, T2> && t) noexcept
+constexpr ::std::tuple_element_t<i, seqan::stl::pair<T1, T2>> && get(seqan::stl::pair<T1, T2> && t) noexcept
     requires (i < 2)
 {
     return ::std::get<i>(static_cast<::std::pair<T1, T2> &&>(::std::move(t)));
 }
 
 template <::std::size_t i, class T1, class T2>
-constexpr ::std::tuple_element_t<i, seqan::std::pair<T1, T2>> const && get(seqan::std::pair<T1, T2> const && t) noexcept
+constexpr ::std::tuple_element_t<i, seqan::stl::pair<T1, T2>> const && get(seqan::stl::pair<T1, T2> const && t) noexcept
     requires (i < 2)
 {
     return ::std::get<i>(static_cast<::std::pair<T1, T2> const &&>(::std::move(t)));
 }
 
 template <typename type, class T1, class T2>
-constexpr type & get(seqan::std::pair<T1, T2> & t) noexcept
+constexpr type & get(seqan::stl::pair<T1, T2> & t) noexcept
     requires (!::std::same_as<T1, T2>)
 {
     return ::std::get<type>(static_cast<::std::pair<T1, T2> &>(t));
 }
 
 template <typename type, class T1, class T2>
-constexpr type const & get(seqan::std::pair<T1, T2> const & t) noexcept
+constexpr type const & get(seqan::stl::pair<T1, T2> const & t) noexcept
     requires (!::std::same_as<T1, T2>)
 {
     return ::std::get<type>(static_cast<::std::pair<T1, T2> const &>(t));
 }
 
 template <typename type, class T1, class T2>
-constexpr type && get(seqan::std::pair<T1, T2> && t) noexcept
+constexpr type && get(seqan::stl::pair<T1, T2> && t) noexcept
     requires (!::std::same_as<T1, T2>)
 {
     return ::std::get<type>(static_cast<::std::pair<T1, T2> &&>(::std::move(t)));
 }
 
 template <typename type, class T1, class T2>
-constexpr type const && get(seqan::std::pair<T1, T2> const && t) noexcept
+constexpr type const && get(seqan::stl::pair<T1, T2> const && t) noexcept
     requires (!::std::same_as<T1, T2>)
 {
     return ::std::get<type>(static_cast<::std::pair<T1, T2> const &&>(::std::move(t)));
diff --git a/include/hibf/contrib/std/to.hpp b/include/hibf/contrib/std/to.hpp
index d144a820..278c6146 100644
--- a/include/hibf/contrib/std/to.hpp
+++ b/include/hibf/contrib/std/to.hpp
@@ -7,7 +7,7 @@
 
 /*!\file
  * \author Enrico Seiler <enrico.seiler AT fu-berlin.de>
- * \brief Provides seqan::std::ranges::to.
+ * \brief Provides seqan::stl::ranges::to.
  */
 
 // File might be included from multiple libraries.
@@ -18,21 +18,21 @@
 
 #ifdef __cpp_lib_ranges_to_container
 
-namespace seqan::std
+namespace seqan::stl
 {
 
 using ::std::from_range_t;
 
 inline constexpr from_range_t from_range{};
 
-} // namespace seqan::std
+} // namespace seqan::stl
 
-namespace seqan::std::ranges
+namespace seqan::stl::ranges
 {
 
 using ::std::ranges::to;
 
-} // namespace seqan::std::ranges
+} // namespace seqan::stl::ranges
 
 #else
 
@@ -40,7 +40,7 @@ using ::std::ranges::to;
 
 #    include "detail/adaptor_from_functor.hpp"
 
-namespace seqan::std
+namespace seqan::stl
 {
 
 struct from_range_t
@@ -50,9 +50,9 @@ struct from_range_t
 
 inline constexpr from_range_t from_range{};
 
-} // namespace seqan::std
+} // namespace seqan::stl
 
-namespace seqan::std::detail::to
+namespace seqan::stl::detail::to
 {
 
 // clang-format off
@@ -107,9 +107,9 @@ template <typename It>
 concept has_input_iterator_category =
     ::std::derived_from<typename ::std::iterator_traits<It>::iterator_category, ::std::input_iterator_tag>;
 
-} // namespace seqan::std::detail::to
+} // namespace seqan::stl::detail::to
 
-namespace seqan::std::ranges
+namespace seqan::stl::ranges
 {
 
 template <class C, ::std::ranges::input_range R, class... Args>
@@ -121,22 +121,22 @@ constexpr C to(R && r, Args &&... args)
     {
         if constexpr (::std::constructible_from<C, R, Args...>)
             return C(::std::forward<R>(r), ::std::forward<Args>(args)...);
-        else if constexpr (::std::constructible_from<C, seqan::std::from_range_t, R, Args...>)
-            return C(seqan::std::from_range, ::std::forward<R>(r), ::std::forward<Args>(args)...);
+        else if constexpr (::std::constructible_from<C, seqan::stl::from_range_t, R, Args...>)
+            return C(seqan::stl::from_range, ::std::forward<R>(r), ::std::forward<Args>(args)...);
         else if constexpr (::std::ranges::common_range<R>
-                           && seqan::std::detail::to::has_input_iterator_category<::std::ranges::iterator_t<R>>
+                           && seqan::stl::detail::to::has_input_iterator_category<::std::ranges::iterator_t<R>>
                            && ::std::constructible_from<C,
                                                         ::std::ranges::iterator_t<R>,
                                                         ::std::ranges::sentinel_t<R>,
                                                         Args...>)
             return C(::std::ranges::begin(r), ::std::ranges::end(r), ::std::forward<Args>(args)...);
         else if constexpr (::std::constructible_from<C, Args...>
-                           && seqan::std::detail::to::container_insertable<C, ::std::ranges::range_reference_t<R>>)
+                           && seqan::stl::detail::to::container_insertable<C, ::std::ranges::range_reference_t<R>>)
         {
             C c(::std::forward<Args>(args)...);
-            if constexpr (::std::ranges::sized_range<R> && seqan::std::detail::to::reservable_container<C>)
+            if constexpr (::std::ranges::sized_range<R> && seqan::stl::detail::to::reservable_container<C>)
                 c.reserve(static_cast<::std::ranges::range_size_t<C>>(::std::ranges::size(r)));
-            ::std::ranges::copy(r, seqan::std::detail::to::container_inserter<::std::ranges::range_reference_t<R>>(c));
+            ::std::ranges::copy(r, seqan::stl::detail::to::container_inserter<::std::ranges::range_reference_t<R>>(c));
             return c;
         }
     }
@@ -158,25 +158,25 @@ constexpr auto to(R && r, Args &&... args)
     if constexpr (requires { C(::std::declval<R>(), ::std::declval<Args>()...); })
         return to<decltype(C(::std::declval<R>(), ::std::declval<Args>()...))>(::std::forward<R>(r),
                                                                                ::std::forward<Args>(args)...);
-    else if constexpr (requires { C(seqan::std::from_range, ::std::declval<R>(), ::std::declval<Args>()...); })
-        return to<decltype(C(seqan::std::from_range, ::std::declval<R>(), ::std::declval<Args>()...))>(
+    else if constexpr (requires { C(seqan::stl::from_range, ::std::declval<R>(), ::std::declval<Args>()...); })
+        return to<decltype(C(seqan::stl::from_range, ::std::declval<R>(), ::std::declval<Args>()...))>(
             ::std::forward<R>(r),
             ::std::forward<Args>(args)...);
     else if constexpr (requires {
-                           C(::std::declval<seqan::std::detail::to::input_iterator<R>>(),
-                             ::std::declval<seqan::std::detail::to::input_iterator<R>>(),
+                           C(::std::declval<seqan::stl::detail::to::input_iterator<R>>(),
+                             ::std::declval<seqan::stl::detail::to::input_iterator<R>>(),
                              ::std::declval<Args>()...);
                        })
-        return to<decltype(C(::std::declval<seqan::std::detail::to::input_iterator<R>>(),
-                             ::std::declval<seqan::std::detail::to::input_iterator<R>>(),
+        return to<decltype(C(::std::declval<seqan::stl::detail::to::input_iterator<R>>(),
+                             ::std::declval<seqan::stl::detail::to::input_iterator<R>>(),
                              ::std::declval<Args>()...))>(::std::forward<R>(r), ::std::forward<Args>(args)...);
     else
         __builtin_unreachable();
 }
 
-} // namespace seqan::std::ranges
+} // namespace seqan::stl::ranges
 
-namespace seqan::std::detail::to
+namespace seqan::stl::detail::to
 {
 
 template <class C>
@@ -186,13 +186,13 @@ struct to_fn1
     template <class... Args>
     constexpr auto operator()(Args &&... args) const
     {
-        return seqan::std::detail::adaptor_from_functor{*this, ::std::forward<Args>(args)...};
+        return seqan::stl::detail::adaptor_from_functor{*this, ::std::forward<Args>(args)...};
     }
 
     template <::std::ranges::input_range R, class... Args>
     constexpr auto operator()(R && r, Args &&... args) const
     {
-        return seqan::std::ranges::to<C>(::std::forward<R>(r), ::std::forward<Args>(args)...);
+        return seqan::stl::ranges::to<C>(::std::forward<R>(r), ::std::forward<Args>(args)...);
     }
 };
 
@@ -202,35 +202,35 @@ struct to_fn2
     template <class... Args>
     constexpr auto operator()(Args &&... args) const
     {
-        return seqan::std::detail::adaptor_from_functor{*this, ::std::forward<Args>(args)...};
+        return seqan::stl::detail::adaptor_from_functor{*this, ::std::forward<Args>(args)...};
     }
 
     template <::std::ranges::input_range R, class... Args>
     constexpr auto operator()(R && r, Args &&... args) const
     {
-        return seqan::std::ranges::to<C>(::std::forward<R>(r), ::std::forward<Args>(args)...);
+        return seqan::stl::ranges::to<C>(::std::forward<R>(r), ::std::forward<Args>(args)...);
     }
 };
 
-} // namespace seqan::std::detail::to
+} // namespace seqan::stl::detail::to
 
-namespace seqan::std::ranges
+namespace seqan::stl::ranges
 {
 
 template <class C, class... Args>
     requires (!::std::ranges::view<C>)
 constexpr auto to(Args &&... args)
 {
-    return seqan::std::detail::to::to_fn1<C>{}(::std::forward<Args>(args)...);
+    return seqan::stl::detail::to::to_fn1<C>{}(::std::forward<Args>(args)...);
 }
 
 template <template <class...> class C, class... Args>
 constexpr auto to(Args &&... args)
 {
-    return seqan::std::detail::to::to_fn2<C>{}(::std::forward<Args>(args)...);
+    return seqan::stl::detail::to::to_fn2<C>{}(::std::forward<Args>(args)...);
 }
 
-} // namespace seqan::std::ranges
+} // namespace seqan::stl::ranges
 
 #endif // ifdef __cpp_lib_ranges_to_container
 
diff --git a/include/hibf/contrib/std/tuple.hpp b/include/hibf/contrib/std/tuple.hpp
index 0b2364a1..86d5d752 100644
--- a/include/hibf/contrib/std/tuple.hpp
+++ b/include/hibf/contrib/std/tuple.hpp
@@ -6,7 +6,7 @@
 // -----------------------------------------------------------------------------------------------------
 
 /*!\file
- * \brief Provides seqan::std::tuple.
+ * \brief Provides seqan::stl::tuple.
  * \author Enrico Seiler <enrico.seiler AT fu-berlin.de>
  */
 
@@ -17,19 +17,19 @@
 
 #ifdef __cpp_lib_tuple_like
 
-namespace seqan::std
+namespace seqan::stl
 {
 
 using ::std::tuple;
 
-} // namespace seqan::std
+} // namespace seqan::stl
 
 #else
 
 #    include "detail/exposition_only.hpp"
 #    include "pair.hpp"
 
-namespace seqan::std
+namespace seqan::stl
 {
 
 template <class... Types>
@@ -891,9 +891,9 @@ class tuple : public ::std::tuple<Types...>
 template <class... UTypes>
 tuple(UTypes...) -> tuple<UTypes...>;
 
-} // namespace seqan::std
+} // namespace seqan::stl
 
-namespace seqan::std::detail::tuple
+namespace seqan::stl::detail::tuple
 {
 
 template <typename query_t, typename... pack_t>
@@ -905,109 +905,109 @@ namespace std
 {
 
 template <typename... args>
-struct tuple_size<seqan::std::tuple<args...>> : public tuple_size<::std::tuple<args...>>
+struct tuple_size<seqan::stl::tuple<args...>> : public tuple_size<::std::tuple<args...>>
 {};
 
 template <size_t index, typename... args>
-struct tuple_element<index, seqan::std::tuple<args...>> : public tuple_element<index, ::std::tuple<args...>>
+struct tuple_element<index, seqan::stl::tuple<args...>> : public tuple_element<index, ::std::tuple<args...>>
 {};
 
 template <class... Ts, class... Us>
-    requires requires { typename seqan::std::tuple<::std::common_type_t<Ts, Us>...>; }
-struct common_type<seqan::std::tuple<Ts...>, seqan::std::tuple<Us...>>
+    requires requires { typename seqan::stl::tuple<::std::common_type_t<Ts, Us>...>; }
+struct common_type<seqan::stl::tuple<Ts...>, seqan::stl::tuple<Us...>>
 {
-    using type = seqan::std::tuple<::std::common_type_t<Ts, Us>...>;
+    using type = seqan::stl::tuple<::std::common_type_t<Ts, Us>...>;
 };
 
 template <class... Ts, class... Us>
-    requires requires { typename seqan::std::tuple<::std::common_type_t<Ts, Us>...>; }
-struct common_type<::std::tuple<Ts...>, seqan::std::tuple<Us...>>
+    requires requires { typename seqan::stl::tuple<::std::common_type_t<Ts, Us>...>; }
+struct common_type<::std::tuple<Ts...>, seqan::stl::tuple<Us...>>
 {
-    using type = seqan::std::tuple<::std::common_type_t<Ts, Us>...>;
+    using type = seqan::stl::tuple<::std::common_type_t<Ts, Us>...>;
 };
 
 template <class... Ts, class... Us>
-    requires requires { typename seqan::std::tuple<::std::common_type_t<Ts, Us>...>; }
-struct common_type<seqan::std::tuple<Ts...>, ::std::tuple<Us...>>
+    requires requires { typename seqan::stl::tuple<::std::common_type_t<Ts, Us>...>; }
+struct common_type<seqan::stl::tuple<Ts...>, ::std::tuple<Us...>>
 {
-    using type = seqan::std::tuple<::std::common_type_t<Ts, Us>...>;
+    using type = seqan::stl::tuple<::std::common_type_t<Ts, Us>...>;
 };
 
 template <class... Ts, class... Us, template <class> class TQual, template <class> class UQual>
-    requires requires { typename seqan::std::tuple<::std::common_reference_t<TQual<Ts>, UQual<Us>>...>; }
-struct basic_common_reference<seqan::std::tuple<Ts...>, seqan::std::tuple<Us...>, TQual, UQual>
+    requires requires { typename seqan::stl::tuple<::std::common_reference_t<TQual<Ts>, UQual<Us>>...>; }
+struct basic_common_reference<seqan::stl::tuple<Ts...>, seqan::stl::tuple<Us...>, TQual, UQual>
 {
-    using type = seqan::std::tuple<::std::common_reference_t<TQual<Ts>, UQual<Us>>...>;
+    using type = seqan::stl::tuple<::std::common_reference_t<TQual<Ts>, UQual<Us>>...>;
 };
 
 template <class... Ts, class... Us, template <class> class TQual, template <class> class UQual>
-    requires requires { typename seqan::std::tuple<::std::common_reference_t<TQual<Ts>, UQual<Us>>...>; }
-struct basic_common_reference<seqan::std::tuple<Ts...>, ::std::tuple<Us...>, TQual, UQual>
+    requires requires { typename seqan::stl::tuple<::std::common_reference_t<TQual<Ts>, UQual<Us>>...>; }
+struct basic_common_reference<seqan::stl::tuple<Ts...>, ::std::tuple<Us...>, TQual, UQual>
 {
-    using type = seqan::std::tuple<::std::common_reference_t<TQual<Ts>, UQual<Us>>...>;
+    using type = seqan::stl::tuple<::std::common_reference_t<TQual<Ts>, UQual<Us>>...>;
 };
 
 template <class... Ts, class... Us, template <class> class TQual, template <class> class UQual>
-    requires requires { typename seqan::std::tuple<::std::common_reference_t<TQual<Ts>, UQual<Us>>...>; }
-struct basic_common_reference<::std::tuple<Ts...>, seqan::std::tuple<Us...>, TQual, UQual>
+    requires requires { typename seqan::stl::tuple<::std::common_reference_t<TQual<Ts>, UQual<Us>>...>; }
+struct basic_common_reference<::std::tuple<Ts...>, seqan::stl::tuple<Us...>, TQual, UQual>
 {
-    using type = seqan::std::tuple<::std::common_reference_t<TQual<Ts>, UQual<Us>>...>;
+    using type = seqan::stl::tuple<::std::common_reference_t<TQual<Ts>, UQual<Us>>...>;
 };
 
 template <::std::size_t i, typename... types>
-constexpr ::std::tuple_element_t<i, seqan::std::tuple<types...>> & get(seqan::std::tuple<types...> & t) noexcept
+constexpr ::std::tuple_element_t<i, seqan::stl::tuple<types...>> & get(seqan::stl::tuple<types...> & t) noexcept
     requires (i < sizeof...(types))
 {
     return ::std::get<i>(static_cast<::std::tuple<types...> &>(t));
 }
 
 template <::std::size_t i, typename... types>
-constexpr ::std::tuple_element_t<i, seqan::std::tuple<types...>> const &
-get(seqan::std::tuple<types...> const & t) noexcept
+constexpr ::std::tuple_element_t<i, seqan::stl::tuple<types...>> const &
+get(seqan::stl::tuple<types...> const & t) noexcept
     requires (i < sizeof...(types))
 {
     return ::std::get<i>(static_cast<::std::tuple<types...> const &>(t));
 }
 
 template <::std::size_t i, typename... types>
-constexpr ::std::tuple_element_t<i, seqan::std::tuple<types...>> && get(seqan::std::tuple<types...> && t) noexcept
+constexpr ::std::tuple_element_t<i, seqan::stl::tuple<types...>> && get(seqan::stl::tuple<types...> && t) noexcept
     requires (i < sizeof...(types))
 {
     return ::std::get<i>(static_cast<::std::tuple<types...> &&>(::std::move(t)));
 }
 
 template <::std::size_t i, typename... types>
-constexpr ::std::tuple_element_t<i, seqan::std::tuple<types...>> const &&
-get(seqan::std::tuple<types...> const && t) noexcept
+constexpr ::std::tuple_element_t<i, seqan::stl::tuple<types...>> const &&
+get(seqan::stl::tuple<types...> const && t) noexcept
     requires (i < sizeof...(types))
 {
     return ::std::get<i>(static_cast<::std::tuple<types...> const &&>(::std::move(t)));
 }
 
 template <typename type, typename... types>
-constexpr type & get(seqan::std::tuple<types...> & t) noexcept
-    requires (seqan::std::detail::tuple::count_in_pack<type, types...> == 1)
+constexpr type & get(seqan::stl::tuple<types...> & t) noexcept
+    requires (seqan::stl::detail::tuple::count_in_pack<type, types...> == 1)
 {
     return ::std::get<type>(static_cast<::std::tuple<types...> &>(t));
 }
 
 template <typename type, typename... types>
-constexpr type const & get(seqan::std::tuple<types...> const & t) noexcept
-    requires (seqan::std::detail::tuple::count_in_pack<type, types...> == 1)
+constexpr type const & get(seqan::stl::tuple<types...> const & t) noexcept
+    requires (seqan::stl::detail::tuple::count_in_pack<type, types...> == 1)
 {
     return ::std::get<type>(static_cast<::std::tuple<types...> const &>(t));
 }
 
 template <typename type, typename... types>
-constexpr type && get(seqan::std::tuple<types...> && t) noexcept
-    requires (seqan::std::detail::tuple::count_in_pack<type, types...> == 1)
+constexpr type && get(seqan::stl::tuple<types...> && t) noexcept
+    requires (seqan::stl::detail::tuple::count_in_pack<type, types...> == 1)
 {
     return ::std::get<type>(static_cast<::std::tuple<types...> &&>(::std::move(t)));
 }
 
 template <typename type, typename... types>
-constexpr type const && get(seqan::std::tuple<types...> const && t) noexcept
-    requires (seqan::std::detail::tuple::count_in_pack<type, types...> == 1)
+constexpr type const && get(seqan::stl::tuple<types...> const && t) noexcept
+    requires (seqan::stl::detail::tuple::count_in_pack<type, types...> == 1)
 {
     return ::std::get<type>(static_cast<::std::tuple<types...> const &&>(::std::move(t)));
 }
diff --git a/include/hibf/contrib/std/zip_view.hpp b/include/hibf/contrib/std/zip_view.hpp
index c3eedd84..a93ac90a 100644
--- a/include/hibf/contrib/std/zip_view.hpp
+++ b/include/hibf/contrib/std/zip_view.hpp
@@ -7,7 +7,7 @@
 
 /*!\file
  * \author Enrico Seiler <enrico.seiler AT fu-berlin.de>
- * \brief Provides seqan::std::views::zip.
+ * \brief Provides seqan::stl::views::zip.
  */
 
 // File might be included from multiple libraries.
@@ -18,12 +18,12 @@
 
 #ifdef __cpp_lib_ranges_zip
 
-namespace seqan::std::views
+namespace seqan::stl::views
 {
 
 using ::std::ranges::views::zip;
 
-} // namespace seqan::std::views
+} // namespace seqan::stl::views
 
 #else
 
@@ -36,7 +36,7 @@ using ::std::ranges::views::zip;
 #    include "detail/exposition_only.hpp"
 #    include "tuple.hpp"
 
-namespace seqan::std::detail::zip
+namespace seqan::stl::detail::zip
 {
 template <bool is_const, typename... range_ts>
 concept all_random_access = (::std::ranges::random_access_range<maybe_const<is_const, range_ts>> && ...);
@@ -67,14 +67,14 @@ template <typename... ts>
     requires (sizeof...(ts) != 2)
 struct tuple_or_pair_impl<ts...>
 {
-    using type = seqan::std::tuple<ts...>;
+    using type = seqan::stl::tuple<ts...>;
 };
 
 template <typename... ts>
     requires (sizeof...(ts) == 2)
 struct tuple_or_pair_impl<ts...>
 {
-    using type = seqan::std::pair<ts...>;
+    using type = seqan::stl::pair<ts...>;
 };
 
 // https://eel.is/c++draft/range.zip#view-1
@@ -126,9 +126,9 @@ concept zip_is_common = (sizeof...(range_ts) == 1 && (::std::ranges::common_rang
                      || ((::std::ranges::random_access_range<range_ts> && ...)
                          && (::std::ranges::sized_range<range_ts> && ...));
 
-} // namespace seqan::std::detail::zip
+} // namespace seqan::stl::detail::zip
 
-namespace seqan::std::ranges
+namespace seqan::stl::ranges
 {
 
 template <::std::ranges::input_range... Views>
@@ -136,7 +136,7 @@ template <::std::ranges::input_range... Views>
 class zip_view : public ::std::ranges::view_interface<zip_view<Views...>>
 {
 private:
-    seqan::std::tuple<Views...> views_;
+    seqan::stl::tuple<Views...> views_;
 
     template <bool>
     class iterator;
@@ -152,37 +152,37 @@ class zip_view : public ::std::ranges::view_interface<zip_view<Views...>>
     {}
 
     constexpr auto begin()
-        requires (!(seqan::std::detail::simple_view<Views> && ...))
+        requires (!(seqan::stl::detail::simple_view<Views> && ...))
     {
-        return iterator<false>(seqan::std::detail::zip::tuple_transform(::std::ranges::begin, views_));
+        return iterator<false>(seqan::stl::detail::zip::tuple_transform(::std::ranges::begin, views_));
     }
 
     constexpr auto begin() const
         requires (::std::ranges::range<Views const> && ...)
     {
-        return iterator<true>(seqan::std::detail::zip::tuple_transform(::std::ranges::begin, views_));
+        return iterator<true>(seqan::stl::detail::zip::tuple_transform(::std::ranges::begin, views_));
     }
 
     constexpr auto end()
-        requires (!(seqan::std::detail::simple_view<Views> && ...))
+        requires (!(seqan::stl::detail::simple_view<Views> && ...))
     {
-        if constexpr (!seqan::std::detail::zip::zip_is_common<Views...>)
-            return sentinel<false>(seqan::std::detail::zip::tuple_transform(::std::ranges::end, views_));
+        if constexpr (!seqan::stl::detail::zip::zip_is_common<Views...>)
+            return sentinel<false>(seqan::stl::detail::zip::tuple_transform(::std::ranges::end, views_));
         else if constexpr ((::std::ranges::random_access_range<Views> && ...))
             return begin() + ::std::iter_difference_t<iterator<false>>(size());
         else
-            return iterator<false>(seqan::std::detail::zip::tuple_transform(::std::ranges::end, views_));
+            return iterator<false>(seqan::stl::detail::zip::tuple_transform(::std::ranges::end, views_));
     }
 
     constexpr auto end() const
         requires (::std::ranges::range<Views const> && ...)
     {
-        if constexpr (!seqan::std::detail::zip::zip_is_common<Views const...>)
-            return sentinel<true>(seqan::std::detail::zip::tuple_transform(::std::ranges::end, views_));
+        if constexpr (!seqan::stl::detail::zip::zip_is_common<Views const...>)
+            return sentinel<true>(seqan::stl::detail::zip::tuple_transform(::std::ranges::end, views_));
         else if constexpr ((::std::ranges::random_access_range<Views const> && ...))
             return begin() + ::std::iter_difference_t<iterator<true>>(size());
         else
-            return iterator<true>(seqan::std::detail::zip::tuple_transform(::std::ranges::end, views_));
+            return iterator<true>(seqan::stl::detail::zip::tuple_transform(::std::ranges::end, views_));
     }
 
     constexpr auto size()
@@ -194,7 +194,7 @@ class zip_view : public ::std::ranges::view_interface<zip_view<Views...>>
                 using common_size_t = ::std::make_unsigned_t<::std::common_type_t<decltype(sizes)...>>;
                 return ::std::ranges::min({static_cast<common_size_t>(sizes)...});
             },
-            seqan::std::detail::zip::tuple_transform(::std::ranges::size, views_));
+            seqan::stl::detail::zip::tuple_transform(::std::ranges::size, views_));
     }
 
     constexpr auto size() const
@@ -206,22 +206,22 @@ class zip_view : public ::std::ranges::view_interface<zip_view<Views...>>
                 using common_size_t = ::std::make_unsigned_t<::std::common_type_t<decltype(sizes)...>>;
                 return ::std::ranges::min({static_cast<common_size_t>(sizes)...});
             },
-            seqan::std::detail::zip::tuple_transform(::std::ranges::size, views_));
+            seqan::stl::detail::zip::tuple_transform(::std::ranges::size, views_));
     }
 };
 
 template <typename... range_ts>
-zip_view(range_ts &&...) -> zip_view<seqan::std::views::all_t<range_ts>...>;
+zip_view(range_ts &&...) -> zip_view<seqan::stl::views::all_t<range_ts>...>;
 
 template <::std::ranges::input_range... Views>
     requires (::std::ranges::view<Views> && ...) && (sizeof...(Views) > 0)
 template <bool Const>
 class zip_view<Views...>::iterator :
-    public seqan::std::detail::zip::iterator_category_t<seqan::std::detail::zip::all_forward<Const, Views...>>
+    public seqan::stl::detail::zip::iterator_category_t<seqan::stl::detail::zip::all_forward<Const, Views...>>
 {
 private:
-    constexpr explicit iterator(seqan::std::detail::zip::tuple_or_pair<
-                                ::std::ranges::iterator_t<seqan::std::detail::maybe_const<Const, Views>>...> current) :
+    constexpr explicit iterator(seqan::stl::detail::zip::tuple_or_pair<
+                                ::std::ranges::iterator_t<seqan::stl::detail::maybe_const<Const, Views>>...> current) :
         current_(::std::move(current))
     {}
 
@@ -230,35 +230,35 @@ class zip_view<Views...>::iterator :
     // clang-format off
 SEQAN_STD_NESTED_VISIBILITY
     // clang-format on
-    seqan::std::detail::zip::tuple_or_pair<::std::ranges::iterator_t<seqan::std::detail::maybe_const<Const, Views>>...>
+    seqan::stl::detail::zip::tuple_or_pair<::std::ranges::iterator_t<seqan::stl::detail::maybe_const<Const, Views>>...>
         current_;
 
 public:
     using iterator_concept = ::std::conditional_t<
-        seqan::std::detail::zip::all_random_access<Const, Views...>,
+        seqan::stl::detail::zip::all_random_access<Const, Views...>,
         ::std::random_access_iterator_tag,
-        ::std::conditional_t<seqan::std::detail::zip::all_bidirectional<Const, Views...>,
+        ::std::conditional_t<seqan::stl::detail::zip::all_bidirectional<Const, Views...>,
                              ::std::bidirectional_iterator_tag,
-                             ::std::conditional_t<seqan::std::detail::zip::all_forward<Const, Views...>,
+                             ::std::conditional_t<seqan::stl::detail::zip::all_forward<Const, Views...>,
                                                   ::std::forward_iterator_tag,
                                                   ::std::input_iterator_tag>>>;
-    using value_type = seqan::std::detail::zip::tuple_or_pair<
-        ::std::ranges::range_value_t<seqan::std::detail::maybe_const<Const, Views>>...>;
+    using value_type = seqan::stl::detail::zip::tuple_or_pair<
+        ::std::ranges::range_value_t<seqan::stl::detail::maybe_const<Const, Views>>...>;
     using difference_type =
-        ::std::common_type_t<::std::ranges::range_difference_t<seqan::std::detail::maybe_const<Const, Views>>...>;
+        ::std::common_type_t<::std::ranges::range_difference_t<seqan::stl::detail::maybe_const<Const, Views>>...>;
 
     iterator() = default;
     constexpr iterator(iterator<!Const> i)
         requires Const
               && (::std::convertible_to<::std::ranges::iterator_t<Views>,
-                                        ::std::ranges::iterator_t<seqan::std::detail::maybe_const<Const, Views>>>
+                                        ::std::ranges::iterator_t<seqan::stl::detail::maybe_const<Const, Views>>>
                   && ...)
         : current_(::std::move(i.current))
     {}
 
     constexpr auto operator*() const
     {
-        return seqan::std::detail::zip::tuple_transform(
+        return seqan::stl::detail::zip::tuple_transform(
             [](auto & i) -> decltype(auto)
             {
                 return *i;
@@ -268,7 +268,7 @@ SEQAN_STD_NESTED_VISIBILITY
 
     constexpr iterator & operator++()
     {
-        seqan::std::detail::zip::tuple_for_each(
+        seqan::stl::detail::zip::tuple_for_each(
             [](auto & i)
             {
                 ++i;
@@ -283,7 +283,7 @@ SEQAN_STD_NESTED_VISIBILITY
     }
 
     constexpr iterator operator++(int)
-        requires seqan::std::detail::zip::all_forward<Const, Views...>
+        requires seqan::stl::detail::zip::all_forward<Const, Views...>
     {
         auto tmp = *this;
         ++*this;
@@ -291,9 +291,9 @@ SEQAN_STD_NESTED_VISIBILITY
     }
 
     constexpr iterator & operator--()
-        requires seqan::std::detail::zip::all_bidirectional<Const, Views...>
+        requires seqan::stl::detail::zip::all_bidirectional<Const, Views...>
     {
-        seqan::std::detail::zip::tuple_for_each(
+        seqan::stl::detail::zip::tuple_for_each(
             [](auto & i)
             {
                 --i;
@@ -303,7 +303,7 @@ SEQAN_STD_NESTED_VISIBILITY
     }
 
     constexpr iterator operator--(int)
-        requires seqan::std::detail::zip::all_bidirectional<Const, Views...>
+        requires seqan::stl::detail::zip::all_bidirectional<Const, Views...>
     {
         auto tmp = *this;
         --*this;
@@ -311,9 +311,9 @@ SEQAN_STD_NESTED_VISIBILITY
     }
 
     constexpr iterator & operator+=(difference_type x)
-        requires seqan::std::detail::zip::all_random_access<Const, Views...>
+        requires seqan::stl::detail::zip::all_random_access<Const, Views...>
     {
-        seqan::std::detail::zip::tuple_for_each(
+        seqan::stl::detail::zip::tuple_for_each(
             [&]<typename I>(I & i)
             {
                 i += ::std::iter_difference_t<I>(x);
@@ -323,9 +323,9 @@ SEQAN_STD_NESTED_VISIBILITY
     }
 
     constexpr iterator & operator-=(difference_type x)
-        requires seqan::std::detail::zip::all_random_access<Const, Views...>
+        requires seqan::stl::detail::zip::all_random_access<Const, Views...>
     {
-        seqan::std::detail::zip::tuple_for_each(
+        seqan::stl::detail::zip::tuple_for_each(
             [&]<typename I>(I & i)
             {
                 i -= ::std::iter_difference_t<I>(x);
@@ -335,9 +335,9 @@ SEQAN_STD_NESTED_VISIBILITY
     }
 
     constexpr auto operator[](difference_type n) const
-        requires seqan::std::detail::zip::all_random_access<Const, Views...>
+        requires seqan::stl::detail::zip::all_random_access<Const, Views...>
     {
-        return seqan::std::detail::zip::tuple_transform(
+        return seqan::stl::detail::zip::tuple_transform(
             [&]<typename I>(I & i) -> decltype(auto)
             {
                 return i[::std::iter_difference_t<I>(n)];
@@ -346,10 +346,10 @@ SEQAN_STD_NESTED_VISIBILITY
     }
 
     friend constexpr bool operator==(iterator const & x, iterator const & y)
-        requires (::std::equality_comparable<::std::ranges::iterator_t<seqan::std::detail::maybe_const<Const, Views>>>
+        requires (::std::equality_comparable<::std::ranges::iterator_t<seqan::stl::detail::maybe_const<Const, Views>>>
                   && ...)
     {
-        if constexpr (seqan::std::detail::zip::all_bidirectional<Const, Views...>)
+        if constexpr (seqan::stl::detail::zip::all_bidirectional<Const, Views...>)
         {
             return x.current_ == y.current_;
         }
@@ -364,33 +364,33 @@ SEQAN_STD_NESTED_VISIBILITY
     }
 
     friend constexpr bool operator<(iterator const & x, iterator const & y)
-        requires seqan::std::detail::zip::all_random_access<Const, Views...>
+        requires seqan::stl::detail::zip::all_random_access<Const, Views...>
     {
         return x.current_ < y.current_;
     }
 
     friend constexpr bool operator>(iterator const & x, iterator const & y)
-        requires seqan::std::detail::zip::all_random_access<Const, Views...>
+        requires seqan::stl::detail::zip::all_random_access<Const, Views...>
     {
         return y < x;
     }
 
     friend constexpr bool operator<=(iterator const & x, iterator const & y)
-        requires seqan::std::detail::zip::all_random_access<Const, Views...>
+        requires seqan::stl::detail::zip::all_random_access<Const, Views...>
     {
         return !(y < x);
     }
 
     friend constexpr bool operator>=(iterator const & x, iterator const & y)
-        requires seqan::std::detail::zip::all_random_access<Const, Views...>
+        requires seqan::stl::detail::zip::all_random_access<Const, Views...>
     {
         return !(x < y);
     }
 
 #    ifdef __cpp_lib_three_way_comparison
     friend constexpr auto operator<=>(iterator const & x, iterator const & y)
-        requires seqan::std::detail::zip::all_random_access<Const, Views...>
-              && (::std::three_way_comparable<::std::ranges::iterator_t<seqan::std::detail::maybe_const<Const, Views>>>
+        requires seqan::stl::detail::zip::all_random_access<Const, Views...>
+              && (::std::three_way_comparable<::std::ranges::iterator_t<seqan::stl::detail::maybe_const<Const, Views>>>
                   && ...)
     {
         return x.current_ <=> y.current_;
@@ -398,7 +398,7 @@ SEQAN_STD_NESTED_VISIBILITY
 #    endif
 
     friend constexpr iterator operator+(iterator const & i, difference_type n)
-        requires seqan::std::detail::zip::all_random_access<Const, Views...>
+        requires seqan::stl::detail::zip::all_random_access<Const, Views...>
     {
         auto r = i;
         r += n;
@@ -406,13 +406,13 @@ SEQAN_STD_NESTED_VISIBILITY
     }
 
     friend constexpr iterator operator+(difference_type n, iterator const & i)
-        requires seqan::std::detail::zip::all_random_access<Const, Views...>
+        requires seqan::stl::detail::zip::all_random_access<Const, Views...>
     {
         return i + n;
     }
 
     friend constexpr iterator operator-(iterator const & i, difference_type n)
-        requires seqan::std::detail::zip::all_random_access<Const, Views...>
+        requires seqan::stl::detail::zip::all_random_access<Const, Views...>
     {
         auto r = i;
         r -= n;
@@ -420,8 +420,8 @@ SEQAN_STD_NESTED_VISIBILITY
     }
 
     friend constexpr difference_type operator-(iterator const & x, iterator const & y)
-        requires (::std::sized_sentinel_for<::std::ranges::iterator_t<seqan::std::detail::maybe_const<Const, Views>>,
-                                            ::std::ranges::iterator_t<seqan::std::detail::maybe_const<Const, Views>>>
+        requires (::std::sized_sentinel_for<::std::ranges::iterator_t<seqan::stl::detail::maybe_const<Const, Views>>,
+                                            ::std::ranges::iterator_t<seqan::stl::detail::maybe_const<Const, Views>>>
                   && ...)
     {
         return [&]<size_t... N>(::std::integer_sequence<size_t, N...>)
@@ -430,7 +430,7 @@ SEQAN_STD_NESTED_VISIBILITY
                 {static_cast<difference_type>(::std::get<N>(x.current_) - ::std::get<N>(y.current_))...},
                 [](difference_type a, difference_type b)
                 {
-                    return seqan::std::detail::zip::abs(b) < seqan::std::detail::zip::abs(a);
+                    return seqan::stl::detail::zip::abs(b) < seqan::stl::detail::zip::abs(a);
                 });
         }
         (::std::index_sequence_for<Views...>{});
@@ -438,21 +438,21 @@ SEQAN_STD_NESTED_VISIBILITY
 
     friend constexpr auto iter_move(iterator const & i) noexcept(
         (noexcept(::std::ranges::iter_move(
-             ::std::declval<::std::ranges::iterator_t<seqan::std::detail::maybe_const<Const, Views>> const &>()))
+             ::std::declval<::std::ranges::iterator_t<seqan::stl::detail::maybe_const<Const, Views>> const &>()))
          && ...)
         && (::std::is_nothrow_move_constructible_v<
-                ::std::ranges::range_rvalue_reference_t<seqan::std::detail::maybe_const<Const, Views>>>
+                ::std::ranges::range_rvalue_reference_t<seqan::stl::detail::maybe_const<Const, Views>>>
             && ...))
     {
-        return seqan::std::detail::zip::tuple_transform(::std::ranges::iter_move, i.current_);
+        return seqan::stl::detail::zip::tuple_transform(::std::ranges::iter_move, i.current_);
     }
 
     friend constexpr void iter_swap(iterator const & l, iterator const & r) noexcept(
         (noexcept(::std::ranges::iter_swap(
-             ::std::declval<::std::ranges::iterator_t<seqan::std::detail::maybe_const<Const, Views>> const &>(),
-             ::std::declval<::std::ranges::iterator_t<seqan::std::detail::maybe_const<Const, Views>> const &>()))
+             ::std::declval<::std::ranges::iterator_t<seqan::stl::detail::maybe_const<Const, Views>> const &>(),
+             ::std::declval<::std::ranges::iterator_t<seqan::stl::detail::maybe_const<Const, Views>> const &>()))
          && ...))
-        requires (::std::indirectly_swappable<::std::ranges::iterator_t<seqan::std::detail::maybe_const<Const, Views>>>
+        requires (::std::indirectly_swappable<::std::ranges::iterator_t<seqan::stl::detail::maybe_const<Const, Views>>>
                   && ...)
     {
         [&]<size_t... N>(::std::integer_sequence<size_t, N...>)
@@ -469,8 +469,8 @@ template <bool Const>
 class zip_view<Views...>::sentinel
 {
 private:
-    constexpr explicit sentinel(seqan::std::detail::zip::tuple_or_pair<
-                                ::std::ranges::sentinel_t<seqan::std::detail::maybe_const<Const, Views>>...> end) :
+    constexpr explicit sentinel(seqan::stl::detail::zip::tuple_or_pair<
+                                ::std::ranges::sentinel_t<seqan::stl::detail::maybe_const<Const, Views>>...> end) :
         end_(::std::move(end))
     {}
 
@@ -479,7 +479,7 @@ class zip_view<Views...>::sentinel
     // clang-format off
 SEQAN_STD_NESTED_VISIBILITY
     // clang-format on
-    seqan::std::detail::zip::tuple_or_pair<::std::ranges::sentinel_t<seqan::std::detail::maybe_const<Const, Views>>...>
+    seqan::stl::detail::zip::tuple_or_pair<::std::ranges::sentinel_t<seqan::stl::detail::maybe_const<Const, Views>>...>
         end_;
 
 public:
@@ -487,14 +487,14 @@ SEQAN_STD_NESTED_VISIBILITY
     constexpr sentinel(sentinel<!Const> i)
         requires Const
               && (::std::convertible_to<::std::ranges::sentinel_t<Views>,
-                                        ::std::ranges::sentinel_t<seqan::std::detail::maybe_const<Const, Views>>>
+                                        ::std::ranges::sentinel_t<seqan::stl::detail::maybe_const<Const, Views>>>
                   && ...)
         : end_(::std::move(i.end_))
     {}
 
     template <bool OtherConst>
-        requires (::std::sentinel_for<::std::ranges::sentinel_t<seqan::std::detail::maybe_const<Const, Views>>,
-                                      ::std::ranges::iterator_t<seqan::std::detail::maybe_const<OtherConst, Views>>>
+        requires (::std::sentinel_for<::std::ranges::sentinel_t<seqan::stl::detail::maybe_const<Const, Views>>,
+                                      ::std::ranges::iterator_t<seqan::stl::detail::maybe_const<OtherConst, Views>>>
                   && ...)
     friend constexpr bool operator==(iterator<OtherConst> const & x, sentinel const & y)
     {
@@ -507,21 +507,21 @@ SEQAN_STD_NESTED_VISIBILITY
 
     template <bool OtherConst>
         requires (
-            ::std::sized_sentinel_for<::std::ranges::sentinel_t<seqan::std::detail::maybe_const<Const, Views>>,
-                                      ::std::ranges::iterator_t<seqan::std::detail::maybe_const<OtherConst, Views>>>
+            ::std::sized_sentinel_for<::std::ranges::sentinel_t<seqan::stl::detail::maybe_const<Const, Views>>,
+                                      ::std::ranges::iterator_t<seqan::stl::detail::maybe_const<OtherConst, Views>>>
             && ...)
     friend constexpr ::std::common_type_t<
-        ::std::ranges::range_difference_t<seqan::std::detail::maybe_const<OtherConst, Views>>...>
+        ::std::ranges::range_difference_t<seqan::stl::detail::maybe_const<OtherConst, Views>>...>
     operator-(iterator<OtherConst> const & x, sentinel const & y)
     {
         using return_t = ::std::common_type_t<
-            ::std::ranges::range_difference_t<seqan::std::detail::maybe_const<OtherConst, Views>>...>;
+            ::std::ranges::range_difference_t<seqan::stl::detail::maybe_const<OtherConst, Views>>...>;
         return [&]<size_t... N>(::std::integer_sequence<size_t, N...>)
         {
             return ::std::ranges::min({static_cast<return_t>(::std::get<N>(x.current_) - ::std::get<N>(y.end_))...},
                                       [](return_t a, return_t b)
                                       {
-                                          return seqan::std::detail::zip::abs(b) < seqan::std::detail::zip::abs(a);
+                                          return seqan::stl::detail::zip::abs(b) < seqan::stl::detail::zip::abs(a);
                                       });
         }
         (::std::index_sequence_for<Views...>{});
@@ -529,11 +529,11 @@ SEQAN_STD_NESTED_VISIBILITY
 
     template <bool OtherConst>
         requires (
-            ::std::sized_sentinel_for<::std::ranges::sentinel_t<seqan::std::detail::maybe_const<Const, Views>>,
-                                      ::std::ranges::iterator_t<seqan::std::detail::maybe_const<OtherConst, Views>>>
+            ::std::sized_sentinel_for<::std::ranges::sentinel_t<seqan::stl::detail::maybe_const<Const, Views>>,
+                                      ::std::ranges::iterator_t<seqan::stl::detail::maybe_const<OtherConst, Views>>>
             && ...)
     friend constexpr ::std::common_type_t<
-        ::std::ranges::range_difference_t<seqan::std::detail::maybe_const<OtherConst, Views>>...>
+        ::std::ranges::range_difference_t<seqan::stl::detail::maybe_const<OtherConst, Views>>...>
     operator-(sentinel const & y, iterator<OtherConst> const & x)
     {
         return -(x - y);
@@ -542,14 +542,14 @@ SEQAN_STD_NESTED_VISIBILITY
 
 struct zip_fn
 {
-    template <seqan::std::ranges::viewable_range... urng_ts>
+    template <seqan::stl::ranges::viewable_range... urng_ts>
         requires (sizeof...(urng_ts) == 0)
     constexpr auto operator()(urng_ts &&... ranges) const
     {
-        return ::std::views::empty<seqan::std::tuple<>>;
+        return ::std::views::empty<seqan::stl::tuple<>>;
     }
 
-    template <seqan::std::ranges::viewable_range... urng_ts>
+    template <seqan::stl::ranges::viewable_range... urng_ts>
         requires (sizeof...(urng_ts) > 1)
     constexpr auto operator()(urng_ts &&... ranges) const
     {
@@ -557,14 +557,14 @@ struct zip_fn
     }
 };
 
-} // namespace seqan::std::ranges
+} // namespace seqan::stl::ranges
 
-namespace seqan::std::views
+namespace seqan::stl::views
 {
 
-inline constexpr auto zip = seqan::std::ranges::zip_fn{};
+inline constexpr auto zip = seqan::stl::ranges::zip_fn{};
 
-} // namespace seqan::std::views
+} // namespace seqan::stl::views
 
 #endif // ifdef __cpp_lib_ranges_zip
 
diff --git a/src/detail/build/insert_into_ibf.cpp b/src/detail/build/insert_into_ibf.cpp
index 01204c00..6ef1724c 100644
--- a/src/detail/build/insert_into_ibf.cpp
+++ b/src/detail/build/insert_into_ibf.cpp
@@ -37,7 +37,7 @@ void insert_into_ibf(robin_hood::unordered_flat_set<uint64_t> const & kmers,
 
     timer<concurrent::no> local_fill_ibf_timer{};
     local_fill_ibf_timer.start();
-    for (auto chunk : kmers | seqan::std::views::chunk(chunk_size))
+    for (auto chunk : kmers | seqan::stl::views::chunk(chunk_size))
     {
         assert(chunk_number < number_of_bins);
         seqan::hibf::bin_index const bin_idx{bin_index + chunk_number};
diff --git a/test/performance/ibf/interleaved_bloom_filter_benchmark.cpp b/test/performance/ibf/interleaved_bloom_filter_benchmark.cpp
index 38f3fb48..097bf4db 100644
--- a/test/performance/ibf/interleaved_bloom_filter_benchmark.cpp
+++ b/test/performance/ibf/interleaved_bloom_filter_benchmark.cpp
@@ -77,7 +77,7 @@ void emplace_benchmark(::benchmark::State & state)
 
     for (auto _ : state)
     {
-        for (auto [hash, bin] : seqan::std::views::zip(hash_values, bin_indices))
+        for (auto [hash, bin] : seqan::stl::views::zip(hash_values, bin_indices))
             ibf.emplace(hash, seqan::hibf::bin_index{bin});
     }
 
@@ -96,7 +96,7 @@ void clear_benchmark(::benchmark::State & state)
                                                         {
                                                             return seqan::hibf::bin_index{i};
                                                         })
-                                                  | seqan::std::ranges::to<std::vector>();
+                                                  | seqan::stl::ranges::to<std::vector>();
 
     for (auto _ : state)
     {
@@ -119,7 +119,7 @@ void clear_range_benchmark(::benchmark::State & state)
                                                         {
                                                             return seqan::hibf::bin_index{i};
                                                         })
-                                                  | seqan::std::ranges::to<std::vector>();
+                                                  | seqan::stl::ranges::to<std::vector>();
 
     for (auto _ : state)
     {
@@ -133,7 +133,7 @@ void bulk_contains_benchmark(::benchmark::State & state)
 {
     auto && [bin_indices, hash_values, ibf] = set_up(state);
 
-    for (auto [hash, bin] : seqan::std::views::zip(hash_values, bin_indices))
+    for (auto [hash, bin] : seqan::stl::views::zip(hash_values, bin_indices))
         ibf.emplace(hash, seqan::hibf::bin_index{bin});
 
     auto agent = ibf.membership_agent();
@@ -153,7 +153,7 @@ void bulk_count_benchmark(::benchmark::State & state)
 {
     auto && [bin_indices, hash_values, ibf] = set_up(state);
 
-    for (auto [hash, bin] : seqan::std::views::zip(hash_values, bin_indices))
+    for (auto [hash, bin] : seqan::stl::views::zip(hash_values, bin_indices))
         ibf.emplace(hash, seqan::hibf::bin_index{bin});
 
     auto agent = ibf.counting_agent();