diff --git a/include/seqan3/alignment/aligned_sequence/debug_stream_alignment.hpp b/include/seqan3/alignment/aligned_sequence/debug_stream_alignment.hpp
index c78b1f920d..535dc88c8b 100644
--- a/include/seqan3/alignment/aligned_sequence/debug_stream_alignment.hpp
+++ b/include/seqan3/alignment/aligned_sequence/debug_stream_alignment.hpp
@@ -91,27 +91,31 @@ void stream_alignment(debug_stream_type<char_t> & stream,
 
 namespace seqan3
 {
-/*!\brief Stream operator for alignments, which are represented as tuples of aligned sequences.
+
+/*!\brief The printer for alignment.
+ * \tparam alignment_t The type of the alignment; must model seqan3::tuple_like and all sequences must be
+ *                     seqan3::aligned_sequence.
  * \ingroup alignment_aligned_sequence
- *
- * \tparam alignment_t The alignment type, must satisfy tuple_like and its size must be at least 2.
- *
- * \param[in,out] stream The target stream for the formatted output.
- * \param[in] alignment The alignment that shall be formatted. All sequences must be equally long.
- *
- * \return The given stream to which the alignment representation is appended.
  */
-template <typename char_t, typename alignment_t>
-    requires (detail::debug_streamable_tuple<alignment_t>
-              && detail::all_model_aligned_seq<detail::tuple_type_list_t<std::remove_cvref_t<alignment_t>>>)
-inline debug_stream_type<char_t> & operator<<(debug_stream_type<char_t> & stream, alignment_t && alignment)
+template <typename alignment_t>
+    requires tuple_like<alignment_t> && detail::all_model_aligned_seq<detail::tuple_type_list_t<alignment_t>>
+struct alignment_printer<alignment_t>
 {
-    constexpr size_t sequence_count = std::tuple_size_v<std::remove_cvref_t<alignment_t>>;
+    /*!\brief The function call operator that pretty prints the alignment to the stream.
+     * \tparam stream_t The type of the stream.
+     * \tparam arg_t The type of the argument.
+     * \param[in,out] stream The target stream for the formatted output.
+     * \param[in] arg The alignment that shall be formatted. All sequences must be equally long.
+     */
+    template <typename stream_t, typename arg_t>
+    constexpr void operator()(stream_t & stream, arg_t && arg) const
+    {
+        constexpr size_t sequence_count = std::tuple_size_v<std::remove_cvref_t<arg_t>>;
 
-    static_assert(sequence_count >= 2, "An alignment requires at least two sequences.");
+        static_assert(sequence_count >= 2, "An alignment requires at least two sequences.");
 
-    detail::stream_alignment(stream, alignment, std::make_index_sequence<sequence_count - 1>{});
-    return stream;
-}
+        detail::stream_alignment(stream, std::forward<arg_t>(arg), std::make_index_sequence<sequence_count - 1>{});
+    }
+};
 
 } // namespace seqan3
diff --git a/include/seqan3/alignment/matrix/detail/advanceable_alignment_coordinate.hpp b/include/seqan3/alignment/matrix/detail/advanceable_alignment_coordinate.hpp
index 5100314105..23af51f03a 100644
--- a/include/seqan3/alignment/matrix/detail/advanceable_alignment_coordinate.hpp
+++ b/include/seqan3/alignment/matrix/detail/advanceable_alignment_coordinate.hpp
@@ -294,23 +294,26 @@ class advanceable_alignment_coordinate
 namespace seqan3
 {
 
-/*!\brief A seqan3::detail::advanceable_alignment_coordinate can be printed to the seqan3::debug_stream.
- * \tparam    coordinate_type The alignment coordinate type.
- * \param[in] s               The seqan3::debug_stream.
- * \param[in] c               The alignment coordinate to print.
- * \relates seqan3::debug_stream_type
+/*!\brief The printer for seqan3::detail::advanceable_alignment_coordinate.
  *
- * \details
+ * Prints the alignment coordinate as a tuple of the column and row index.
  *
- * Prints the alignment coordinate as a tuple.
+ * \tparam state_t The state of the detail::advanceable_alignment_coordinate.
+ * \ingroup alignment_matrix
  */
-template <typename char_t, typename coordinate_type>
-    requires detail::is_value_specialisation_of_v<std::remove_cvref_t<coordinate_type>,
-                                                  detail::advanceable_alignment_coordinate>
-inline debug_stream_type<char_t> & operator<<(debug_stream_type<char_t> & s, coordinate_type && c)
+template <auto state_t>
+struct advanceable_alignment_coordinate_printer<detail::advanceable_alignment_coordinate<state_t>>
 {
-    s << std::tie(c.first, c.second);
-    return s;
-}
+    /*!\brief The function call operator that prints the coordinate to the given stream.
+     * \tparam stream_t The type of the stream.
+     * \param[in,out] stream The stream to print to.
+     * \param[in] arg The alignment coordinate to print.
+     */
+    template <typename stream_t>
+    constexpr void operator()(stream_t & stream, detail::advanceable_alignment_coordinate<state_t> const arg) const
+    {
+        stream << std::tie(arg.first, arg.second);
+    }
+};
 
 } // namespace seqan3
diff --git a/include/seqan3/alignment/matrix/detail/debug_matrix.hpp b/include/seqan3/alignment/matrix/detail/debug_matrix.hpp
index 615abe26b5..302dff33a4 100644
--- a/include/seqan3/alignment/matrix/detail/debug_matrix.hpp
+++ b/include/seqan3/alignment/matrix/detail/debug_matrix.hpp
@@ -467,33 +467,67 @@ debug_matrix(matrix_t &&,
 
 namespace seqan3
 {
-/*!\brief An alignment matrix can be printed to the seqan3::debug_stream.
- * \tparam alignment_matrix_t Type of the alignment matrix to be printed; must model seqan3::detail::matrix.
- * \param s The seqan3::debug_stream.
- * \param matrix The alignment matrix.
- * \relates seqan3::debug_stream_type
+
+/*!\brief The printer for alignment scoring and trace matrices.
  *
- * \details
+ * Prints the alignment matrix to the given formatted ouput stream.
  *
- * This prints out an alignment matrix which can be a score matrix or a trace matrix.
+ * \tparam alignment_matrix_t The type of the alignment matrix; must model seqan3::detail::matrix.
+ * \ingroup alignment_matrix
  */
-template <typename char_t, detail::matrix alignment_matrix_t>
-inline debug_stream_type<char_t> & operator<<(debug_stream_type<char_t> & s, alignment_matrix_t && matrix)
+template <detail::matrix alignment_matrix_t>
+struct alignment_matrix_printer<alignment_matrix_t>
 {
-    detail::debug_matrix debug{std::forward<alignment_matrix_t>(matrix)};
-
-    std::stringstream sstream{};
-    debug.stream_matrix(sstream, s.flags2());
-    s << sstream.str();
-    return s;
-}
-
-//!\overload
-template <typename char_t, std::ranges::input_range alignment_matrix_t>
-    requires detail::debug_stream_range_guard<alignment_matrix_t> && detail::matrix<alignment_matrix_t>
-inline debug_stream_type<char_t> & operator<<(debug_stream_type<char_t> & s, alignment_matrix_t && matrix)
-{
-    return s << detail::debug_matrix{std::forward<alignment_matrix_t>(matrix)};
-}
+    /*!\brief Prints the alignment matrix into the given stream using formatting specified by seqan3::fmtflags2.
+     *
+     * This overload is selected if the stream is a seqan3::debug_stream_type and has a `flags2()` member function that
+     * returns a seqan3::fmtflags2 object.
+     * Using the flags2() member function allows to print the matrix with unicode characters if seqan3::fmtflags2::utf8
+     * is set to the seqan3::debug_stream.
+     *
+     * \tparam stream_t The type of the stream.
+     * \tparam arg_t The type of the argument.
+     * \param stream The stream to print to.
+     * \param arg The alignment matrix to print
+     */
+    template <typename stream_t, typename arg_t>
+        requires detail::is_type_specialisation_of_v<stream_t, debug_stream_type>
+    constexpr void operator()(stream_t & stream, arg_t && arg) const
+    {
+        print_impl(stream.get_underlying_stream(), stream.flags2(), std::forward<arg_t>(arg));
+    }
+
+    /*!\brief Prints the alignment matrix into the given stream using ascii formatting.
+     *
+     * This overload is selected if the stream is \b not a seqan3::debug_stream_type and always prints
+     * with seqan3::fmtflags2::none.
+     *
+     * \tparam stream_t The type of the stream.
+     * \tparam arg_t The type of the argument.
+     * \param stream The stream to print to.
+     * \param arg The alignment matrix to print.
+     */
+    template <typename stream_t, typename arg_t>
+    constexpr void operator()(stream_t & stream, arg_t && arg) const
+    {
+        print_impl(stream, fmtflags2::none, std::forward<arg_t>(arg));
+    }
+
+private:
+    /*!\brief Prints the alignment matrix into the given formatted output stream.
+     * \tparam stream_t The type of the stream.
+     * \tparam arg_t The type of the argument.
+     * \param stream The stream to print to.
+     * \param flags The flags to modify the way the matrix is printed.
+     * \param arg The alignment matrix to print.
+     */
+    template <typename stream_t, typename arg_t>
+    void print_impl(stream_t & stream, fmtflags2 const flags, arg_t && arg) const
+    {
+        detail::debug_matrix debug{std::forward<arg_t>(arg)};
+
+        debug.stream_matrix(stream, flags);
+    }
+};
 
 } // namespace seqan3
diff --git a/include/seqan3/alignment/matrix/detail/trace_directions.hpp b/include/seqan3/alignment/matrix/detail/trace_directions.hpp
index 1cb9648d94..f518a95b79 100644
--- a/include/seqan3/alignment/matrix/detail/trace_directions.hpp
+++ b/include/seqan3/alignment/matrix/detail/trace_directions.hpp
@@ -9,8 +9,12 @@
 
 #pragma once
 
+#include <array>
+#include <string_view>
+
 #include <seqan3/core/add_enum_bitwise_operators.hpp>
 #include <seqan3/core/debug_stream/debug_stream_type.hpp>
