diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index ad2f74254..12116f7f4 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -194,7 +194,6 @@ jobs:
             libs/function_types \
             libs/functional \
             libs/fusion \
-            libs/integer \
             libs/io \
             libs/mp11 \
             libs/mpl \
@@ -203,11 +202,9 @@ jobs:
             libs/static_assert \
             libs/throw_exception \
             libs/tuple \
-            libs/type_index \
             libs/type_traits \
             libs/typeof \
-            libs/utility \
-            libs/variant
+            libs/utility
 
       - name: Build upstream Boost libraries (Ubuntu)
         if: matrix.os.name == 'ubuntu' && steps.cache-boost.outputs.cache-hit != 'true'
diff --git a/CMakeLists.txt b/CMakeLists.txt
index bc6c06d0f..d15c82a8a 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -80,26 +80,6 @@ list(APPEND iris_x4_boost_deps functional)
 list(APPEND iris_x4_boost_deps function)
 list(APPEND iris_x4_boost_deps bind)
 
-# Everything required by `variant` (manually confirmed)
-list(APPEND iris_x4_boost_deps variant)
-list(APPEND iris_x4_boost_deps integer)
-list(APPEND iris_x4_boost_deps type_index)
-list(APPEND iris_x4_boost_deps assert)
-list(APPEND iris_x4_boost_deps config)
-list(APPEND iris_x4_boost_deps container_hash)
-list(APPEND iris_x4_boost_deps core)
-list(APPEND iris_x4_boost_deps detail)
-list(APPEND iris_x4_boost_deps mpl)
-list(APPEND iris_x4_boost_deps preprocessor)
-list(APPEND iris_x4_boost_deps static_assert)
-list(APPEND iris_x4_boost_deps throw_exception)
-list(APPEND iris_x4_boost_deps type_traits)
-list(APPEND iris_x4_boost_deps utility)
-list(APPEND iris_x4_boost_deps describe)
-list(APPEND iris_x4_boost_deps mp11)
-list(APPEND iris_x4_boost_deps predef)
-list(APPEND iris_x4_boost_deps io)
-
 # Everything required by `preprocessor` (manually confirmed)
 list(APPEND iris_x4_boost_deps preprocessor)
 
diff --git a/README.md b/README.md
index 91ee2dc6a..f6baf801b 100644
--- a/README.md
+++ b/README.md
@@ -48,9 +48,9 @@ git submodule update --init --depth 1 --recursive -- \
     tools/build tools/boost_install libs/assert libs/bind libs/config \
     libs/container_hash libs/core libs/describe libs/detail \
     libs/function libs/function_types libs/functional libs/fusion \
-    libs/integer libs/io libs/mp11 libs/mpl libs/predef libs/preprocessor \
-    libs/static_assert libs/throw_exception libs/tuple libs/type_index \
-    libs/type_traits libs/typeof libs/utility libs/variant
+    libs/io libs/mp11 libs/mpl libs/predef libs/preprocessor \
+    libs/static_assert libs/throw_exception libs/tuple \
+    libs/type_traits libs/typeof libs/utility
 
 # Linux
 ./bootstrap.sh
diff --git a/include/iris/x4/core/detail/parse_into_container.hpp b/include/iris/x4/core/detail/parse_into_container.hpp
index 8b8e084ae..7a2c3b4d8 100644
--- a/include/iris/x4/core/detail/parse_into_container.hpp
+++ b/include/iris/x4/core/detail/parse_into_container.hpp
@@ -22,8 +22,6 @@
 #include <boost/fusion/sequence/intrinsic/front.hpp>
 #include <boost/fusion/sequence/intrinsic/back.hpp>
 
-#include <boost/variant/variant.hpp> // TODO: remove Boost.Variant usage
-
 #include <iterator>
 #include <type_traits>
 #include <utility>
diff --git a/include/iris/x4/debug/print_attribute.hpp b/include/iris/x4/debug/print_attribute.hpp
index 10978c1bd..b81774fcc 100644
--- a/include/iris/x4/debug/print_attribute.hpp
+++ b/include/iris/x4/debug/print_attribute.hpp
@@ -14,10 +14,9 @@
 #include <iris/x4/traits/attribute_category.hpp>
 #include <iris/x4/traits/variant_traits.hpp>
 
