diff --git a/include/seqan3/alphabet/container/bitpacked_sequence.hpp b/include/seqan3/alphabet/container/bitpacked_sequence.hpp
index 53377ced7d..449d90a2ee 100644
--- a/include/seqan3/alphabet/container/bitpacked_sequence.hpp
+++ b/include/seqan3/alphabet/container/bitpacked_sequence.hpp
@@ -91,7 +91,7 @@ class bitpacked_sequence
         //!\brief Update the sdsl-proxy.
         constexpr void on_update() noexcept
         {
-            internal_proxy = static_cast<base_t &>(*this).to_rank();
+            internal_proxy = base_t::to_rank();
         }
 
     public:
@@ -110,10 +110,12 @@ class bitpacked_sequence
         ~reference_proxy_type() noexcept = default;                                                  //!< Defaulted.
 
         //!\brief Initialise from internal proxy type.
-        reference_proxy_type(std::ranges::range_reference_t<data_type> const & internal) noexcept :
+        reference_proxy_type(std::ranges::range_reference_t<data_type> const internal) noexcept :
             internal_proxy{internal}
         {
-            static_cast<base_t &>(*this).assign_rank(internal);
+            // Call alphabet_base's assign_rank to prevent calling on_update() during construction
+            // which is not necessary, because internal_proxy is already correctly initialised!
+            base_t::base_t::assign_rank(static_cast<alphabet_rank_t<alphabet_type>>(internal));
         }
         //!\}
     };
diff --git a/test/performance/range/container_push_back_benchmark.cpp b/test/performance/range/container_push_back_benchmark.cpp
index a0d2c12a00..064c58729f 100644
--- a/test/performance/range/container_push_back_benchmark.cpp
+++ b/test/performance/range/container_push_back_benchmark.cpp
@@ -16,6 +16,7 @@
 #include <seqan3/alignment/decorator/gap_decorator.hpp>
 #include <seqan3/alphabet/all.hpp>
 #include <seqan3/alphabet/container/bitpacked_sequence.hpp>
+#include <seqan3/test/seqan2.hpp>
 #include <seqan3/utility/container/small_vector.hpp>
 
 template <typename t>