+#include <seqan3/core/detail/template_inspection.hpp>
 
 namespace seqan3::detail
 {
@@ -54,12 +58,7 @@ template <>
 inline constexpr bool add_enum_bitwise_operators<seqan3::detail::trace_directions> = true;
 //!\endcond
 
-/*!\brief All trace_directions can be printed as ascii or as utf8 to the seqan3::debug_stream.
- * \param s The seqan3::debug_stream.
- * \param trace The trace direction.
- * \relates seqan3::debug_stream_type
- *
- * \details
+/*!\brief Prints `trace_directions` as ascii or as utf8 to output stream.
  *
  * The following table shows the printed symbol of a particular seqan3::detail::trace_directions:
  *
@@ -71,23 +70,71 @@ inline constexpr bool add_enum_bitwise_operators<seqan3::detail::trace_direction
  * | seqan3::detail::trace_directions::up        | ⇡    | u     |
  * | seqan3::detail::trace_directions::left_open | ←    | L     |
  * | seqan3::detail::trace_directions::left      | ⇠    | l     |
+ *
+ * \ingroup alignment_matrix
  */
-template <typename char_t>
-inline debug_stream_type<char_t> & operator<<(debug_stream_type<char_t> & s, detail::trace_directions const trace)
+template <>
+struct trace_directions_printer<detail::trace_directions>
 {
-    static char const * unicode[32]{"↺",   "↖",    "↑",   "↖↑",  "⇡",    "↖⇡",   "↑⇡",  "↖↑⇡",  "←",    "↖←",   "↑←",
-                                    "↖↑←", "⇡←",   "↖⇡←", "↑⇡←", "↖↑⇡←", "⇠",    "↖⇠",  "↑⇠",   "↖↑⇠",  "⇡⇠",   "↖⇡⇠",
-                                    "↑⇡⇠", "↖↑⇡⇠", "←⇠",  "↖←⇠", "↑←⇠",  "↖↑←⇠", "⇡←⇠", "↖⇡←⇠", "↑⇡←⇠", "↖↑⇡←⇠"};
+private:
+    //!\brief The unicode representation of the trace directions.
+    static constexpr std::array<std::string_view, 32> unicode{
+        "↺", "↖",  "↑",  "↖↑",  "⇡",  "↖⇡",  "↑⇡",  "↖↑⇡",  "←",  "↖←",  "↑←",  "↖↑←",  "⇡←",  "↖⇡←",  "↑⇡←",  "↖↑⇡←",
+        "⇠", "↖⇠", "↑⇠", "↖↑⇠", "⇡⇠", "↖⇡⇠", "↑⇡⇠", "↖↑⇡⇠", "←⇠", "↖←⇠", "↑←⇠", "↖↑←⇠", "⇡←⇠", "↖⇡←⇠", "↑⇡←⇠", "↖↑⇡←⇠"};
+
+    //!\brief The ascii representation of the trace directions.
+    static constexpr std::array<std::string_view, 32> csv{
+        "N", "D",  "U",  "DU",  "u",  "Du",  "Uu",  "DUu",  "L",  "DL",  "UL",  "DUL",  "uL",  "DuL",  "UuL",  "DUuL",
+        "l", "Dl", "Ul", "DUl", "ul", "Dul", "Uul", "DUul", "Ll", "DLl", "ULl", "DULl", "uLl", "DuLl", "UuLl", "DUuLl"};
 
-    static char const * csv[32]{"N",   "D",    "U",   "DU",  "u",    "Du",   "Uu",  "DUu",  "L",    "DL",   "UL",
-                                "DUL", "uL",   "DuL", "UuL", "DUuL", "l",    "Dl",  "Ul",   "DUl",  "ul",   "Dul",
-                                "Uul", "DUul", "Ll",  "DLl", "ULl",  "DULl", "uLl", "DuLl", "UuLl", "DUuLl"};
+public:
+    /*!\brief Prints the trace directions into the given stream.
+     *
+     * This overload is only available if the stream has a member function `flags2` that returns a `fmtflags2`.
+     * Using the flags2() member function allows to print the trace with unicode characters if seqan3::fmtflags2::utf8
+     * is set to the seqan3::debug_stream.
+     *
+     * \tparam stream_t The type of the stream.
+     * \param stream The stream to print to.
+     * \param trace The trace directions to print.
+     */
+    template <typename stream_t>
+        requires detail::is_type_specialisation_of_v<stream_t, debug_stream_type>
+    constexpr void operator()(stream_t & stream, detail::trace_directions const trace) const
+    {
+        print_impl(stream, stream.flags2(), trace);
+    }
 
-    bool is_unicode = (s.flags2() & fmtflags2::utf8) == fmtflags2::utf8;
-    auto const & trace_dir = is_unicode ? unicode : csv;
+    /*!\brief Prints the trace directions into the given stream.
+     *
+     * This overload is only available if the stream has no member function `flags2`. In this case it will use
+     * ascii characters to print the trace.
+     *
+     * \tparam stream_t The type of the stream.
+     * \param stream The stream to print to.
+     * \param trace The trace directions to print.
+     */
+    template <typename stream_t>
+    constexpr void operator()(stream_t & stream, detail::trace_directions const trace) const
+    {
+        print_impl(stream, fmtflags2::none, trace);
+    }
 
-    s << trace_dir[static_cast<size_t>(trace)];
-    return s;
-}
+private:
+    /*!\brief Prints the trace directions
+     * \tparam stream_t The type of the stream.
+     * \param stream The stream to print to.
+     * \param flag The flags of the stream.
+     * \param trace The trace directions to print.
+     */
+    template <typename stream_t>
+    constexpr void print_impl(stream_t & stream, fmtflags2 const flag, detail::trace_directions const trace) const
+    {
+        bool const is_unicode = (flag & fmtflags2::utf8) == fmtflags2::utf8;
+        auto const & trace_dir = is_unicode ? unicode : csv;
+
+        stream << trace_dir[static_cast<size_t>(trace)];
+    }
+};
 
 } // namespace seqan3
diff --git a/include/seqan3/alignment/pairwise/alignment_result.hpp b/include/seqan3/alignment/pairwise/alignment_result.hpp
index 04774ce76d..8ef58b6751 100644
--- a/include/seqan3/alignment/pairwise/alignment_result.hpp
+++ b/include/seqan3/alignment/pairwise/alignment_result.hpp
@@ -10,6 +10,7 @@
 
 #pragma once
 
+#include <concepts>
 #include <optional>
 
 #include <seqan3/core/configuration/configuration.hpp>
@@ -171,6 +172,9 @@ class alignment_result
         requires seqan3::detail::is_type_specialisation_of_v<configuration_t, configuration>
     friend class detail::policy_alignment_result_builder;
 
+    template <typename>
+    friend struct alignment_result_printer;
+
 public:
     /*!\name Constructors, destructor and assignment
      * \{
@@ -401,54 +405,58 @@ struct alignment_result_value_type_accessor<alignment_result<result_value_t>>
 
 namespace seqan3
 {
-/*!\brief Streams the seqan3::alignment_result to the seqan3::debug_stream.
+
+/*!\brief The printer used for formatted output of the alignment result.
  *
- * \tparam char_t The underlying character type of the seqan3::debug_stream_type.
- * \tparam alignment_result_t A type specialisation of seqan3::alignment_result.
+ * The type of the printer must be a seqan3::alignment_result type.
  *
- * \param[in,out] stream The output stream.
- * \param[in] result The alignment result to print.
- * \relates seqan3::debug_stream_type
+ * \tparam result_value_t The type of the alignment result value.
+ * \ingroup alignment_pairwise
  */
-template <typename char_t, typename alignment_result_t>
-    requires detail::is_type_specialisation_of_v<std::remove_cvref_t<alignment_result_t>, alignment_result>
-inline debug_stream_type<char_t> & operator<<(debug_stream_type<char_t> & stream, alignment_result_t && result)
+template <typename result_value_t>
+struct alignment_result_printer<alignment_result<result_value_t>>
 {
-    using disabled_t = std::nullopt_t *;
-    using result_data_t =
-        typename detail::alignment_result_value_type_accessor<std::remove_cvref_t<alignment_result_t>>::type;
-
-    constexpr bool has_sequence1_id = !std::is_same_v<decltype(std::declval<result_data_t>().sequence1_id), disabled_t>;
-    constexpr bool has_sequence2_id = !std::is_same_v<decltype(std::declval<result_data_t>().sequence2_id), disabled_t>;
-    constexpr bool has_score = !std::is_same_v<decltype(std::declval<result_data_t>().score), disabled_t>;
-    constexpr bool has_end_positions =
-        !std::is_same_v<decltype(std::declval<result_data_t>().end_positions), disabled_t>;
-    constexpr bool has_begin_positions =
-        !std::is_same_v<decltype(std::declval<result_data_t>().begin_positions), disabled_t>;
-    constexpr bool has_alignment = !std::is_same_v<decltype(std::declval<result_data_t>().alignment), disabled_t>;
-
-    bool prepend_comma = false;
-    auto append_to_stream = [&](auto &&... args)
+    /*!\brief Prints the formatted output of the alignment result to the stream.
+     * \tparam stream_t The type of the stream.
+     * \tparam arg_t The type of the argument.
+     * \param[in,out] stream The output stream.
+     * \param[in] arg The alignment result to print.
+     */
+    template <typename stream_t, typename arg_t>
+    constexpr void operator()(stream_t & stream, arg_t && arg) const noexcept
     {
-        ((stream << (prepend_comma ? std::string{", "} : std::string{})) << ... << std::forward<decltype(args)>(args));
-        prepend_comma = true;
-    };
-
-    stream << '{';
-    if constexpr (has_sequence1_id)
-        append_to_stream("sequence1 id: ", result.sequence1_id());
-    if constexpr (has_sequence2_id)
-        append_to_stream("sequence2 id: ", result.sequence2_id());
-    if constexpr (has_score)
-        append_to_stream("score: ", result.score());
-    if constexpr (has_begin_positions)
-        append_to_stream("begin: (", result.sequence1_begin_position(), ",", result.sequence2_begin_position(), ")");
-    if constexpr (has_end_positions)
-        append_to_stream("end: (", result.sequence1_end_position(), ",", result.sequence2_end_position(), ")");
-    if constexpr (has_alignment)
-        append_to_stream("\nalignment:\n", result.alignment());
-    stream << '}';
-
-    return stream;
-}
+        using disabled_t = std::nullopt_t *;
+        using result_t = std::remove_cvref_t<arg_t>;
+        constexpr bool has_sequence1_id = !std::is_same_v<typename result_t::sequence1_id_t, disabled_t>;
+        constexpr bool has_sequence2_id = !std::is_same_v<typename result_t::sequence2_id_t, disabled_t>;
+        constexpr bool has_score = !std::is_same_v<typename result_t::score_t, disabled_t>;
+        constexpr bool has_end_positions = !std::is_same_v<typename result_t::end_positions_t, disabled_t>;
+        constexpr bool has_begin_positions = !std::is_same_v<typename result_t::begin_positions_t, disabled_t>;
+        constexpr bool has_alignment = !std::is_same_v<typename result_t::alignment_t, disabled_t>;
+
+        bool prepend_comma = false;
+        auto append_to_stream = [&](auto &&... args)
+        {
+            ((stream << (prepend_comma ? std::string{", "} : std::string{}))
+             << ... << std::forward<decltype(args)>(args));
+            prepend_comma = true;
+        };
+
+        stream << '{';
+        if constexpr (has_sequence1_id)
+            append_to_stream("sequence1 id: ", arg.sequence1_id());
+        if constexpr (has_sequence2_id)
+            append_to_stream("sequence2 id: ", arg.sequence2_id());
+        if constexpr (has_score)
+            append_to_stream("score: ", arg.score());
+        if constexpr (has_begin_positions)
+            append_to_stream("begin: (", arg.sequence1_begin_position(), ",", arg.sequence2_begin_position(), ")");
+        if constexpr (has_end_positions)
+            append_to_stream("end: (", arg.sequence1_end_position(), ",", arg.sequence2_end_position(), ")");
+        if constexpr (has_alignment)
+            append_to_stream("\nalignment:\n", arg.alignment());
+        stream << '}';
+    }
+};
+
 } // namespace seqan3