-#include <boost/fusion/include/for_each.hpp>
+#include <iris/rvariant/rvariant_io.hpp>
 
-#include <boost/variant.hpp>
-#include <boost/variant/apply_visitor.hpp> // TODO: remove this
+#include <boost/fusion/include/for_each.hpp>
 
 #ifdef IRIS_X4_UNICODE
 # include <iris/x4/char_encoding/unicode.hpp>
@@ -57,9 +56,9 @@ struct print_fusion_sequence
 
 // print elements in a variant
 template<class Out>
-struct print_visitor : boost::static_visitor<>
+struct print_visitor
 {
-    print_visitor(Out& out)
+    explicit print_visitor(Out& out)
         : out(out)
     {}
 
@@ -144,7 +143,7 @@ struct print_attribute_debug
     // for variant types
     static void call(Out& out, CategorizedAttr<variant_attr> auto const& val)
     {
-        boost::apply_visitor(detail::print_visitor<Out>(out), val);
+        iris::visit(detail::print_visitor<Out>{out}, val);
     }
 
     static void call(Out& out, CategorizedAttr<optional_attr> auto const& val)
diff --git a/include/iris/x4/operator/alternative.hpp b/include/iris/x4/operator/alternative.hpp
index 6f70dd6e0..84a1a323a 100644
--- a/include/iris/x4/operator/alternative.hpp
+++ b/include/iris/x4/operator/alternative.hpp
@@ -19,7 +19,7 @@
 #include <iris/x4/traits/attribute_of_binary.hpp>
 #include <iris/x4/traits/container_traits.hpp>
 
-#include <boost/variant/variant.hpp> // TODO: remove this
+#include <iris/rvariant/rvariant.hpp>
 
 #include <concepts>
 #include <iterator>
@@ -31,7 +31,7 @@ namespace iris::x4 {
 template<class Left, class Right>
 struct alternative : binary_parser<Left, Right, alternative<Left, Right>>
 {
-    using attribute_type = traits::attribute_of_binary<boost::variant, alternative, Left, Right>::type;
+    using attribute_type = traits::attribute_of_binary<iris::rvariant, alternative, Left, Right>::type;
 
     using binary_parser<Left, Right, alternative>::binary_parser;
 
diff --git a/include/iris/x4/traits/variant_traits.hpp b/include/iris/x4/traits/variant_traits.hpp
index d5484e92d..4c452e827 100644
--- a/include/iris/x4/traits/variant_traits.hpp
+++ b/include/iris/x4/traits/variant_traits.hpp
@@ -14,120 +14,113 @@
 
 #include <iris/x4/traits/substitution.hpp>
 
-#include <boost/variant/variant_fwd.hpp> // TODO: remove this
-
-#include <boost/mpl/find.hpp> // TODO: remove this
-#include <boost/mpl/deref.hpp> // TODO: remove this
-#include <boost/mpl/find_if.hpp> // TODO: remove this
-#include <boost/mpl/eval_if.hpp> // TODO: remove this
-#include <boost/mpl/begin_end.hpp> // TODO: remove this
+#include <iris/rvariant/variant_helper.hpp>
 
 #include <type_traits>
 
 namespace iris::x4::traits {
 
-// TODO: define a legit concept for determining variant-like types
-
 template<class T>
 struct is_variant : std::false_type {};
 
 template<class T>
 constexpr bool is_variant_v = is_variant<T>::value;
 
-// By declaring a nested struct named `adapted_variant_tag` in
-// your class, you tell X4 that it is regarded as a variant type.
-// The minimum required interface for such a variant is that it has
-// constructors for various types supported by your variant and
-// `::types` which is an mpl sequence of the contained types.
-// Note (2025): The above spec is obsolete and will change in the near future.
-//
-// This is an intrusive interface. For a non-intrusive interface,
-// specialize the is_variant trait.
-template<class T>
-    requires requires {
-        typename T::adapted_variant_tag;
-    }
-struct is_variant<T> : std::true_type
-{};
+// `std::variant` is not supported, as it does can't handle recursive types
 
-template<BOOST_VARIANT_ENUM_PARAMS(typename T)>
-struct is_variant<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>>
-    : std::true_type
-{};
+template<class... Ts>
+struct is_variant<iris::rvariant<Ts...>> : std::true_type {};
+
+
+namespace detail {
 
+template<class Attr, class... Ts>
+struct variant_find_substitute_impl;
 
-template<class Variant, X4Attribute T>
-struct variant_find_substitute
+template<class Attr>
+struct variant_find_substitute_impl<Attr>
 {
-    // Get the type from the Variant that can be a substitute for T.
-    // If none is found, just return T
-
-    using variant_type = Variant;
-    using types = typename variant_type::types;
-    using end = typename boost::mpl::end<types>::type;
-
-    using iter_1 = typename boost::mpl::find<types, T>::type;
-
-    using iter = typename boost::mpl::eval_if<
-        std::is_same<iter_1, end>,
-        boost::mpl::find_if<types, is_substitute<T, boost::mpl::_1>>,
-        std::type_identity<iter_1>
-    >::type;
-
-    using type = typename boost::mpl::eval_if<
-        std::is_same<iter, end>,
-        std::type_identity<T>,
-        boost::mpl::deref<iter>
-    >::type;
+    using type = Attr;
 };
 
-template<class Variant, X4Attribute T>
-using variant_find_substitute_t = typename variant_find_substitute<Variant, T>::type;
-
-template<class Variant>
-struct variant_find_substitute<Variant, Variant>
+template<class Attr, class First, class... Rest>
+struct variant_find_substitute_impl<Attr, First, Rest...>
 {
-    using type = Variant;
+    using type = std::conditional_t<
+        is_substitute_v<Attr, iris::unwrap_recursive_t<First>>,
+
+        // TODO
+        // Given some type `T`, when both `T` and `recursive_wrapper<T>` is seen
+        // during attribute resolution, X4 should ideally materialize the latter
+        // because:
+        //   - It means that the user has supplied at least one explicit type
+        //     (possibly a rule attribute type) that is `recursive_wrapper<T>`,
+        //   - Constructing `T` and then moving it to `recursive_wrapper<T>`
+        //     involves copying from stack to heap.
+        //
+        // This is to-do because the above optimization is currently not
+        // implementable in a straightforward way. We need to add
+        // `unwrap_recursive(attr)` to every places where any parser attempts
+        // to modify the content.
+        iris::unwrap_recursive_t<First>,
+
+        typename variant_find_substitute_impl<Attr, Rest...>::type
+    >;
 };
 
+} // detail
 
-namespace detail {
 
-template<class Variant, X4Attribute T>
-struct variant_has_substitute_impl
-{
-    // Find a type from the Variant that can be a substitute for T.
-    // return true_ if one is found, else false_
+template<class Variant, X4Attribute Attr>
+struct variant_find_substitute;
 
-    using variant_type = Variant;
-    using types = typename variant_type::types;
-    using end = typename boost::mpl::end<types>::type;
-    using iter_1 = typename boost::mpl::find<types, T>::type;
+template<class Variant, X4Attribute Attr>
+using variant_find_substitute_t = typename variant_find_substitute<Variant, Attr>::type;
 
-    using iter = typename boost::mpl::eval_if<
-        std::is_same<iter_1, end>,
-        boost::mpl::find_if<types, is_substitute<T, boost::mpl::_1>>,
-        std::type_identity<iter_1>
-    >::type;
+template<X4Attribute Attr>
+struct variant_find_substitute<Attr, Attr>
+{
+    using type = Attr;
+};
 
-    using type = std::bool_constant<!std::is_same_v<iter, end>>;
+// Recursively find the first type from the variant that can be a substitute for `Attr`.
+// If none is found, returns `Attr`.
+template<X4Attribute Attr, class... Ts>
+    requires (!std::same_as<iris::rvariant<Ts...>, Attr>)
+struct variant_find_substitute<iris::rvariant<Ts...>, Attr>
+{
+    using type = typename detail::variant_find_substitute_impl<Attr, Ts...>::type;
 };
 
-} // detail
 
 template<class Variant, X4Attribute Attr>
-struct variant_has_substitute
-    : detail::variant_has_substitute_impl<Variant, Attr>::type
-{};
+struct variant_has_substitute;
 
 template<class Variant, X4Attribute Attr>
 constexpr bool variant_has_substitute_v = variant_has_substitute<Variant, Attr>::value;
 
 template<X4Attribute Attr>
-struct variant_has_substitute<unused_type, Attr> : std::true_type {};
+struct variant_has_substitute<Attr, Attr>
+    : std::true_type
+{};
 
 template<X4Attribute Attr>
-struct variant_has_substitute<unused_type const, Attr> : std::true_type {};
+struct variant_has_substitute<unused_type, Attr>
+    : std::true_type
+{};
+
+template<X4Attribute Attr>
+struct variant_has_substitute<unused_type const, Attr>
+    : std::true_type
+{};
+
+// Recursively find the first type from the variant that can be a substitute for `T`.
+// Returns boolean value whether it was found.
+template<X4Attribute Attr, class... Ts>
+    requires (!std::same_as<iris::rvariant<Ts...>, Attr>)
+struct variant_has_substitute<iris::rvariant<Ts...>, Attr>
+    : std::disjunction<is_substitute<Attr, Ts>...>
+{};
 
 } // iris::x4::traits
 
diff --git a/modules/iris b/modules/iris
index a9359a6eb..7670a27a5 160000
--- a/modules/iris
+++ b/modules/iris
@@ -1 +1 @@
-Subproject commit a9359a6ebd84a27a3e44abfa243ddabdc04bcb6d
+Subproject commit 7670a27a52fa98e2d726fae1a425bd94806d42ab
diff --git a/test/x4/alternative.cpp b/test/x4/alternative.cpp
index 38a16f4d7..be45739c0 100644
--- a/test/x4/alternative.cpp
+++ b/test/x4/alternative.cpp
@@ -2,6 +2,7 @@
     Copyright (c) 2001-2015 Joel de Guzman
     Copyright (c) 2001-2011 Hartmut Kaiser
     Copyright (c) 2025 Nana Sakisaka
+    Copyright (c) 2026 The Iris Project Contributors
 
     Distributed under the Boost Software License, Version 1.0. (See accompanying
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -23,12 +24,12 @@
 #include <iris/x4/operator/list.hpp>
 #include <iris/x4/operator/optional.hpp>
 
+#include <iris/rvariant.hpp>
+
 #include <boost/fusion/include/adapt_struct.hpp>
 #include <boost/fusion/include/at_c.hpp>
 #include <boost/fusion/include/vector.hpp>
 
-#include <boost/variant.hpp>
-
 #include <string>
 #include <vector>
 
@@ -76,47 +77,47 @@ TEST_CASE("alternative")
     }
 
     {
-        using attr_type = boost::variant<undefined, int, char>;
+        using attr_type = iris::rvariant<undefined, int, char>;
         {
             attr_type v;
             REQUIRE(parse("12345", int_ | char_, v));
-            CHECK(boost::get<int>(v) == 12345);
+            CHECK(iris::get<int>(v) == 12345);
         }
         {
             attr_type v;
             REQUIRE(parse("12345", lit("rock") | int_ | char_, v));
-            CHECK(boost::get<int>(v) == 12345);
+            CHECK(iris::get<int>(v) == 12345);
         }
         {
             attr_type v;
             REQUIRE(parse("rock", lit("rock") | int_ | char_, v));
-            CHECK(v.which() == 0);
+            CHECK(v.index() == 0);
         }
         {
             attr_type v;
             REQUIRE(parse("x", lit("rock") | int_ | char_, v));
-            CHECK(boost::get<char>(v) == 'x');
+            CHECK(iris::get<char>(v) == 'x');
         }
     }
 
     {
         // Make sure that we are using the actual supplied attribute types
         // from the variant and not the expected type.
-        using attr_type = boost::variant<int, std::string>;
+        using attr_type = iris::rvariant<int, std::string>;
         {
             attr_type v;
             REQUIRE(parse("12345", int_ | +char_, v));
-            CHECK(boost::get<int>(v) == 12345);
+            CHECK(iris::get<int>(v) == 12345);
         }
         {
             attr_type v;
             REQUIRE(parse("abc", int_ | +char_, v));
-            CHECK(boost::get<std::string>(v) == "abc");
+            CHECK(iris::get<std::string>(v) == "abc");
         }
         {
             attr_type v;
             REQUIRE(parse("12345", +char_ | int_, v));
-            CHECK(boost::get<std::string>(v) == "12345");
+            CHECK(iris::get<std::string>(v) == "12345");
         }
     }
 
@@ -201,7 +202,7 @@ TEST_CASE("alternative")
 
     {
         //compile test only (bug_march_10_2011_8_35_am)
-        using value_type = boost::variant<double, std::string>;
+        using value_type = iris::rvariant<double, std::string>;
 
         using x4::rule;
 
@@ -211,7 +212,7 @@ TEST_CASE("alternative")
 
     {
         using x4::rule;
-        using d_line = boost::variant<di_ignore, di_include>;
+        using d_line = iris::rvariant<di_ignore, di_include>;
 
         rule<class ignore, di_ignore> ignore;
         rule<class include, di_include> include;
@@ -223,14 +224,14 @@ TEST_CASE("alternative")
 
     // single-element fusion vector tests
     {
-        boost::fusion::vector<boost::variant<int, std::string>> fv;
+        boost::fusion::vector<iris::rvariant<int, std::string>> fv;
         REQUIRE(parse("12345", int_ | +char_, fv));
-        CHECK(boost::get<int>(boost::fusion::at_c<0>(fv)) == 12345);
+        CHECK(iris::get<int>(boost::fusion::at_c<0>(fv)) == 12345);
     }
     {
-        boost::fusion::vector<boost::variant<int, std::string>> fvi;
+        boost::fusion::vector<iris::rvariant<int, std::string>> fvi;
         REQUIRE(parse("12345", int_ | int_, fvi));
-        CHECK(boost::get<int>(boost::fusion::at_c<0>(fvi)) == 12345);
+        CHECK(iris::get<int>(boost::fusion::at_c<0>(fvi)) == 12345);
     }
 
     // alternative over single element sequences as part of another sequence
@@ -240,11 +241,11 @@ TEST_CASE("alternative")
         constexpr auto keys = key1 | key2;
         constexpr auto pair = keys >> lit("=") >> +char_;
 
-        boost::fusion::deque<boost::variant<long, char>, std::string> attr_;
+        boost::fusion::deque<iris::rvariant<long, char>, std::string> attr_;
 
         REQUIRE(parse("long=ABC", pair, attr_));
-        CHECK(boost::get<long>(&boost::fusion::front(attr_)) != nullptr);
-        CHECK(boost::get<char>(&boost::fusion::front(attr_)) == nullptr);
+        CHECK(iris::get_if<long>(&boost::fusion::front(attr_)) != nullptr);
+        CHECK(iris::get_if<char>(&boost::fusion::front(attr_)) == nullptr);
     }
 
     {
@@ -271,7 +272,7 @@ TEST_CASE("alternative")
     {
         // regressing test for #603
         struct X {};
-        std::vector<boost::variant<std::string, int, X>> v;
+        std::vector<iris::rvariant<std::string, int, X>> v;
         REQUIRE(parse("xx42x9y", *(int_ | +char_('x') | 'y' >> attr(X{})), v));
         CHECK(v.size() == 5);
     }
@@ -288,21 +289,21 @@ TEST_CASE("alternative")
         struct X {};
         struct Y {};
         struct Z {};
-        boost::variant<X, Y, Z> v;
-        boost::variant<Y, X> x{X{}};
-        v = x; // boost::variant supports that convertion
+        iris::rvariant<X, Y, Z> v;
+        iris::rvariant<Y, X> x{X{}};
+        v = x; // iris::rvariant supports that convertion
         auto const p = 'x' >> attr(x) | 'z' >> attr(Z{});
         REQUIRE(parse("z", p, v));
-        CHECK(boost::get<Z>(&v) != nullptr);
+        CHECK(iris::get_if<Z>(&v) != nullptr);
         REQUIRE(parse("x", p, v));
-        CHECK(boost::get<X>(&v) != nullptr);
+        CHECK(iris::get_if<X>(&v) != nullptr);
     }
 
     {
         // regression test for #679
-        using Qaz = std::vector<boost::variant<int>>;
-        using Foo = std::vector<boost::variant<Qaz, int>>;
-        using Bar = std::vector<boost::variant<Foo, int>>;
+        using Qaz = std::vector<iris::rvariant<int>>;
+        using Foo = std::vector<iris::rvariant<Qaz, int>>;
+        using Bar = std::vector<iris::rvariant<Foo, int>>;
         Bar x;
         CHECK(parse("abaabb", +('a' >> attr(Foo{}) | 'b' >> attr(int{})), x));
     }
diff --git a/test/x4/raw.cpp b/test/x4/raw.cpp
index 8c74f4339..99e7ee28a 100644
--- a/test/x4/raw.cpp
+++ b/test/x4/raw.cpp
@@ -1,6 +1,7 @@
 /*=============================================================================
     Copyright (c) 2001-2014 Joel de Guzman
     Copyright (c) 2025 Nana Sakisaka
+    Copyright (c) 2026 The Iris Project Contributors
 
     Distributed under the Boost Software License, Version 1.0. (See accompanying
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -19,8 +20,9 @@
 #include <iris/x4/operator/plus.hpp>
 #include <iris/x4/operator/alternative.hpp>
 
+#include <iris/rvariant.hpp>
+
 #include <boost/fusion/include/std_pair.hpp>
-#include <boost/variant.hpp>
 
 #include <ranges>
 #include <string>
@@ -97,10 +99,10 @@ TEST_CASE("raw")
 
     {
         using range = std::ranges::subrange<std::string_view::const_iterator>;
-        boost::variant<int, range> attr;
+        iris::rvariant<int, range> attr;
 
         REQUIRE(parse("test", (int_ | raw[*char_]), attr));
-        auto const& rng = boost::get<range>(attr);
+        auto const& rng = iris::get<range>(attr);
         CHECK(std::string(rng.begin(), rng.end()) == "test");
     }
 
diff --git a/test/x4/rule3.cpp b/test/x4/rule3.cpp
index f154e4849..2d24792e0 100644
--- a/test/x4/rule3.cpp
+++ b/test/x4/rule3.cpp
@@ -1,6 +1,7 @@
 /*=============================================================================
     Copyright (c) 2001-2012 Joel de Guzman
     Copyright (c) 2025 Nana Sakisaka
+    Copyright (c) 2026 The Iris Project Contributors
 
     Distributed under the Boost Software License, Version 1.0. (See accompanying
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -18,11 +19,12 @@
 #include <iris/x4/operator/sequence.hpp>
 #include <iris/x4/operator/plus.hpp>
 
+#include <iris/rvariant/rvariant.hpp>
+#include <iris/rvariant/recursive_wrapper.hpp>
+
 #include <boost/fusion/include/adapt_struct.hpp>
 #include <boost/fusion/include/std_pair.hpp>
 
-#include <boost/variant.hpp>
-
 #include <string>
 #include <vector>
 #include <cstring>
@@ -47,10 +49,17 @@ IRIS_X4_DEFINE(b)
 
 namespace check_recursive {
 
-using node_t = boost::make_recursive_variant<
+struct node_array;
+
+using node_t = iris::rvariant<
    int,
-   std::vector<boost::recursive_variant_>
->::type;
+   iris::recursive_wrapper<node_array>
+>;
+
+struct node_array : std::vector<node_t>
+{
+    using std::vector<node_t>::vector;
+};
 
 x4::rule<class recursive_grammar_r, node_t> const grammar;
 
@@ -63,6 +72,7 @@ IRIS_X4_DEFINE(grammar)
 namespace check_recursive_scoped {
 
 using check_recursive::node_t;
+using check_recursive::node_array;
 
 x4::rule<class intvec_r, node_t> const intvec;
 auto const grammar = intvec = '[' >> intvec % ',' >> ']' | x4::int_;
@@ -147,12 +157,12 @@ TEST_CASE("rule3")
         using namespace check_recursive;
         node_t v;
         REQUIRE(parse("[4,2]", grammar, v));
-        CHECK((node_t{std::vector<node_t>{{4}, {2}}} == v));
+        CHECK((node_t{node_array{{4}, {2}}} == v));
     }
     {
         using namespace check_recursive_scoped;
         node_t v;
         REQUIRE(parse("[4,2]", grammar, v));
-        CHECK((node_t{std::vector<node_t>{{4}, {2}}} == v));
+        CHECK((node_t{node_array{{4}, {2}}} == v));
     }
 }
diff --git a/test/x4/rule4.cpp b/test/x4/rule4.cpp
index bbe119261..8c65f9ce0 100644
--- a/test/x4/rule4.cpp
+++ b/test/x4/rule4.cpp
@@ -1,6 +1,7 @@
 /*=============================================================================
     Copyright (c) 2001-2015 Joel de Guzman
     Copyright (c) 2025 Nana Sakisaka
+    Copyright (c) 2026 The Iris Project Contributors
 
     Distributed under the Boost Software License, Version 1.0. (See accompanying
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -15,11 +16,11 @@
 #include <iris/x4/operator/plus.hpp>
 #include <iris/x4/operator/sequence.hpp>
 
+#include <iris/rvariant.hpp>
+
 #include <boost/fusion/include/at_c.hpp>
 #include <boost/fusion/include/vector.hpp>
 
-#include <boost/variant.hpp>
-
 #include <iterator>
 #include <string>
 #include <cstring>
@@ -153,12 +154,12 @@ TEST_CASE("rule4")
     }
 
     {
-        using v_type = boost::variant<double, int>;
+        using v_type = iris::rvariant<double, int>;
         auto r1 = rule<class r1_id, v_type>{} = int_;
         v_type v;
         REQUIRE(parse("1", r1, v));
-        REQUIRE(v.which() == 1);
-        CHECK(boost::get<int>(v) == 1);
+        REQUIRE(v.index() == 1);
+        CHECK(iris::get<int>(v) == 1);
 
         using ov_type = std::optional<int>;
         auto r2 = rule<class r2_id, ov_type>{} = int_;
diff --git a/test/x4/sequence.cpp b/test/x4/sequence.cpp
index ba65c6c18..60ac50f69 100644
--- a/test/x4/sequence.cpp
+++ b/test/x4/sequence.cpp
@@ -1,6 +1,7 @@
 /*=============================================================================
     Copyright (c) 2001-2015 Joel de Guzman
     Copyright (c) 2025 Nana Sakisaka
+    Copyright (c) 2026 The Iris Project Contributors
 
     Distributed under the Boost Software License, Version 1.0. (See accompanying
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -25,6 +26,8 @@
 #include <iris/x4/operator/optional.hpp>
 #include <iris/x4/operator/alternative.hpp>
 
+#include <iris/rvariant/rvariant.hpp>
+
 #include <boost/fusion/include/at_c.hpp>
 #include <boost/fusion/include/vector.hpp>
 #include <boost/fusion/include/deque.hpp>
@@ -388,7 +391,7 @@ TEST_CASE("sequence")
     }
 
     {
-        using Attr = boost::variant<int, float>;
+        using Attr = iris::rvariant<int, float>;
         constexpr auto term = rule<class term_id, Attr>("term") = int_ | float_;
         constexpr auto expr = rule<class expr_id, Attr>("expr") = term | ('(' > term > ')');
         Attr var;