@@ -31,14 +32,14 @@ using small_vec = seqan3::small_vector<t, 10'000>;
 template <template <typename> typename container_t, typename alphabet_t>
 void push_back(benchmark::State & state)
 {
-    alphabet_t a{};
+    alphabet_t letter{};
 
     for (auto _ : state)
     {
-        container_t<alphabet_t> c;
+        container_t<alphabet_t> container;
         for (size_t i = 0; i < 10'000; ++i)
-            c.push_back(a);
-        a = c.back();
+            container.push_back(letter);
+        benchmark::DoNotOptimize(letter = container.back());
     }
 
     state.counters["sizeof"] = sizeof(alphabet_t);
@@ -88,6 +89,7 @@ BENCHMARK_TEMPLATE(push_back, sdsl_int_vec, uint32_t);
 BENCHMARK_TEMPLATE(push_back, sdsl_int_vec, uint64_t);
 
 BENCHMARK_TEMPLATE(push_back, seqan3::bitpacked_sequence, char);
+BENCHMARK_TEMPLATE(push_back, seqan3::bitpacked_sequence, uint32_t);
 BENCHMARK_TEMPLATE(push_back, seqan3::bitpacked_sequence, seqan3::gap);
 BENCHMARK_TEMPLATE(push_back, seqan3::bitpacked_sequence, seqan3::dna4);
 BENCHMARK_TEMPLATE(push_back, seqan3::bitpacked_sequence, seqan3::gapped<seqan3::dna4>);
@@ -96,6 +98,7 @@ BENCHMARK_TEMPLATE(push_back, seqan3::bitpacked_sequence, seqan3::aa27);
 BENCHMARK_TEMPLATE(push_back, seqan3::bitpacked_sequence, seqan3::alphabet_variant<char, seqan3::dna4>);
 
 BENCHMARK_TEMPLATE(push_back, small_vec, char);
+BENCHMARK_TEMPLATE(push_back, small_vec, uint32_t);
 BENCHMARK_TEMPLATE(push_back, small_vec, seqan3::gap);
 BENCHMARK_TEMPLATE(push_back, small_vec, seqan3::dna4);
 BENCHMARK_TEMPLATE(push_back, small_vec, seqan3::gapped<seqan3::dna4>);
@@ -103,6 +106,70 @@ BENCHMARK_TEMPLATE(push_back, small_vec, seqan3::dna15);
 BENCHMARK_TEMPLATE(push_back, small_vec, seqan3::aa27);
 BENCHMARK_TEMPLATE(push_back, small_vec, seqan3::alphabet_variant<char, seqan3::dna4>);
 
+// ============================================================================
+//  push_back SeqAn2
+// ============================================================================
+
+#if SEQAN3_HAS_SEQAN2
+
+#include <seqan/sequence.h>
+
+template <template <typename...> typename container_t, typename spec_t, typename alphabet_t>
+void push_back2(benchmark::State & state)
+{
+    alphabet_t letter{};
+
+    for (auto _ : state)
+    {
+        container_t<alphabet_t, spec_t> container;
+        for (size_t i = 0; i < 10'000; ++i)
+            seqan::appendValue(container, letter);
+        benchmark::DoNotOptimize(letter = seqan::back(container));
+    }
+
+    state.counters["sizeof"] = sizeof(alphabet_t);
+    state.counters["alph_size"] = seqan::ValueSize<alphabet_t>::VALUE;
+}
+
+BENCHMARK_TEMPLATE(push_back, std::vector, seqan::Dna);
+BENCHMARK_TEMPLATE(push_back, std::vector, seqan::Dna5);
+BENCHMARK_TEMPLATE(push_back, std::vector, seqan::Iupac);
+BENCHMARK_TEMPLATE(push_back, std::vector, seqan::AminoAcid);
+BENCHMARK_TEMPLATE(push_back, std::vector, seqan::Dna5Q);
+
+BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Alloc<>, char);
+BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Alloc<>, uint8_t);
+BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Alloc<>, uint16_t);
+BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Alloc<>, uint32_t);
+BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Alloc<>, uint64_t);
+
+BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Alloc<>, seqan3::gap);
+BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Alloc<>, seqan3::dna4);
+BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Alloc<>, seqan3::gapped<seqan3::dna4>);
+BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Alloc<>, seqan3::dna15);
+BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Alloc<>, seqan3::aa27);
+BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Alloc<>, seqan3::alphabet_variant<char, seqan3::dna4>);
+
+BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Alloc<>, seqan::Dna);
+BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Alloc<>, seqan::Dna5);
+BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Alloc<>, seqan::Iupac);
+BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Alloc<>, seqan::AminoAcid);
+BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Alloc<>, seqan::Dna5Q);
+
+BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Packed<>, seqan::Dna);
+BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Packed<>, seqan::Dna5);
+BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Packed<>, seqan::Iupac);
+BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Packed<>, seqan::AminoAcid);
+// BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Packed<>, seqan::Dna5Q); // broken in SeqAn2
+
+BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Array<10'000>, seqan::Dna);
+BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Array<10'000>, seqan::Dna5);
+BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Array<10'000>, seqan::Iupac);
+BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Array<10'000>, seqan::AminoAcid);
+BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Array<10'000>, seqan::Dna5Q);
+
+#endif // SEQAN3_HAS_SEQAN2
+
 // ============================================================================
 //  run
 // ============================================================================
diff --git a/test/performance/range/container_seq_read_benchmark.cpp b/test/performance/range/container_seq_read_benchmark.cpp
index 41993bcfbf..9908ac685b 100644
--- a/test/performance/range/container_seq_read_benchmark.cpp
+++ b/test/performance/range/container_seq_read_benchmark.cpp
@@ -17,6 +17,7 @@
 #include <seqan3/alphabet/all.hpp>
 #include <seqan3/alphabet/container/bitpacked_sequence.hpp>
 #include <seqan3/test/performance/sequence_generator.hpp>
+#include <seqan3/test/seqan2.hpp>
 #include <seqan3/utility/container/small_vector.hpp>
 
 template <typename t>