diff --git a/include/seqan3/alphabet/cigar/cigar.hpp b/include/seqan3/alphabet/cigar/cigar.hpp
index 1463901d7c..fd006ac69f 100644
--- a/include/seqan3/alphabet/cigar/cigar.hpp
+++ b/include/seqan3/alphabet/cigar/cigar.hpp
@@ -207,13 +207,26 @@ class cigar : public alphabet_tuple_base<cigar, uint32_t, exposition_only::cigar
     //!\}
 };
 
-//!\brief Overload for the seqan3::debug_stream's operator.
-template <typename char_t>
-inline debug_stream_type<char_t> & operator<<(debug_stream_type<char_t> & s, cigar const c)
+/*!\brief The printer used for formatted output of the cigar alphabets.
+ *
+ * The type of the printer must be a seqan3::cigar type.
+ *
+ * \ingroup alphabet_cigar
+ */
+template <>
+struct cigar_printer<cigar>
 {
-    s << c.to_string();
-    return s;
-}
+    /*!\brief Prints the formatted output of the cigar symbol to the stream.
+     * \tparam stream_t The type of the stream.
+     * \param[in,out] stream The output stream.
+     * \param[in] arg The cigar symbol to print.
+     */
+    template <typename stream_t>
+    constexpr void operator()(stream_t & stream, cigar const arg) const noexcept
+    {
+        stream << arg.to_string();
+    }
+};
 
 inline namespace literals
 {
diff --git a/include/seqan3/alphabet/concept.hpp b/include/seqan3/alphabet/concept.hpp
index 5e43ebf3ce..80e03b063e 100644
--- a/include/seqan3/alphabet/concept.hpp
+++ b/include/seqan3/alphabet/concept.hpp
@@ -1065,8 +1065,7 @@ concept writable_alphabet = alphabet<t> && writable_semialphabet<t> && requires
  *
  * \{
  */
-/*!
- * \brief Save an alphabet letter to stream.
+/*!\brief Save an alphabet letter to stream.
  * \tparam archive_t Must satisfy seqan3::cereal_output_archive.
  * \tparam alphabet_t Type of l; must satisfy seqan3::semialphabet.
  * \param l The alphabet letter.
diff --git a/include/seqan3/alphabet/detail/debug_stream_alphabet.hpp b/include/seqan3/alphabet/detail/debug_stream_alphabet.hpp
index 9b7e8e0fe7..a75bc026d3 100644
--- a/include/seqan3/alphabet/detail/debug_stream_alphabet.hpp
+++ b/include/seqan3/alphabet/detail/debug_stream_alphabet.hpp
@@ -15,38 +15,53 @@
 
 namespace seqan3
 {
-/*!\name Formatted output overloads
- * \{
- */
-/*!\brief All alphabets can be printed to the seqan3::debug_stream by their char representation.
- * \tparam alphabet_t Type of the alphabet to be printed; must model seqan3::alphabet.
- * \param s The seqan3::debug_stream.
- * \param l The alphabet letter.
- * \relates seqan3::debug_stream_type
+
+/*!\brief The printer used for formatted output of seqan3::alphabet types.
+ *
+ * Prints the char representation of the given alphabet letter.
+ *
+ * \tparam alphabet_t The type of the alphabet to be printed.
+ * \ingroup alphabet
  */
-template <typename char_t, alphabet alphabet_t>
-inline debug_stream_type<char_t> & operator<<(debug_stream_type<char_t> & s, alphabet_t && l)
-    requires (!output_stream_over<std::basic_ostream<char_t>, alphabet_t>)
+template <alphabet alphabet_t>
+struct alphabet_printer<alphabet_t>
 {
-    return s << to_char(l);
-}
+    /*!\brief Print the alphabet to the stream
+     * \tparam stream_t The type of the stream.
+     * \param[in,out] stream The stream to print to.
+     * \param[in] letter The alphabet letter.
+     */
+    template <typename stream_t>
+    constexpr void operator()(stream_t & stream, alphabet_t const letter) const noexcept
+    {
+        stream << to_char(letter);
+    }
+};
 
 // forward declare seqan3::mask
 class mask;
 
-/*!\brief Overload for the seqan3::mask alphabet.
- * \tparam char_t Type char type of the debug_stream.
- * \param s The seqan3::debug_stream.
- * \param l The mask alphabet letter.
- * \relates seqan3::debug_stream_type
+/*!\brief The printer used for formatted output of seqan3::mask alphabet.
+ *
+ * Prints "MASKED" if the letter is masked and "UNMASKED" otherwise.
+ *
+ * \tparam mask_t The type of the alphabet to be printed. Must be seqan3::mask.
+ * \ingroup alphabet_mask
  */
-template <typename char_t, seqan3::semialphabet alphabet_t>
-inline debug_stream_type<char_t> & operator<<(debug_stream_type<char_t> & s, alphabet_t && l)
-    requires std::same_as<std::remove_cvref_t<alphabet_t>, mask>
+template <std::same_as<mask> mask_t>
+struct mask_printer<mask_t>
 {
-    return s << (l == alphabet_t{} ? "UNMASKED" : "MASKED");
-}
-
-//!\}
+    /*!\brief Print the mask alphabet to the stream
+     * \tparam stream_t The type of the stream.
+     * \param[in,out] stream The stream to print to.
+     * \param[in] arg The mask alphabet letter.
+     */
+    template <typename stream_t>
+    constexpr void operator()(stream_t & stream, mask_t const arg) const noexcept
+    {
+        // seqan3::mask is incomplete at this point, so we cannot use `arg == mask{}`
+        stream << (arg == mask_t{} ? "UNMASKED" : "MASKED");
+    }
+};
 
 } // namespace seqan3
diff --git a/include/seqan3/argument_parser/auxiliary.hpp b/include/seqan3/argument_parser/auxiliary.hpp
index d5af167bca..54461e18e8 100644
--- a/include/seqan3/argument_parser/auxiliary.hpp
+++ b/include/seqan3/argument_parser/auxiliary.hpp
@@ -201,33 +201,39 @@ concept argument_parser_compatible_option =
     input_stream_over<std::istringstream, option_type> || named_enumeration<option_type>;
 //!\endcond
 
-/*!\name Formatted output overloads
- * \{
- */
 /*!\brief A type (e.g. an enum) can be made debug streamable by customizing the seqan3::enumeration_names.
- * \tparam option_type Type of the enum to be printed.
- * \param s  The seqan3::debug_stream.
- * \param op The value to print.
- * \relates seqan3::debug_stream_type
- *
- * \details
  *
  * This searches the seqan3::enumeration_names of the respective type for the value \p op and prints the
  * respective string if found or '\<UNKNOWN_VALUE\>' if the value cannot be found in the map.
+ *
+ * \tparam enum_t Type of the enum to be printed; must model seqan3::named_enumeration.
+ * \ingroup argument_parser
  */
-template <typename char_t, typename option_type>
-    requires named_enumeration<std::remove_cvref_t<option_type>>
-inline debug_stream_type<char_t> & operator<<(debug_stream_type<char_t> & s, option_type && op)
+template <named_enumeration enum_t>
+struct enumeration_printer<enum_t>
 {
-    for (auto & [key, value] : enumeration_names<option_type>)
+    /*!\brief Prints the associated label of the given enum value.
+     * \tparam stream_t The type of the stream.
+     * \param[in,out] stream The output stream.
+     * \param[in] arg The enum value to print.
+     *
+     * If for the given enumeration value no enumeration name can be found, "<UNKNOWN_VALUE>" is printed.
+     */
+    template <typename stream_t>
+    constexpr void operator()(stream_t & stream, enum_t const arg) const
     {
-        if (op == value)
-            return s << key;
-    }
+        for (auto & [label, enumerator] : enumeration_names<enum_t>)
+        {
+            if (arg == enumerator)
+            {
+                stream << label;
+                return;
+            }
+        }
 
-    return s << "<UNKNOWN_VALUE>";
-}
-//!\}
+        stream << "<UNKNOWN_VALUE>";
+    }
+};
 
 /*!\brief Used to further specify argument_parser options/flags.
  * \ingroup argument_parser
diff --git a/include/seqan3/core/debug_stream/byte.hpp b/include/seqan3/core/debug_stream/byte.hpp
index 2c39246f1e..6bccbcf1af 100644
--- a/include/seqan3/core/debug_stream/byte.hpp
+++ b/include/seqan3/core/debug_stream/byte.hpp
@@ -16,23 +16,22 @@
 
 namespace seqan3
 {
-/*!\name Formatted output overloads
- * \{
- */
 /*!\brief A std::byte can be printed by printing its value as integer.
- * \tparam    byte_type     The type of the input; must be equal to `std::byte`.
- * \param[in] s             The seqan3::debug_stream.
- * \param[in] arg           The std::byte.
- * \relates seqan3::debug_stream_type
+ * \ingroup core_debug_stream
  */
-template <typename char_t, typename byte_type>
-    requires std::same_as<std::remove_cvref_t<byte_type>, std::byte>
-inline debug_stream_type<char_t> & operator<<(debug_stream_type<char_t> & s, byte_type && arg)
+template <>
+struct std_byte_printer<std::byte>
 {
-    s << std::to_integer<uint8_t>(arg);
-    return s;
-}
-
-//!\}
+    /*!\brief Prints the byte as uint8_t value.
+     * \tparam stream_t The type of the stream.
+     * \param[in,out] stream The output stream.
+     * \param[in] arg The byte argument to print.
+     */
+    template <typename stream_t>
+    constexpr void operator()(stream_t & stream, std::byte const arg) const
+    {
+        stream << std::to_integer<uint8_t>(arg);
+    }
+};
 
 } // namespace seqan3