@@ -32,18 +33,21 @@ using small_vec = seqan3::small_vector<t, 10'000>;
 template <template <typename> typename container_t, typename alphabet_t, bool const_qualified = false>
 void sequential_read(benchmark::State & state)
 {
-    auto cont_rando = seqan3::test::generate_sequence<alphabet_t>(10'000, 0, 0);
-    container_t<alphabet_t> source(cont_rando.begin(), cont_rando.end());
+    container_t<alphabet_t> container = []()
+    {
+        auto container = seqan3::test::generate_sequence<alphabet_t>(10'000, 0, 0);
+        return container_t<alphabet_t>(container.begin(), container.end());
+    }();
 
-    using source_ref_t =
+    using container_reference_t =
         std::conditional_t<const_qualified, container_t<alphabet_t> const &, container_t<alphabet_t> &>;
 
-    source_ref_t source_ref{source};
+    container_reference_t container_reference{container};
 
-    alphabet_t a;
+    alphabet_t letter{};
     for (auto _ : state)
-        for (auto && c : source_ref)
-            benchmark::DoNotOptimize(a = c);
+        for (auto && element : container_reference)
+            benchmark::DoNotOptimize(letter = element);
 
     state.counters["sizeof"] = sizeof(alphabet_t);
     if constexpr (seqan3::alphabet<alphabet_t>)
@@ -58,9 +62,11 @@ BENCHMARK_TEMPLATE(sequential_read, std::vector, uint32_t);
 BENCHMARK_TEMPLATE(sequential_read, std::vector, uint64_t);
 BENCHMARK_TEMPLATE(sequential_read, std::vector, seqan3::gap);
 BENCHMARK_TEMPLATE(sequential_read, std::vector, seqan3::dna4);
+BENCHMARK_TEMPLATE(sequential_read, std::vector, seqan3::dna5);
 BENCHMARK_TEMPLATE(sequential_read, std::vector, seqan3::gapped<seqan3::dna4>);
 BENCHMARK_TEMPLATE(sequential_read, std::vector, seqan3::dna15);
 BENCHMARK_TEMPLATE(sequential_read, std::vector, seqan3::aa27);
+BENCHMARK_TEMPLATE(sequential_read, std::vector, seqan3::qualified<seqan3::dna4, seqan3::phred42>);
 BENCHMARK_TEMPLATE(sequential_read, std::vector, seqan3::alphabet_variant<char, seqan3::dna4>);
 
 BENCHMARK_TEMPLATE(sequential_read, std::deque, char);
@@ -70,9 +76,11 @@ BENCHMARK_TEMPLATE(sequential_read, std::deque, uint32_t);
 BENCHMARK_TEMPLATE(sequential_read, std::deque, uint64_t);
 BENCHMARK_TEMPLATE(sequential_read, std::deque, seqan3::gap);
 BENCHMARK_TEMPLATE(sequential_read, std::deque, seqan3::dna4);
+BENCHMARK_TEMPLATE(sequential_read, std::deque, seqan3::dna5);
 BENCHMARK_TEMPLATE(sequential_read, std::deque, seqan3::gapped<seqan3::dna4>);
 BENCHMARK_TEMPLATE(sequential_read, std::deque, seqan3::dna15);
 BENCHMARK_TEMPLATE(sequential_read, std::deque, seqan3::aa27);
+BENCHMARK_TEMPLATE(sequential_read, std::deque, seqan3::qualified<seqan3::dna4, seqan3::phred42>);
 BENCHMARK_TEMPLATE(sequential_read, std::deque, seqan3::alphabet_variant<char, seqan3::dna4>);
 
 BENCHMARK_TEMPLATE(sequential_read, std::list, char);
@@ -82,9 +90,11 @@ BENCHMARK_TEMPLATE(sequential_read, std::list, uint32_t);
 BENCHMARK_TEMPLATE(sequential_read, std::list, uint64_t);
 BENCHMARK_TEMPLATE(sequential_read, std::list, seqan3::gap);
 BENCHMARK_TEMPLATE(sequential_read, std::list, seqan3::dna4);
+BENCHMARK_TEMPLATE(sequential_read, std::list, seqan3::dna5);
 BENCHMARK_TEMPLATE(sequential_read, std::list, seqan3::gapped<seqan3::dna4>);
 BENCHMARK_TEMPLATE(sequential_read, std::list, seqan3::dna15);
 BENCHMARK_TEMPLATE(sequential_read, std::list, seqan3::aa27);
+BENCHMARK_TEMPLATE(sequential_read, std::list, seqan3::qualified<seqan3::dna4, seqan3::phred42>);
 BENCHMARK_TEMPLATE(sequential_read, std::list, seqan3::alphabet_variant<char, seqan3::dna4>);
 
 BENCHMARK_TEMPLATE(sequential_read, sdsl_int_vec, uint8_t);
@@ -93,19 +103,25 @@ BENCHMARK_TEMPLATE(sequential_read, sdsl_int_vec, uint32_t);
 BENCHMARK_TEMPLATE(sequential_read, sdsl_int_vec, uint64_t);
 
 BENCHMARK_TEMPLATE(sequential_read, seqan3::bitpacked_sequence, char);
+BENCHMARK_TEMPLATE(sequential_read, seqan3::bitpacked_sequence, uint32_t);
 BENCHMARK_TEMPLATE(sequential_read, seqan3::bitpacked_sequence, seqan3::gap);
 BENCHMARK_TEMPLATE(sequential_read, seqan3::bitpacked_sequence, seqan3::dna4);
+BENCHMARK_TEMPLATE(sequential_read, seqan3::bitpacked_sequence, seqan3::dna5);
 BENCHMARK_TEMPLATE(sequential_read, seqan3::bitpacked_sequence, seqan3::gapped<seqan3::dna4>);
 BENCHMARK_TEMPLATE(sequential_read, seqan3::bitpacked_sequence, seqan3::dna15);
 BENCHMARK_TEMPLATE(sequential_read, seqan3::bitpacked_sequence, seqan3::aa27);
+BENCHMARK_TEMPLATE(sequential_read, seqan3::bitpacked_sequence, seqan3::qualified<seqan3::dna4, seqan3::phred42>);
 BENCHMARK_TEMPLATE(sequential_read, seqan3::bitpacked_sequence, seqan3::alphabet_variant<char, seqan3::dna4>);
 
 BENCHMARK_TEMPLATE(sequential_read, small_vec, char);
+BENCHMARK_TEMPLATE(sequential_read, small_vec, uint32_t);
 BENCHMARK_TEMPLATE(sequential_read, small_vec, seqan3::gap);
 BENCHMARK_TEMPLATE(sequential_read, small_vec, seqan3::dna4);
+BENCHMARK_TEMPLATE(sequential_read, small_vec, seqan3::dna5);
 BENCHMARK_TEMPLATE(sequential_read, small_vec, seqan3::gapped<seqan3::dna4>);
 BENCHMARK_TEMPLATE(sequential_read, small_vec, seqan3::dna15);
 BENCHMARK_TEMPLATE(sequential_read, small_vec, seqan3::aa27);
+BENCHMARK_TEMPLATE(sequential_read, small_vec, seqan3::qualified<seqan3::dna4, seqan3::phred42>);
 BENCHMARK_TEMPLATE(sequential_read, small_vec, seqan3::alphabet_variant<char, seqan3::dna4>);
 
 // ============================================================================
@@ -119,27 +135,114 @@ BENCHMARK_TEMPLATE(sequential_read, std::vector, uint32_t, true);
 BENCHMARK_TEMPLATE(sequential_read, std::vector, uint64_t, true);
 BENCHMARK_TEMPLATE(sequential_read, std::vector, seqan3::gap, true);
 BENCHMARK_TEMPLATE(sequential_read, std::vector, seqan3::dna4, true);
+BENCHMARK_TEMPLATE(sequential_read, std::vector, seqan3::dna5, true);
 BENCHMARK_TEMPLATE(sequential_read, std::vector, seqan3::gapped<seqan3::dna4>, true);
 BENCHMARK_TEMPLATE(sequential_read, std::vector, seqan3::dna15, true);
 BENCHMARK_TEMPLATE(sequential_read, std::vector, seqan3::aa27, true);
+BENCHMARK_TEMPLATE(sequential_read, std::vector, seqan3::qualified<seqan3::dna4, seqan3::phred42>, true);
 BENCHMARK_TEMPLATE(sequential_read, std::vector, seqan3::alphabet_variant<char, seqan3::dna4>, true);
 
 BENCHMARK_TEMPLATE(sequential_read, seqan3::bitpacked_sequence, char, true);
+BENCHMARK_TEMPLATE(sequential_read, seqan3::bitpacked_sequence, uint32_t, true);
 BENCHMARK_TEMPLATE(sequential_read, seqan3::bitpacked_sequence, seqan3::gap, true);
 BENCHMARK_TEMPLATE(sequential_read, seqan3::bitpacked_sequence, seqan3::dna4, true);
+BENCHMARK_TEMPLATE(sequential_read, seqan3::bitpacked_sequence, seqan3::dna5, true);
 BENCHMARK_TEMPLATE(sequential_read, seqan3::bitpacked_sequence, seqan3::gapped<seqan3::dna4>, true);
 BENCHMARK_TEMPLATE(sequential_read, seqan3::bitpacked_sequence, seqan3::dna15, true);
 BENCHMARK_TEMPLATE(sequential_read, seqan3::bitpacked_sequence, seqan3::aa27, true);
+BENCHMARK_TEMPLATE(sequential_read, seqan3::bitpacked_sequence, seqan3::qualified<seqan3::dna4, seqan3::phred42>, true);
 BENCHMARK_TEMPLATE(sequential_read, seqan3::bitpacked_sequence, seqan3::alphabet_variant<char, seqan3::dna4>, true);
 
 BENCHMARK_TEMPLATE(sequential_read, small_vec, char, true);
+BENCHMARK_TEMPLATE(sequential_read, small_vec, uint32_t, true);
 BENCHMARK_TEMPLATE(sequential_read, small_vec, seqan3::gap, true);
 BENCHMARK_TEMPLATE(sequential_read, small_vec, seqan3::dna4, true);
+BENCHMARK_TEMPLATE(sequential_read, small_vec, seqan3::dna5, true);
 BENCHMARK_TEMPLATE(sequential_read, small_vec, seqan3::gapped<seqan3::dna4>, true);
 BENCHMARK_TEMPLATE(sequential_read, small_vec, seqan3::dna15, true);
 BENCHMARK_TEMPLATE(sequential_read, small_vec, seqan3::aa27, true);
+BENCHMARK_TEMPLATE(sequential_read, small_vec, seqan3::qualified<seqan3::dna4, seqan3::phred42>, true);
 BENCHMARK_TEMPLATE(sequential_read, small_vec, seqan3::alphabet_variant<char, seqan3::dna4>, true);
 
+// ============================================================================
+//  SeqAn2: sequential_read
+// ============================================================================
+
+#if SEQAN3_HAS_SEQAN2
+
+#    include <seqan/sequence.h>
+
+template <template <typename...> typename container_t,
+          typename spec_t,
+          typename alphabet_t,
+          bool const_qualified = false>
+void sequential_read2(benchmark::State & state)
+{
+    container_t<alphabet_t, spec_t> container{seqan3::test::generate_sequence_seqan2<alphabet_t>(10'000, 0, 0)};
+
+    using container_reference_t =
+        std::conditional_t<const_qualified, container_t<alphabet_t, spec_t> const &, container_t<alphabet_t, spec_t> &>;
+
+    container_reference_t container_reference{container};
+
+    alphabet_t letter{};
+    for (auto _ : state)
+        for (auto && element : container_reference)
+            benchmark::DoNotOptimize(letter = element);
+
+    state.counters["sizeof"] = sizeof(alphabet_t);
+    state.counters["alph_size"] = seqan::ValueSize<alphabet_t>::VALUE;
+    state.counters["const"] = const_qualified;
+}
+
+BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Alloc<>, char);
+BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Alloc<>, uint8_t);
+BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Alloc<>, uint16_t);
+BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Alloc<>, uint32_t);
+BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Alloc<>, uint64_t);
+
+BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Alloc<>, seqan::Dna);
+BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Alloc<>, seqan::Dna5);
+BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Alloc<>, seqan::Iupac);
+BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Alloc<>, seqan::AminoAcid);
+BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Alloc<>, seqan::Dna5Q);
+
+BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Packed<>, seqan::Dna);
+BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Packed<>, seqan::Dna5);
+BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Packed<>, seqan::Iupac);
+BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Packed<>, seqan::AminoAcid);
+// BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Packed<>, seqan::Dna5Q); // broken in SeqAn2
+
+BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Array<10'000>, seqan::Dna);
+BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Array<10'000>, seqan::Dna5);
+BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Array<10'000>, seqan::Iupac);
+BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Array<10'000>, seqan::AminoAcid);
+BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Array<10'000>, seqan::Dna5Q);
+
+// ============================================================================
+//  sequential_read (const)
+// ============================================================================
+
+BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Alloc<>, char, true);
+BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Alloc<>, uint8_t, true);
+BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Alloc<>, uint16_t, true);
+BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Alloc<>, uint32_t, true);
+BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Alloc<>, uint64_t, true);
+
+BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Alloc<>, seqan::Dna, true);
+BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Alloc<>, seqan::Dna5, true);
+BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Alloc<>, seqan::Iupac, true);
+BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Alloc<>, seqan::AminoAcid, true);
+BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Alloc<>, seqan::Dna5Q, true);
+
+BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Packed<>, seqan::Dna, true);
+BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Packed<>, seqan::Dna5, true);
+BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Packed<>, seqan::Iupac, true);
+BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Packed<>, seqan::AminoAcid, true);
+// BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Packed<>, seqan::Dna5Q); // broken in SeqAn2
+
+#endif // SEQAN3_HAS_SEQAN2
+
 // ============================================================================
 //  run
 // ============================================================================