diff --git a/include/seqan3/core/debug_stream/debug_stream_type.hpp b/include/seqan3/core/debug_stream/debug_stream_type.hpp
index 56c74def92..18458972ea 100644
--- a/include/seqan3/core/debug_stream/debug_stream_type.hpp
+++ b/include/seqan3/core/debug_stream/debug_stream_type.hpp
@@ -9,9 +9,13 @@
 
 #pragma once
 
+#include <cassert>
 #include <iosfwd>
+#include <stdexcept>
 
 #include <seqan3/core/add_enum_bitwise_operators.hpp>
+#include <seqan3/core/debug_stream/default_printer.hpp>
+#include <seqan3/utility/detail/type_name_as_string.hpp>
 
 namespace seqan3
 {
@@ -114,6 +118,13 @@ class debug_stream_type
     {
         stream = &out;
     }
+
+    //!\brief Retrieve the underlying stream.
+    std::basic_ostream<char_t> & get_underlying_stream() const noexcept
+    {
+        assert(stream != nullptr);
+        return *stream;
+    }
     //!\}
 
     /*!\name Formatted output
@@ -121,7 +132,19 @@ class debug_stream_type
      */
     //!\brief Forwards to the underlying stream object.
     template <typename other_char_t, typename t>
-    friend debug_stream_type<other_char_t> & operator<<(debug_stream_type<other_char_t> & s, t && v);
+    friend debug_stream_type<other_char_t> & operator<<(debug_stream_type<other_char_t> & s, t && v)
+    {
+        if constexpr (printable_with<default_printer, decltype(s), t>)
+        {
+            std::invoke(default_printer{}, s, std::forward<t>(v));
+        }
+        else
+        {
+            std::string const msg = "debug_stream has no print overload for type: " + detail::type_name_as_string<t>;
+            throw std::runtime_error{msg};
+        }
+        return s;
+    }
 
     //!\brief This overloads enables forwarding std::endl and other manipulators.
     debug_stream_type & operator<<(std::ostream & (*fp)(std::ostream &))
@@ -130,27 +153,14 @@ class debug_stream_type
         return *this;
     }
 
-    //!\cond
-    debug_stream_type & operator<<(int8_t const v)
-    {
-        if ((flags2() & fmtflags2::small_int_as_number) == fmtflags2::small_int_as_number)
-            *stream << static_cast<int>(v);
-        else
-            *stream << v;
-        return *this;
-    }
-
-    debug_stream_type & operator<<(uint8_t const v)
-    {
-        if ((flags2() & fmtflags2::small_int_as_number) == fmtflags2::small_int_as_number)
-            *stream << static_cast<unsigned>(v);
-        else
-            *stream << v;
-        return *this;
-    }
-    //!\endcond
     //!\}
 
+    template <typename T>
+    friend struct debug_stream_printer;
+
+    template <typename T>
+    friend struct std_printer;
+
     //!\brief This type is std::ios_base::fmtflags
     using fmtflags = typename std::basic_ostream<char_t>::fmtflags;
 
@@ -182,17 +192,6 @@ class debug_stream_type
         stream->unsetf(flag);
     }
 
-// fmtflags is an enum in libstdc++ and an unsigned in libc++
-#ifdef _LIBCPP_VERSION
-    static_assert(std::same_as<fmtflags, unsigned>);
-#else
-    //!\copybrief setf()
-    debug_stream_type & operator<<(fmtflags const flag)
-    {
-        setf(flag);
-        return *this;
-    }
-#endif
     //!\}
 
     /*!\name Format flags (seqan3::fmtflags2)
@@ -224,12 +223,6 @@ class debug_stream_type
         flgs2 &= ~flag;
     }
 
-    //!\copybrief setf()
-    debug_stream_type & operator<<(fmtflags2 const flag)
-    {
-        setf(flag);
-        return *this;
-    }
     //!\}
 
 private:
@@ -240,12 +233,72 @@ class debug_stream_type
     fmtflags2 flgs2{fmtflags2::default_};
 };
 
-//!\brief Forwards to the underlying stream object.
-template <typename char_t, typename t>
-debug_stream_type<char_t> & operator<<(debug_stream_type<char_t> & s, t && v)
+/*!\brief A struct that provides a debug stream printer for a specific value type.
+ *
+ * This struct provides operator() overloads for printing values of type int8_t, uint8_t, and seqan3::fmtflags2
+ * to a debug stream. The operator() overloads handle the formatting of the values based on the
+ * fmtflags2 settings of the debug stream.
+ *
+ * \tparam value_t The type of the value to be printed.
+ * \ingroup core_debug_stream
+ */
+template <typename value_t>
+    requires (std::is_same_v<std::remove_cvref_t<value_t>, int8_t>
+              || std::is_same_v<std::remove_cvref_t<value_t>, uint8_t>
+              || std::is_same_v<std::remove_cvref_t<value_t>, fmtflags2>)
+struct debug_stream_printer<value_t>
 {
-    (*s.stream) << v;
-    return s;
-}
+    /*!\brief Prints an int8_t value to the debug stream.
+     *
+     * \tparam char_t The character type of the debug stream.
+     * \param stream The debug stream to print to.
+     * \param v The int8_t value to be printed.
+     *
+     * This function prints the int8_t value to the debug stream, taking into account the
+     * fmtflags2 settings of the stream. If the fmtflags2::small_int_as_number flag is set,
+     * the value is printed as an int, otherwise it is printed as is.
+     */
+    template <typename char_t>
+    constexpr void operator()(debug_stream_type<char_t> & stream, int8_t const v) const
+    {
+        if ((stream.flags2() & fmtflags2::small_int_as_number) == fmtflags2::small_int_as_number)
+            *stream.stream << static_cast<int>(v);
+        else
+            *stream.stream << v;
+    }
+
+    /*!\brief Prints a uint8_t value to the debug stream.
+     *
+     * \tparam char_t The character type of the debug stream.
+     * \param stream The debug stream to print to.
+     * \param v The uint8_t value to be printed.
+     *
+     * This function prints the uint8_t value to the debug stream, taking into account the
+     * fmtflags2 settings of the stream. If the fmtflags2::small_int_as_number flag is set,
+     * the value is printed as an unsigned int, otherwise it is printed as is.
+     */
+    template <typename char_t>
+    constexpr void operator()(debug_stream_type<char_t> & stream, uint8_t const v) const
+    {
+        if ((stream.flags2() & fmtflags2::small_int_as_number) == fmtflags2::small_int_as_number)
+            *stream.stream << static_cast<unsigned>(v);
+        else
+            *stream.stream << v;
+    }
+
+    /*!\brief Sets the fmtflags2 of the debug stream.
+     *
+     * \tparam char_t The character type of the debug stream.
+     * \param stream The debug stream to set the fmtflags2 for.
+     * \param flag The fmtflags2 value to set.
+     *
+     * This function sets the fmtflags2 of the debug stream to the specified flag value.
+     */
+    template <typename char_t>
+    constexpr void operator()(debug_stream_type<char_t> & stream, fmtflags2 const flag) const
+    {
+        stream.setf(flag);
+    }
+};
 
 } // namespace seqan3
diff --git a/include/seqan3/core/debug_stream/default_printer.hpp b/include/seqan3/core/debug_stream/default_printer.hpp
new file mode 100644
index 0000000000..d0f24d6bcc
--- /dev/null
+++ b/include/seqan3/core/debug_stream/default_printer.hpp
@@ -0,0 +1,236 @@
+// SPDX-FileCopyrightText: 2006-2024 Knut Reinert & Freie Universität Berlin
+// SPDX-FileCopyrightText: 2016-2024 Knut Reinert & MPI für molekulare Genetik
+// SPDX-License-Identifier: BSD-3-Clause
+
+/*!\file
+ * \author Marcel Ehrhardt <marcel.ehrhardt AT fu-berlin.de>
+ * \brief Provides seqan3::default_printer.
+ */
+
+#pragma once
+
+#include <functional>
+#include <iosfwd>
+#include <tuple>
+#include <utility>
+
+#include <seqan3/core/platform.hpp>
+
+namespace seqan3
+{
+
+// clang-format off
+/*!\brief A tag that indicates that no printer was found for the given type.
+ * \ingroup core_debug_stream
+ */
+struct no_printer_found{};
+template <typename> struct advanceable_alignment_coordinate_printer {};
+template <typename> struct alignment_matrix_printer {};
+template <typename> struct alignment_printer {};
+template <typename> struct alignment_result_printer {};
+template <typename> struct alphabet_printer {};
+template <typename> struct cigar_printer {};
+template <typename> struct debug_stream_printer {};
+template <typename> struct dynamic_bitset_printer {};
+template <typename> struct enumeration_printer {};
+template <typename> struct input_range_printer {};
+template <typename> struct integer_sequence_printer {};
+template <typename> struct integral_printer {};
+template <typename> struct mask_printer {};
+template <typename> struct optional_printer {};
+template <typename> struct sam_flag_printer {};
+template <typename> struct sequence_printer {};
+template <typename> struct search_result_printer {};
+template <typename> struct simd_printer {};
+template <typename> struct std_byte_printer {};
+template <typename> struct std_variant_printer {};
+template <typename> struct std_printer {};
+template <typename> struct strong_type_printer {};
+template <typename> struct char_sequence_printer {};
+template <typename> struct trace_directions_printer {};
+template <typename> struct tuple_printer {};
+// clang-format on
+
+/*!
+ * \interface seqan3::printable_with <>
+ * \brief The concept for a printable object.
+ *
+ * A printable object is a printer that can print an argument to a stream.
+ * The printer must be invocable with a stream and an argument.
+ *
+ * \tparam printer_t The type of the printer.
+ * \tparam stream_t The type of the stream.
+ * \tparam arg_t The type of the argument.
+ * \ingroup core_debug_stream
+ */
+template <typename printer_t, typename stream_t, typename arg_t>
+concept printable_with = std::invocable<printer_t, stream_t, arg_t>;
+
+/*!\brief The printer for standard output streams.
+ *
+ * The std_printer is used as a generic fallback to print regular types that can be printed to a
+ * standard output stream, e.g. std::cout.
+ *
+ * \tparam type_t The type of the printable argument.
+ * \ingroup core_debug_stream
+ */
+template <typename type_t>
+    requires requires (std::ostream & cout, type_t const & value) {
+        { cout << value };
+    }
+struct std_printer<type_t>
+{
+    /*!\brief The function call operator that prints the value to the stream.
+     *
+     * This function call operator prints the value to underlying stream of the seqan3::debug_stream.
+     * This overload is only provided if the stream is a seqan3::debug_stream.
+     *
+     * \tparam stream_t The type of the stream.
+     * \tparam arg_t The type of the argument.
+     * \param[in,out] stream The stream to print to.
+     * \param[in] arg The value to print.
+     */
+    template <typename stream_t, typename arg_t>
+        requires requires (stream_t & stream) { stream.stream; }
+    constexpr void operator()(stream_t & stream, arg_t && arg) const
+    {
+        *stream.stream << arg;
+    }
+};
+
+/*!
+ 8 \brief The printer for integral types.
+ *
+ * The integral_printer is used to print integral types to a stream.
+ *
+ * \tparam integral_t The type of the integral.
+ * \ingroup core_debug_stream
+ */
+template <std::integral integral_t>
+struct integral_printer<integral_t>
+{
+    /*!\brief The function call operator that prints the integral to the stream.
+     * \tparam stream_t The type of the stream.
+     * \param[in,out] stream The stream to print to.
+     * \param[in] arg The integral to print.
+     */
+    template <typename stream_t>
+    constexpr void operator()(stream_t & stream, integral_t const arg) const
+    {
+        // note that we assume here that we always can print all std::integral's,
+        // but this is not correct since std::cout << char32_t{5}; is not possible.
+        // since char32_t is also an alphabet, we avoid infinite recursion here.
+        if constexpr (printable_with<std_printer<integral_t>, stream_t &, integral_t>)
+            std::invoke(std_printer<integral_t>{}, stream, arg);
+        else
+            static_assert(std::same_as<integral_t *, void>, "This type is not printable.");
+        // We actually want `static_assert(false, "This type is not printable.");`.
+        // But this only works starting with GCC13. Before that, also the `if constexpr` branches that are not taken
+        // are evaluated and `static_assert(false)` will always result in an error. As a pre-GCC13 workaround,
+        // we can make the `false` dependent on some template type, which then will only be evaluated if the branch is
+        // taken.
+    }
+};
+
+/*!\brief The printer_order is a variadic template that defines the order of the printers.
+ *
+ * The printer_order is a variadic template that defines the order of the printers.
+ * It is used to find the first valid printer among all given printers that can print the argument to the given stream.
+ * The printer_order is used by the seqan3::default_printer.
+ *
+ * \tparam printer_templates_t The printer class templates that are used to print the arguments.
+ * \ingroup core_debug_stream
+ */
+template <template <typename> typename... printer_templates_t>
+struct printer_order
+{
+protected:
+    /*!\brief Find the index of the first printer that can print the argument.
+     * \tparam stream_t The type of the stream.
+     * \tparam arg_t The type of the argument.
+     * \tparam printers_t The printer class templates that are used to print the arguments.
+     * \returns The index of the printer that can print the argument or `n`, where `n` is equal to the
+     * number of printers, if no printer was found.
+     */
+    template <typename stream_t, typename arg_t, typename... printers_t>
+    static constexpr size_t find_index()
+    {
+        size_t i = 0;
+        return ((printable_with<printers_t, stream_t, arg_t> ? false : ++i) && ...) ? sizeof...(printer_templates_t)
+                                                                                    : i;
+    }
+
+    /*!\brief The type of the printer that can print the argument to the stream.
+     *
+     * In case no valid printer is found for the argument and stream type the seqan3::no_printer_found is used.
+     *
+     * \tparam stream_t The type of the stream.
+     * \tparam arg_t The type of the argument.
+     * \tparam i The index of the printer that can print the argument (default initialised to the index of the printer
+     * in the list that can print the argument to the stream).
+     */
+    template <typename stream_t,
+              typename arg_t,
+              size_t i = find_index<stream_t, arg_t, printer_templates_t<arg_t>...>()>
+    using printer_for_t =
+        // first: the index of the printer that can print the arguments or sizeof...(printers_t) if no printer was found
+        // second: the tuple of instantiated printers extended with no_printer_found
+        std::tuple_element_t<i, std::tuple<printer_templates_t<arg_t>..., no_printer_found>>;
+};
+
+/*!\brief The default printer that is used by seqan3::debug_stream.
+ *
+ * This printer offers a function call operator if the type is printable by one of the printers defined
+ * in the seqan3::printer_order.
+ * If no valid printer is found the function call operator is not defined.
+ *
+ * \ingroup core_debug_stream
+ */
+struct default_printer :
+    public printer_order<
+        debug_stream_printer,
+        alignment_result_printer,                 // type seqan3::alignment_result<>
+        search_result_printer,                    // type seqan3::search_result<>
+        alignment_printer,                        // concept seqan3::tuple_like<>
+        advanceable_alignment_coordinate_printer, // type seqan3::detail::advanceable_alignment_coordinate<>
+        alignment_matrix_printer,                 // concept seqan3::detail::matrix<>
+        trace_directions_printer,                 // type seqan3::detail::trace_directions
+        mask_printer,                             // type seqan3::mask
+        integral_printer,                         // concept std::integral
+        cigar_printer,                            // type seqan3::cigar
+        // NOTE: alphabet_printer needs the integral_printer overload, otherwise it might have infinite recursion due to
+        // char and uint being an alphabet
+        alphabet_printer,         // concept seqan3::alphabet
+        sam_flag_printer,         // type seqan3::sam_flag
+        simd_printer,             // concept simd::simd_concept<>
+        dynamic_bitset_printer,   // type seqan3::dynamic_bitset<>
+        char_sequence_printer,    // concept std::range::input_range<> with char value_type
+        integer_sequence_printer, // concept std::range::input_range<> with std::integral value_type
+        sequence_printer, // concept seqan3::sequence<>, i.e. std::range::input_range<> with seqan3::alphabet value_type
+        input_range_printer, // concept std::range::input_range<>
+        strong_type_printer, // concept seqan3::detail::derived_from_strong_type<>
+        optional_printer,    // type std::optional<> or std::nullopt_t
+        enumeration_printer, // types for which seqan3::enumeration_names is overloaded
+        tuple_printer,       // concept seqan3::tuple_like<>
+        std_byte_printer,    // type std::byte
+        std_variant_printer, // type std::variant<>
+        std_printer          // anything that can be printed by std::ostream
+        >
+{
+public:
+    /*!\brief The function call operator that is only defined if the type is printable.
+     * \tparam stream_t The type of the stream.
+     * \tparam arg_t The type of the argument.
+     * \param[in,out] stream The stream to print to.
+     * \param[in] arg The argument to print.
+     */
+    template <typename stream_t, typename arg_t>
+        requires printable_with<printer_for_t<stream_t &, std::remove_cvref_t<arg_t>>, stream_t &, arg_t>
+    constexpr void operator()(stream_t & stream, arg_t && arg) const
+    {
+        using printer_t = printer_for_t<stream_t &, std::remove_cvref_t<arg_t>>;
+        std::invoke(printer_t{}, stream, std::forward<arg_t>(arg));
+    }
+};
+
+} // namespace seqan3
diff --git a/include/seqan3/core/debug_stream/optional.hpp b/include/seqan3/core/debug_stream/optional.hpp
index 42344ac640..4c83b88300 100644
--- a/include/seqan3/core/debug_stream/optional.hpp
+++ b/include/seqan3/core/debug_stream/optional.hpp
@@ -17,39 +17,45 @@
 
 namespace seqan3
 {
-/*!\name Formatted output overloads
- * \{
- */
-/*!\brief Make std::nullopt_t printable.
- * \tparam    optional_type This is std::nullopt_t.
- * \param[in] s             The seqan3::debug_stream.
- * \param[in] arg           This is std::nullopt.
- * \relates seqan3::debug_stream_type
- */
-template <typename char_t>
-inline debug_stream_type<char_t> & operator<<(debug_stream_type<char_t> & s, std::nullopt_t SEQAN3_DOXYGEN_ONLY(arg))
+
+//!\brief Printer for formatted output of std::nullopt_t.
+//!\ingroup core_debug_stream
+template <>
+struct optional_printer<std::nullopt_t>
 {
-    s << "<VALUELESS_OPTIONAL>";
-    return s;
-}
-
-/*!\brief A std::optional can be printed by printing its value or nothing if valueless.
- * \tparam    optional_type The type of the optional.
- * \param[in] s             The seqan3::debug_stream.
- * \param[in] arg           The std::optional.
- * \relates seqan3::debug_stream_type
+    /*!\brief Prints `std::nullopt_t` to formatted output stream.
+     * \tparam stream_t The type of the stream to which the value is streamed.
+     * \param[in,out] stream The stream to print to.
+     * \param[in] arg The optional to print.
+     */
+    template <typename stream_t>
+    constexpr void operator()(stream_t & stream, std::nullopt_t const SEQAN3_DOXYGEN_ONLY(arg)) const
+    {
+        stream << "<VALUELESS_OPTIONAL>";
+    }
+};
+
+/*!\brief Printer for formatted output of a std::optional
+ * \tparam T The value type of the std::optional.
+ * \ingroup core_debug_stream
  */
-template <typename char_t, typename optional_type>
-    requires detail::is_type_specialisation_of_v<std::remove_cvref_t<optional_type>, std::optional>
-inline debug_stream_type<char_t> & operator<<(debug_stream_type<char_t> & s, optional_type && arg)
+template <typename T>
+struct optional_printer<std::optional<T>>
 {
-    if (arg.has_value())
-        s << *arg;
-    else
-        s << "<VALUELESS_OPTIONAL>";
-    return s;
-}
-
-//!\}
+    /*!\brief Print the optional to the stream by printing its value or nothing if valueless.
+     * \tparam stream_t The type of the stream.
+     * \tparam arg_t The type of the argument.
+     * \param[in,out] stream The stream to print to.
+     * \param[in] arg The optional to print.
+     */
+    template <typename stream_t, typename arg_t>
+    constexpr void operator()(stream_t & stream, arg_t && arg) const
+    {
+        if (arg.has_value())
+            stream << *arg;
+        else
+            stream << "<VALUELESS_OPTIONAL>";
+    }
+};
 
 } // namespace seqan3
diff --git a/include/seqan3/core/debug_stream/range.hpp b/include/seqan3/core/debug_stream/range.hpp
index 6875d65310..f1782a713d 100644
--- a/include/seqan3/core/debug_stream/range.hpp
+++ b/include/seqan3/core/debug_stream/range.hpp
@@ -9,6 +9,7 @@
 
 #pragma once
 
+#include <functional>
 #include <ranges>
 
 #include <seqan3/alphabet/adaptation/char.hpp>
@@ -17,128 +18,141 @@
 #include <seqan3/core/debug_stream/debug_stream_type.hpp>
 #include <seqan3/core/range/type_traits.hpp>
 