diff --git a/test/performance/range/container_seq_write_benchmark.cpp b/test/performance/range/container_seq_write_benchmark.cpp
index dc32c35641..b9fabd99e8 100644
--- a/test/performance/range/container_seq_write_benchmark.cpp
+++ b/test/performance/range/container_seq_write_benchmark.cpp
@@ -17,6 +17,7 @@
 #include <seqan3/alphabet/all.hpp>
 #include <seqan3/alphabet/container/bitpacked_sequence.hpp>
 #include <seqan3/test/performance/sequence_generator.hpp>
+#include <seqan3/test/seqan2.hpp>
 #include <seqan3/utility/container/small_vector.hpp>
 
 template <typename t>
@@ -32,15 +33,16 @@ using small_vec = seqan3::small_vector<t, 10'000>;
 template <template <typename> typename container_t, typename alphabet_t>
 void sequential_write(benchmark::State & state)
 {
-    auto cont_rando = seqan3::test::generate_sequence<alphabet_t>(10000, 0, 0);
-    container_t<alphabet_t> source(cont_rando.begin(), cont_rando.end());
+    container_t<alphabet_t> container = []()
+    {
+        auto container = seqan3::test::generate_sequence<alphabet_t>(10'000, 0, 0);
+        return container_t<alphabet_t>(container.begin(), container.end());
+    }();
 
-    alphabet_t a{};
+    alphabet_t letter{};
     for (auto _ : state)
-    {
-        for (auto && c : source)
-            c = a;
-    }
+        for (auto && element : container)
+            element = letter;
 
     state.counters["sizeof"] = sizeof(alphabet_t);
     if constexpr (seqan3::alphabet<alphabet_t>)
@@ -89,6 +91,7 @@ BENCHMARK_TEMPLATE(sequential_write, sdsl_int_vec, uint32_t);
 BENCHMARK_TEMPLATE(sequential_write, sdsl_int_vec, uint64_t);
 
 BENCHMARK_TEMPLATE(sequential_write, seqan3::bitpacked_sequence, char);
+BENCHMARK_TEMPLATE(sequential_write, seqan3::bitpacked_sequence, uint32_t);
 BENCHMARK_TEMPLATE(sequential_write, seqan3::bitpacked_sequence, seqan3::gap);
 BENCHMARK_TEMPLATE(sequential_write, seqan3::bitpacked_sequence, seqan3::dna4);
 BENCHMARK_TEMPLATE(sequential_write, seqan3::bitpacked_sequence, seqan3::gapped<seqan3::dna4>);
@@ -97,6 +100,7 @@ BENCHMARK_TEMPLATE(sequential_write, seqan3::bitpacked_sequence, seqan3::aa27);
 BENCHMARK_TEMPLATE(sequential_write, seqan3::bitpacked_sequence, seqan3::alphabet_variant<char, seqan3::dna4>);
 
 BENCHMARK_TEMPLATE(sequential_write, small_vec, char);
+BENCHMARK_TEMPLATE(sequential_write, small_vec, uint32_t);
 BENCHMARK_TEMPLATE(sequential_write, small_vec, seqan3::gap);
 BENCHMARK_TEMPLATE(sequential_write, small_vec, seqan3::dna4);
 BENCHMARK_TEMPLATE(sequential_write, small_vec, seqan3::gapped<seqan3::dna4>);
@@ -104,6 +108,54 @@ BENCHMARK_TEMPLATE(sequential_write, small_vec, seqan3::dna15);
 BENCHMARK_TEMPLATE(sequential_write, small_vec, seqan3::aa27);
 BENCHMARK_TEMPLATE(sequential_write, small_vec, seqan3::alphabet_variant<char, seqan3::dna4>);
 
+// ============================================================================
+//  SeqAn2: sequential_write
+// ============================================================================
+
+#if SEQAN3_HAS_SEQAN2
+
+#    include <seqan/sequence.h>
+
+template <template <typename...> typename container_t, typename spec_t, typename alphabet_t>
+void sequential_write2(benchmark::State & state)
+{
+    container_t<alphabet_t, spec_t> container{seqan3::test::generate_sequence_seqan2<alphabet_t>(10'000, 0, 0)};
+
+    alphabet_t letter{};
+    for (auto _ : state)
+        for (auto && element : container)
+            element = letter;
+
+    state.counters["sizeof"] = sizeof(alphabet_t);
+    state.counters["alph_size"] = seqan::ValueSize<alphabet_t>::VALUE;
+}
+
+BENCHMARK_TEMPLATE(sequential_write2, seqan::String, seqan::Alloc<>, char);
+BENCHMARK_TEMPLATE(sequential_write2, seqan::String, seqan::Alloc<>, uint8_t);
+BENCHMARK_TEMPLATE(sequential_write2, seqan::String, seqan::Alloc<>, uint16_t);
+BENCHMARK_TEMPLATE(sequential_write2, seqan::String, seqan::Alloc<>, uint32_t);
+BENCHMARK_TEMPLATE(sequential_write2, seqan::String, seqan::Alloc<>, uint64_t);
+
+BENCHMARK_TEMPLATE(sequential_write2, seqan::String, seqan::Alloc<>, seqan::Dna);
+BENCHMARK_TEMPLATE(sequential_write2, seqan::String, seqan::Alloc<>, seqan::Dna5);
+BENCHMARK_TEMPLATE(sequential_write2, seqan::String, seqan::Alloc<>, seqan::Iupac);
+BENCHMARK_TEMPLATE(sequential_write2, seqan::String, seqan::Alloc<>, seqan::AminoAcid);
+BENCHMARK_TEMPLATE(sequential_write2, seqan::String, seqan::Alloc<>, seqan::Dna5Q);
+
+BENCHMARK_TEMPLATE(sequential_write2, seqan::String, seqan::Packed<>, seqan::Dna);
+BENCHMARK_TEMPLATE(sequential_write2, seqan::String, seqan::Packed<>, seqan::Dna5);
+BENCHMARK_TEMPLATE(sequential_write2, seqan::String, seqan::Packed<>, seqan::Iupac);
+BENCHMARK_TEMPLATE(sequential_write2, seqan::String, seqan::Packed<>, seqan::AminoAcid);
+// BENCHMARK_TEMPLATE(sequential_write2, seqan::String, seqan::Packed<>, seqan::Dna5Q); // broken in SeqAn2
+
+BENCHMARK_TEMPLATE(sequential_write2, seqan::String, seqan::Array<10'000>, seqan::Dna);
+BENCHMARK_TEMPLATE(sequential_write2, seqan::String, seqan::Array<10'000>, seqan::Dna5);
+BENCHMARK_TEMPLATE(sequential_write2, seqan::String, seqan::Array<10'000>, seqan::Iupac);
+BENCHMARK_TEMPLATE(sequential_write2, seqan::String, seqan::Array<10'000>, seqan::AminoAcid);
+BENCHMARK_TEMPLATE(sequential_write2, seqan::String, seqan::Array<10'000>, seqan::Dna5Q);
+
+#endif // SEQAN3_HAS_SEQAN2
+
 // ============================================================================
 //  run
 // ============================================================================
diff --git a/test/performance/range/views/CMakeLists.txt b/test/performance/range/views/CMakeLists.txt
index b71f40c99e..ce65cba931 100644
--- a/test/performance/range/views/CMakeLists.txt
+++ b/test/performance/range/views/CMakeLists.txt
@@ -1,4 +1,5 @@
 seqan3_benchmark (view_all_benchmark.cpp)
 seqan3_benchmark (view_drop_benchmark.cpp)
 seqan3_benchmark (view_drop_view_take_benchmark.cpp)
+seqan3_benchmark (view_filter_benchmark.cpp)
 seqan3_benchmark (view_take_benchmark.cpp)
diff --git a/test/performance/range/views/view_filter_benchmark.cpp b/test/performance/range/views/view_filter_benchmark.cpp
new file mode 100644
index 0000000000..fc5bb2ed33
--- /dev/null
+++ b/test/performance/range/views/view_filter_benchmark.cpp
@@ -0,0 +1,99 @@
+// -----------------------------------------------------------------------------------------------------
+// Copyright (c) 2006-2022, Knut Reinert & Freie Universität Berlin
+// Copyright (c) 2016-2022, Knut Reinert & MPI für molekulare Genetik
+// This file may be used, modified and/or redistributed under the terms of the 3-clause BSD-License
+// shipped with this file and also available at: https://github.com/seqan/seqan3/blob/master/LICENSE.md
+// -----------------------------------------------------------------------------------------------------
+
+#include <benchmark/benchmark.h>
+
+#include <seqan3/alphabet/nucleotide/dna4.hpp>
+#include <seqan3/test/performance/sequence_generator.hpp>
+
+auto const always_true = [](seqan3::dna4 const letter)
+{
+    return letter.to_rank() < 42u;
+};
+auto const randomly_true = [](seqan3::dna4 const letter)
+{
+    return letter.to_rank() > 1u;
+};
+auto const never_true = [](seqan3::dna4 const letter)
+{
+    return letter.to_rank() > 42u;
+};
+
+void baseline(benchmark::State & state)
+{
+    std::vector<seqan3::dna4> input = seqan3::test::generate_sequence<seqan3::dna4>(10000, 0, 0);
+
+    for (auto _ : state)
+    {
+        std::vector<seqan3::dna4> output{};
+        for (seqan3::dna4 const letter : input)
+            output.push_back(letter);
+        output.clear();
+    }
+}
+
+template <typename predicate_t>
+void loop_if(benchmark::State & state, predicate_t predicate)
+{
+    std::vector<seqan3::dna4> input = seqan3::test::generate_sequence<seqan3::dna4>(10000, 0, 0);
+
+    for (auto _ : state)
+    {
+        std::vector<seqan3::dna4> output{};
+        for (seqan3::dna4 const letter : input)
+            if (predicate(letter))
+                output.push_back(letter);
+        output.clear();
+    }
+}
+
+template <typename predicate_t>
+void loop_view(benchmark::State & state, predicate_t predicate)
+{
+    std::vector<seqan3::dna4> input = seqan3::test::generate_sequence<seqan3::dna4>(10000, 0, 0);
+
+    for (auto _ : state)
+    {
+        std::vector<seqan3::dna4> output{};
+        for (seqan3::dna4 const letter : input | std::views::filter(predicate))
+            output.push_back(letter);
+        output.clear();
+    }
+}
+
+template <typename predicate_t>
+void copy_view(benchmark::State & state, predicate_t predicate)
+{
+    std::vector<seqan3::dna4> input = seqan3::test::generate_sequence<seqan3::dna4>(10000, 0, 0);
+
+    for (auto _ : state)
+    {
+        std::vector<seqan3::dna4> output{};
+        std::ranges::copy(input | std::views::filter(predicate), std::back_inserter(output));
+        output.clear();
+    }
+}
+
+BENCHMARK(baseline);
+
+BENCHMARK_CAPTURE(loop_if, "always_true", always_true);
+BENCHMARK_CAPTURE(loop_view, "always_true", always_true);
+BENCHMARK_CAPTURE(copy_view, "always_true", always_true);
+
+BENCHMARK_CAPTURE(loop_if, "randomly_true", randomly_true);
+BENCHMARK_CAPTURE(loop_view, "randomly_true", randomly_true);
+BENCHMARK_CAPTURE(copy_view, "randomly_true", randomly_true);
+
+BENCHMARK_CAPTURE(loop_if, "never_true", never_true);
+BENCHMARK_CAPTURE(loop_view, "never_true", never_true);
+BENCHMARK_CAPTURE(copy_view, "never_true", never_true);
+
+// ============================================================================
+//  run
+// ============================================================================
+
+BENCHMARK_MAIN();