-namespace seqan3::detail
+namespace seqan3
 {
-/*!\brief A helper concept definition for ranges that can be streamed to the seqan3::debug_stream.
- * \tparam rng_t The range type to check.
- * \ingroup core_debug_stream
- *
- * \details
- *
- * This concept refines the std::ranges::input_range concept to allow streaming the range object to the debug stream,
- * with the following requirements:
- *
- * * `rng_t` is not the same type as `std::ranges::range_reference_t<rng_t>`,
- * * `rng_t` is not a pointer or c-style array,
- * * `std::ranges::range_reference_t<rng_t>` is not `char`.
- */
-template <typename rng_t>
-concept debug_stream_range_guard =
-    !std::same_as<std::remove_cvref_t<std::ranges::range_reference_t<rng_t>>, std::remove_cvref_t<rng_t>>
-    && !(std::is_pointer_v<std::decay_t<rng_t>>
-         && std::same_as<std::remove_cvref_t<std::ranges::range_reference_t<rng_t>>, char>);
-// prevent recursive instantiation: std::same_as<std::remove_cvref_t<std::ranges::range_reference_t<rng_t>>, char>
-// exclude null-terminated strings: std::is_pointer_v<std::decay_t<rng_t>>
 
-/*!\brief Helper template variable that checks if the reference type of a range can be streamed into an instance of
- *        seqan3::debug_stream_type .
- * \tparam rng_t The range type to check.
- * \tparam char_t The char type of the stream.
- * \ingroup core_debug_stream
+/*!
+ * \interface seqan3::nonrecursive_range <>
+ * \brief A concept that checks whether a range is non-recursive.
  *
- * \details
+ * A range is considered non-recursive if it is itself a range whose reference type is not the range type itself.
  *
- * Evaluates to `true` if the following expression is valid: `debug_stream << *rng.begin();`, where rng is of  type
- * rng_t. Otherwise false.
+ * \tparam rng_t The type to check.
+ * \ingroup core_debug_stream
  */
-template <std::ranges::range rng_t, typename char_t>
-constexpr bool reference_type_is_streamable_v = false;
-
-//!\cond
-template <std::ranges::range rng_t, typename char_t>
-    requires requires (std::ranges::range_reference_t<rng_t> l, debug_stream_type<char_t> s) {
-        { s << l };
-    }
-constexpr bool reference_type_is_streamable_v<rng_t, char_t> = true;
-//!\endcond
-} // namespace seqan3::detail
+template <typename rng_t>
+concept nonrecursive_range =
+    !std::same_as<std::remove_cvref_t<std::ranges::range_reference_t<rng_t>>, std::remove_cvref_t<rng_t>>;
 
-namespace seqan3
-{
-/*!\name Formatted output overloads
- * \{
- */
-/*!\brief All input ranges can be printed to the seqan3::debug_stream element-wise (if their elements are printable).
- * \tparam rng_t Type of the range to be printed; must model std::ranges::input_range.
- * \param s The seqan3::debug_stream.
- * \param r The input range.
- * \relates seqan3::debug_stream_type
- *
- * \details
+/*!\brief A printer for arbitrary input ranges.
  *
+ * All input ranges can be printed to the seqan3::debug_stream element-wise (if their elements are printable).
  * If the element type models seqan3::alphabet (and is not an unsigned integer), the range is printed
  * just as if it were a string, i.e. <tt>std::vector<dna4>{'C'_dna4, 'G'_dna4, 'A'_dna4}</tt> is printed as "CGA".
  *
  * In all other cases the elements are comma separated and the range is enclosed in brackets, i.e.
  * `std::vector<int>{3, 1, 33, 7}` is printed as "[3,1,33,7]".
  *
- * \if DEV
- * Note that overloads for range based streaming need to refine the seqan3::detail::debug_stream_range_guard concept
- * to avoid ambiguous function calls.
- * \endif
+ * This printer excludes recursive ranges, such as entities from the std::filesystem library.
+ *
+ * \tparam rng_t Type of the range to be printed; must model std::ranges::input_range and be non-recursive.
+ * \ingroup core_debug_stream
  */
-template <typename char_t, std::ranges::input_range rng_t>
-inline debug_stream_type<char_t> & operator<<(debug_stream_type<char_t> & s, rng_t && r)
-    requires detail::debug_stream_range_guard<rng_t>
+template <typename rng_t>
+    requires std::ranges::input_range<rng_t> && nonrecursive_range<rng_t>
+struct input_range_printer<rng_t>
 {
-    static_assert(detail::reference_type_is_streamable_v<rng_t, char_t>,
-                  "The reference type of the passed range cannot be streamed into the debug_stream.");
-
-    s << '[';
-    auto b = std::ranges::begin(r);
-    auto e = std::ranges::end(r);
-    if (b != e)
+    /*!\brief Prints the elements of a sequence to an output stream.
+     *
+     * \tparam stream_t The type of the stream.
+     * \tparam arg_t The type of the argument.
+     *
+     * \param[in,out] stream The output stream to print to.
+     * \param[in] arg The range to be printed.
+     */
+    template <typename stream_t, typename arg_t>
+    constexpr void operator()(stream_t & stream, arg_t && arg) const
     {
-        s << *b;
-        ++b;
+        stream << '[';
+        auto first = std::ranges::begin(arg);
+        auto last = std::ranges::end(arg);
+        if (first != last)
+        {
+            stream << *first;
+            ++first;
+        }
+        while (first != last)
+        {
+            stream << ',';
+            stream << *first;
+            ++first;
+        }
+        stream << ']';
     }
-    while (b != e)
-    {
-        s << ',';
-        s << *b;
-        ++b;
-    }
-    s << ']';
-
-    return s;
-}
+};
 
-/*!\brief All biological sequences can be printed to the seqan3::debug_stream.
- * \tparam sequence_t Type of the (biological) sequence to be printed; must model seqan3::sequence.
- * \param s The seqan3::debug_stream.
- * \param sequence The input range.
- * \relates seqan3::debug_stream_type
- *
- * \details
+/*!\brief A printer for (biological) sequences.
  *
  * The (biological) sequence (except for ranges over unsigned integers) is printed just as if it were a string, i.e.
  * <tt>std::vector<dna4>{'C'_dna4, 'G'_dna4, 'A'_dna4}</tt> is printed as "CGA".
  *
- * \if DEV
- * Note that overloads for range based streaming need to refine the seqan3::detail::debug_stream_range_guard concept
- * to avoid ambiguous function calls.
- * \endif
+ * \tparam sequence_t The type of the sequence to be printed; must model seqan3::sequence.
+ * \ingroup core_debug_stream
+ */
+template <sequence sequence_t>
+struct sequence_printer<sequence_t>
+{
+    /*!\brief Prints the elements of a sequence to an output stream.
+     *
+     * \tparam stream_t The type of the stream.
+     * \tparam arg_t The type of the argument.
+     *
+     * \param[in,out] stream The output stream to print to.
+     * \param[in] arg The sequence to be printed.
+     */
+    template <typename stream_t, typename arg_t>
+    constexpr void operator()(stream_t & stream, arg_t && arg) const
+    {
+        for (auto && chr : arg)
+            stream << chr;
+    }
+};
+
+/*!\brief A printer for character sequences.
+ * \ingroup core_debug_stream
+ *
+ * This struct provides a printer for character sequences. It is used to print character sequences to a stream.
+ * The character sequence must be an input range and the range reference type must be a character type, i.e.
+ * seqan3::detail::is_char_adaptation_v evaluates to `true`.
+ *
+ * \tparam char_sequence_t The type of the character sequence.
  */
-template <typename char_t, sequence sequence_t>
-inline debug_stream_type<char_t> & operator<<(debug_stream_type<char_t> & s, sequence_t && sequence)
-    requires detail::debug_stream_range_guard<sequence_t>
-          && (!detail::is_uint_adaptation_v<std::remove_cvref_t<std::ranges::range_reference_t<sequence_t>>>)
+template <typename char_sequence_t>
+    requires std::ranges::input_range<char_sequence_t>
+          && (detail::is_char_adaptation_v<std::remove_cvref_t<std::ranges::range_reference_t<char_sequence_t>>>)
+struct char_sequence_printer<char_sequence_t>
 {
-    for (auto && chr : sequence)
-        s << chr;
-    return s;
-}
+    /*!\brief Prints the character sequence to the given stream.
+     *
+     * \tparam stream_t The type of the stream.
+     * \tparam arg_t The type of the argument.
+     * \param stream The stream to print to.
+     * \param arg The character sequence to print.
+     */
+    template <typename stream_t, typename arg_t>
+    constexpr void operator()(stream_t & stream, arg_t && arg) const
+    {
+        // null-terminated string
+        if constexpr (std::is_pointer_v<std::decay_t<char_sequence_t>>)
+            return std::invoke(std_printer<char_sequence_t>{}, stream, std::forward<arg_t>(arg));
+
+        for (auto && chr : arg)
+            stream << chr;
+    }
+};
 
-//!\}
+/*!\brief A printer for integer sequences.
+ *
+ * This struct provides a printer for integer sequences.
+ * The integer sequence must be an input range and the range reference type must model std::integral concept.
+ *
+ * \tparam integer_sequence_t The type of the integer sequence.
+ * \ingroup core_debug_stream
+ */
+template <typename integer_sequence_t>
+    requires std::ranges::input_range<integer_sequence_t>
+          && std::integral<std::remove_cvref_t<std::ranges::range_reference_t<integer_sequence_t>>>
+struct integer_sequence_printer<integer_sequence_t> : public input_range_printer<integer_sequence_t>
+{};
 
 } // namespace seqan3
diff --git a/include/seqan3/core/debug_stream/tuple.hpp b/include/seqan3/core/debug_stream/tuple.hpp
index 21e46d96fd..a3bde61b40 100644
--- a/include/seqan3/core/debug_stream/tuple.hpp
+++ b/include/seqan3/core/debug_stream/tuple.hpp
@@ -36,42 +36,34 @@ void print_tuple(debug_stream_type<char_t> & s, tuple_t && t, std::index_sequenc
     s << ')';
 }
 
-/*!\interface seqan3::detail::debug_streamable_tuple <>
- * \brief A helper concept to avoid ambiguous overloads with the debug stream operator for alignments.
- * \ingroup core_debug_stream
- * \tparam tuple_t The tuple type to print to the seqan3::detail::debug_stream_type.
- *
- * \details
- *
- * This concept requires that the given type is a seqan3::tuple_like type but neither a std::ranges::input_range nor
- * an alphabet (see seqan3::alphabet_tuple_base).
- */
-//!\cond
-template <typename tuple_t>
-concept debug_streamable_tuple =
-    !std::ranges::input_range<tuple_t> && !alphabet<tuple_t> && // exclude alphabet_tuple_base
-    tuple_like<std::remove_cvref_t<tuple_t>>;
-//!\endcond
 } // namespace seqan3::detail
 
 namespace seqan3
 {
 
-/*!\brief All tuples can be printed by printing their elements separately.
+/*!\brief Printer for formatted output of tuple like objects.
  * \tparam tuple_t Type of the tuple to be printed; must model seqan3::tuple_like.
- * \param s The seqan3::debug_stream.
- * \param t The tuple.
- * \relates seqan3::debug_stream_type
+ * \ingroup core_debug_stream
  */
-template <typename char_t, typename tuple_t>
-    requires (detail::debug_streamable_tuple<tuple_t>)
-inline debug_stream_type<char_t> & operator<<(debug_stream_type<char_t> & s, tuple_t && t)
+template <tuple_like tuple_t>
+struct tuple_printer<tuple_t>
 {
-    detail::print_tuple(s,
-                        std::forward<tuple_t>(t),
-                        std::make_index_sequence<std::tuple_size_v<std::remove_cvref_t<tuple_t>>>{});
-    return s;
-}
+    /*!\brief Prints a tuple to a formatted output stream.
+     *
+     * Takes a stream and a tuple object as arguments and prints the tuple elements to the stream.
+     * The elements are printed using the `detail::print_tuple` function.
+     *
+     * \tparam stream_t The type of the stream.
+     * \tparam arg_t The type of the argument.
+     * \param[in,out] stream The stream to print to.
+     * \param[in] arg The tuple to print.
+     */
+    template <typename stream_t, typename arg_t>
+    constexpr void operator()(stream_t & stream, arg_t && arg) const
+    {
+        detail::print_tuple(stream, std::forward<arg_t>(arg), std::make_index_sequence<std::tuple_size_v<tuple_t>>{});
+    }
+};
 
 //!\}
 
diff --git a/include/seqan3/core/debug_stream/variant.hpp b/include/seqan3/core/debug_stream/variant.hpp
index 38a08636ea..01de9024a6 100644
--- a/include/seqan3/core/debug_stream/variant.hpp
+++ b/include/seqan3/core/debug_stream/variant.hpp
@@ -17,35 +17,34 @@
 
 namespace seqan3
 {
-/*!\name Formatted output overloads
- * \{
- */
+
 /*!\brief A std::variant can be printed by visiting the stream operator for the corresponding type.
- * \tparam    variant_type The type of the variant.
- * \param[in] s            The seqan3::debug_stream.
- * \param[in] v            The variant.
- * \relates seqan3::debug_stream_type
- *
- * \details
- *
- * Note that in case the variant is valueless(_by_exception), nothing is printed.
+ * \tparam variant_ts The types of the variant.
+ * \ingroup core_debug_stream
  */
-template <typename char_t, typename variant_type>
-    requires detail::is_type_specialisation_of_v<std::remove_cvref_t<variant_type>, std::variant>
-inline debug_stream_type<char_t> & operator<<(debug_stream_type<char_t> & s, variant_type && v)
+template <typename... variant_ts>
+struct std_variant_printer<std::variant<variant_ts...>>
 {
-    if (!v.valueless_by_exception())
-        std::visit(
-            [&s](auto && arg)
-            {
-                s << arg;
-            },
-            v);
-    else
-        s << "<VALUELESS_VARIANT>";
-    return s;
-}
-
-//!\}
-
+    /*!\brief Prints the variant by visiting the stream operator for the corresponding type.
+     * \tparam stream_t The type of the stream.
+     * \tparam arg_t The type of the argument.
+     * \param[in,out] stream The output stream.
+     * \param[in] arg The variant argument to print.
+     *
+     * Note that in case the variant is valueless(_by_exception), nothing is printed.
+     */
+    template <typename stream_t, typename arg_t>
+    constexpr void operator()(stream_t & stream, arg_t && arg) const
+    {
+        if (!arg.valueless_by_exception())
+            std::visit(
+                [&stream](auto && elem)
+                {
+                    stream << elem;
+                },
+                arg);
+        else
+            stream << "<VALUELESS_VARIANT>";
+    }
+};
 } // namespace seqan3
diff --git a/include/seqan3/core/detail/strong_type.hpp b/include/seqan3/core/detail/strong_type.hpp
index 0e17bcc687..bb3eb3b0fe 100644
--- a/include/seqan3/core/detail/strong_type.hpp
+++ b/include/seqan3/core/detail/strong_type.hpp
@@ -447,34 +447,27 @@ class strong_type
     value_t value;
 };
 
-//------------------------------------------------------------------------------
-// related functions
-//------------------------------------------------------------------------------
-
-/*!\name Formatted output
- * \relates seqan3::detail::strong_type
- * \{
- */
+} // namespace seqan3::detail
 
-/*!\brief Formatted output to a seqan3::detail::debug_stream_type.
- * \tparam char_t The char type of the seqan3::detail::debug_stream_type.
- * \tparam strong_type_t The strong type to print; must model seqan3::detail::derived_from_strong_type.
- *
- * \param[in,out] stream The output stream.
- * \param[in] value The strong typed value to print.
- *
- * \details
- *
- * Prints the stored value of the given strong type.
- *
- * \returns `stream_t &` A reference to the given stream.
+namespace seqan3
+{
+/*!\brief A strong type can be printed by printing its underlying value.
+ * \tparam strong_type_t The type of the strong type; must be derived from seqan3::detail::strong_type.
+ * \ingroup core_debug_stream
  */
-template <typename char_t, derived_from_strong_type strong_type_t>
-debug_stream_type<char_t> & operator<<(debug_stream_type<char_t> & stream, strong_type_t && value)
+template <detail::derived_from_strong_type strong_type_t>
+struct strong_type_printer<strong_type_t>
 {
-    stream << value.get();
-    return stream;
-}
-//!\}
-
-} // namespace seqan3::detail
+    /*!\brief Prints the stored value of the given strong type.
+     * \tparam stream_t The type of the stream.
+     * \tparam arg_t The type of the argument.
+     * \param[in,out] stream The output stream.
+     * \param[in] arg The strong typed value to print.
+     */
+    template <typename stream_t, typename arg_t>
+    constexpr void operator()(stream_t & stream, arg_t && arg) const
+    {
+        stream << arg.get();
+    }
+};
+} // namespace seqan3
diff --git a/include/seqan3/io/sam_file/sam_flag.hpp b/include/seqan3/io/sam_file/sam_flag.hpp
index a6a19d571a..720b2d1322 100644
--- a/include/seqan3/io/sam_file/sam_flag.hpp
+++ b/include/seqan3/io/sam_file/sam_flag.hpp
@@ -94,16 +94,22 @@ template <>
 inline constexpr bool add_enum_bitwise_operators<sam_flag> = true;
 //!\endcond
 
-/*!\brief Overload for the seqan3::sam_flags.
- * \tparam char_t Type char type of the debug_stream.
- * \param stream The seqan3::debug_stream.
- * \param flag The flag to print.
- * \relates seqan3::debug_stream_type
+/*!\brief A sam_flag can be printed as an integer value.
+ * \ingroup io_sam_file
  */
-template <typename char_t>
-inline debug_stream_type<char_t> & operator<<(debug_stream_type<char_t> & stream, sam_flag const flag)
+template <>
+struct sam_flag_printer<sam_flag>
 {
-    return stream << static_cast<int16_t>(flag);
-}
+    /*!\brief Prints the sam flag.
+     * \tparam stream_t The output stream type.
+     * \param[in,out] stream The output stream.
+     * \param[in] arg The sam flag to print.
+     */
+    template <typename stream_t>
+    constexpr void operator()(stream_t & stream, sam_flag const arg) const
+    {
+        stream << static_cast<int16_t>(arg);
+    }
+};
 
 } // namespace seqan3
diff --git a/include/seqan3/io/structure_file/detail.hpp b/include/seqan3/io/structure_file/detail.hpp
index cca57c70f4..14a5224db2 100644
--- a/include/seqan3/io/structure_file/detail.hpp
+++ b/include/seqan3/io/structure_file/detail.hpp
@@ -18,8 +18,7 @@
 
 namespace seqan3::detail
 {
-/*!
- * \brief Transforms a structure annotation string into a base pair probability matrix.
+/*!\brief Transforms a structure annotation string into a base pair probability matrix.
  * \ingroup io_structure_file
  * \throws seqan3::parse_error if unpaired brackets are found in the structure annotation.
  * \tparam structure_alph_type The type of the structure alphabet; must satisfy seqan3::rna_structure_alphabet.
diff --git a/include/seqan3/search/search_result.hpp b/include/seqan3/search/search_result.hpp
index 9a2e2ceccc..15d3eb5f1c 100644
--- a/include/seqan3/search/search_result.hpp
+++ b/include/seqan3/search/search_result.hpp
@@ -181,31 +181,38 @@ class search_result
     //!\}
 };
 
-/*!\brief Print the seqan3::search_result to seqan3::debug_stream.
- * \tparam char_t The underlying character type of the seqan3::debug_stream_type.
- * \tparam search_result_t A specialization of seqan3::search_result.
- * \param stream The stream.
- * \param result The search result to print.
- * \relates seqan3::debug_stream_type
+/*!\brief The printer used for formatted output of the search result.
+ *
+ * The type of the printer must be a seqan3::search_result type.
+ *
+ * \tparam specs_t The list of types seqan3::search_result is specialised with.
+ * \ingroup search
  */
-template <typename char_t, typename search_result_t>
-    requires detail::is_type_specialisation_of_v<std::remove_cvref_t<search_result_t>, search_result>
-inline debug_stream_type<char_t> & operator<<(debug_stream_type<char_t> & stream, search_result_t && result)
+template <typename... specs_t>
+struct search_result_printer<search_result<specs_t...>>
 {
-    using result_type_list = detail::transfer_template_args_onto_t<std::remove_cvref_t<search_result_t>, type_list>;
-
-    stream << "<";
-    if constexpr (!std::same_as<list_traits::at<0, result_type_list>, detail::empty_type>)
-        stream << "query_id:" << result.query_id();
-    if constexpr (!std::same_as<list_traits::at<1, result_type_list>, detail::empty_type>)
-        stream << ", index cursor is present";
-    if constexpr (!std::same_as<list_traits::at<2, result_type_list>, detail::empty_type>)
-        stream << ", reference_id:" << result.reference_id();
-    if constexpr (!std::same_as<list_traits::at<3, result_type_list>, detail::empty_type>)
-        stream << ", reference_pos:" << result.reference_begin_position();
-    stream << ">";
-
-    return stream;
-}
+    /*!\brief Prints the search result.
+     * \tparam stream_t The type of the stream.
+     * \tparam arg_t The type of the argument.
+     * \param[in,out] stream The output stream.
+     * \param[in] arg The search result to print.
+     */
+    template <typename stream_t, typename arg_t>
+    constexpr void operator()(stream_t & stream, arg_t && arg) const
+    {
+        using result_type_list = type_list<specs_t...>;
+
+        stream << "<";
+        if constexpr (!std::same_as<list_traits::at<0, result_type_list>, detail::empty_type>)
+            stream << "query_id:" << arg.query_id();
+        if constexpr (!std::same_as<list_traits::at<1, result_type_list>, detail::empty_type>)
+            stream << ", index cursor is present";
+        if constexpr (!std::same_as<list_traits::at<2, result_type_list>, detail::empty_type>)
+            stream << ", reference_id:" << arg.reference_id();
+        if constexpr (!std::same_as<list_traits::at<3, result_type_list>, detail::empty_type>)
+            stream << ", reference_pos:" << arg.reference_begin_position();
+        stream << ">";
+    }
+};
 
 } // namespace seqan3
diff --git a/include/seqan3/utility/container/dynamic_bitset.hpp b/include/seqan3/utility/container/dynamic_bitset.hpp
index 1fefc968f7..bb77a67f66 100644
--- a/include/seqan3/utility/container/dynamic_bitset.hpp
+++ b/include/seqan3/utility/container/dynamic_bitset.hpp
@@ -1925,26 +1925,6 @@ class dynamic_bitset
         return is;
     }
 
-    /*!\brief Formatted debug output for the `seqan3::dynamic_bitset`.
-     * \param[in,out] s   The `seqan3::debug_stream` to write to.
-     * \param[in]     arg The `seqan3::dynamic_bitset` to read from.
-     * \returns `s`.
-     *
-     * \details
-     *
-     * Internally calls \ref to_string() "arg.to_string()" and inserts a <code>'</code> at every fourth position.
-     *
-     * \experimentalapi{Experimental since version 3.1.}
-     */
-    template <typename char_t>
-    friend debug_stream_type<char_t> & operator<<(debug_stream_type<char_t> & s, dynamic_bitset arg)
-    {
-        s << (std::string_view{arg.to_string()} | views::interleave(4, std::string_view{"'"})
-              | ranges::to<std::string>());
-        return s;
-    }
-    //!\}
-
     //!\cond DEV
     /*!\brief Serialisation support function.
      * \tparam archive_t Type of `archive`; must satisfy seqan3::cereal_archive.
@@ -1970,6 +1950,27 @@ class dynamic_bitset
     //!\endcond
 };
 
+/*!\brief Prints seqan3::dynamic_bitset.
+ * \ingroup utility_container
+ * \experimentalapi{Experimental since version 3.1.}
+ */
+template <size_t bit_capacity>
+struct dynamic_bitset_printer<dynamic_bitset<bit_capacity>>
+{
+    /*!\brief Prints the dynamic bitset.
+     * \tparam stream_t The type of the stream.
+     * \tparam arg_t The type of the argument.
+     * \param[in,out] stream The output stream.
+     * \param[in] arg The dynamic bitset to print.
+     */
+    template <typename stream_t, typename arg_t>
+    constexpr void operator()(stream_t & stream, arg_t && arg) const
+    {
+        stream << (std::string_view{arg.to_string()} | views::interleave(4, std::string_view{"'"})
+                   | ranges::to<std::string>());
+    }
+};
+
 } // namespace seqan3
 
 namespace std
diff --git a/include/seqan3/utility/simd/detail/debug_stream_simd.hpp b/include/seqan3/utility/simd/detail/debug_stream_simd.hpp
index 84504df474..ee0792c6e5 100644
--- a/include/seqan3/utility/simd/detail/debug_stream_simd.hpp
+++ b/include/seqan3/utility/simd/detail/debug_stream_simd.hpp
@@ -17,22 +17,30 @@
 namespace seqan3
 {
 
-/*!\brief Overload for debug_stream for simd types.
+/*!\brief Prints simd types.
+ * \tparam simd_t The simd type to print.
  * \ingroup utility_simd
  */
-template <typename char_t, typename simd_t>
-    requires simd::simd_concept<std::remove_cvref_t<simd_t>>
-inline debug_stream_type<char_t> & operator<<(debug_stream_type<char_t> & s, simd_t && simd)
+template <simd::simd_concept simd_t>
+struct simd_printer<simd_t>
 {
-    using simd_type = std::remove_cvref_t<simd_t>;
-    constexpr size_t length = simd::simd_traits<simd_type>::length;
-    using scalar_type = typename simd::simd_traits<simd_type>::scalar_type;
+    /*!\brief Prints the simd value.
+     * \tparam stream_t The type of the stream.
+     * \tparam arg_t The type of the argument.
+     * \param[in,out] stream The output stream.
+     * \param[in] arg The simd type to print.
+     */
+    template <typename stream_t, typename arg_t>
+    constexpr void operator()(stream_t & stream, arg_t && arg) const
+    {
+        constexpr size_t length = simd::simd_traits<simd_t>::length;
+        using scalar_type = typename simd::simd_traits<simd_t>::scalar_type;
 
-    std::array<scalar_type, length> array{};
-    for (size_t i = 0; i < length; ++i)
-        array[i] = simd[i];
-    s << array;
-    return s;
-}
+        std::array<scalar_type, length> array{};
+        for (size_t i = 0; i < length; ++i)
+            array[i] = arg[i];
+        stream << array;
+    }
+};
 
 } // namespace seqan3
diff --git a/test/unit/alignment/matrix/detail/debug_stream_debug_matrix_test.cpp b/test/unit/alignment/matrix/detail/debug_stream_debug_matrix_test.cpp
index 225a3a295e..ef8b72fabc 100644
--- a/test/unit/alignment/matrix/detail/debug_stream_debug_matrix_test.cpp
+++ b/test/unit/alignment/matrix/detail/debug_stream_debug_matrix_test.cpp
@@ -183,6 +183,7 @@ struct debug_matrix_stream_test : public ::testing::Test
 
 using typename seqan3::detail::debug_matrix_stream_test;
 using debug_stream_test = seqan3::detail::debug_matrix_stream_test;
+using debug_matrix_printer_test = seqan3::detail::debug_matrix_stream_test;
 
 TEST_F(debug_matrix_stream_test, unicode_str_length)
 {
@@ -429,3 +430,26 @@ TEST_F(debug_stream_test, trace_matrix_unicode_with_sequences)
 
     EXPECT_EQ(stream.str(), trace_matrix_unicode_with_sequences);
 }
+
+TEST_F(debug_matrix_printer_test, score_matrix_ascii_std_stream)
+{
+    seqan3::detail::debug_matrix matrix{score_matrix};
+    seqan3::alignment_matrix_printer<decltype(matrix)> printer;
+
+    std::stringstream stream;
+    printer(stream, matrix);
+
+    EXPECT_EQ(stream.str(), score_matrix_ascii);
+}
+
+TEST_F(debug_matrix_printer_test, score_matrix_unicode_debug_stream)
+{
+    seqan3::detail::debug_matrix matrix{score_matrix};
+    seqan3::alignment_matrix_printer<decltype(matrix)> printer;
+
+    std::stringstream stream;
+    seqan3::debug_stream_type debug_stream{stream};
+    printer(debug_stream << seqan3::fmtflags2::utf8, matrix);
+
+    EXPECT_EQ(stream.str(), score_matrix_unicode);
+}
diff --git a/test/unit/alignment/matrix/detail/debug_stream_trace_directions_test.cpp b/test/unit/alignment/matrix/detail/debug_stream_trace_directions_test.cpp
index 450123675a..ec77d1923e 100644
--- a/test/unit/alignment/matrix/detail/debug_stream_trace_directions_test.cpp
+++ b/test/unit/alignment/matrix/detail/debug_stream_trace_directions_test.cpp
@@ -40,3 +40,20 @@ TEST(debug_stream_test, unicode)
 
     EXPECT_EQ(s.str(), "↺;↖;↑;←;↖↑;↖←;↑←;↖↑←;⇡;⇠;↖⇡;↖⇡⇠;↖↑⇡←⇠");
 }
+
+TEST(trace_directions_printer_test, std_stream)
+{
+    std::stringstream s{};
+    seqan3::trace_directions_printer<seqan3::detail::trace_directions> printer{};
+    printer(s, N);
+    s << ';';
+    printer(s, D);
+    s << ';';
+    printer(s, L);
+    s << ';';
+    printer(s, U);
+    s << ';';
+    printer(s, D | U | u | L | l);
+
+    EXPECT_EQ(s.str(), "N;D;L;U;DUuLl");
+}
diff --git a/test/unit/io/record_test.cpp b/test/unit/io/record_test.cpp
index dc90b6a154..fd8ebe4bbe 100644
--- a/test/unit/io/record_test.cpp
+++ b/test/unit/io/record_test.cpp
@@ -21,6 +21,7 @@ using default_fields = seqan3::fields<seqan3::field::seq, seqan3::field::id, seq
 // This is needed for EXPECT_RANGE_EQ:
 namespace seqan3
 {
+// TODO: This is only for the test. We might need to consider adding enumeration_names for the io fields to the library.
 template <typename char_t>
 inline debug_stream_type<char_t> & operator<<(debug_stream_type<char_t> & stream, field f)
 {
diff --git a/test/unit/test/pretty_printing_test.cpp b/test/unit/test/pretty_printing_test.cpp
index 9e6e38b75c..bfceb6785c 100644
--- a/test/unit/test/pretty_printing_test.cpp
+++ b/test/unit/test/pretty_printing_test.cpp
@@ -37,6 +37,22 @@ TEST(pretty_printing, char)
     EXPECT_EQ(debug_str('a'), "a"s);
 }
 
+TEST(pretty_printing, charX_t)
+{
+    EXPECT_EQ(gtest_str(char8_t{5}), "U+0005"s);
+    EXPECT_EQ(gtest_str(char16_t{5}), "U+0005"s);
+    EXPECT_EQ(gtest_str(char32_t{5}), "U+0005"s);
+    // EXPECT_EQ(debug_str(char8_t{5}), "U+0005"s);
+    // EXPECT_EQ(debug_str(char16_t{5}), "U+0005"s);
+    // EXPECT_EQ(debug_str(char32_t{5}), "U+0005"s);
+}
+
+TEST(pretty_printing, cstring)
+{
+    EXPECT_EQ(gtest_str("test"), "\"test\""s);
+    EXPECT_EQ(debug_str("test"), "test"s);
+}
+
 TEST(pretty_printing, tuple)
 {
     EXPECT_EQ(gtest_str(std::make_tuple<int, int>(42, -10)), "(42, -10)"s);