diff --git a/CMakeLists.txt b/CMakeLists.txt
index 386cc725..39350993 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -36,6 +36,7 @@ option(ENABLE_GUILE "enable building guile module" off)
 option(ENABLE_BOOST_COROUTINE "run benchmarks with boost coroutine" off)
 
 option(immer_BUILD_TESTS "Build tests" ON)
+option(immer_BUILD_ARCHIVE_TESTS "Build experimental archive tests" off)
 option(immer_BUILD_EXAMPLES "Build examples" ON)
 option(immer_BUILD_DOCS "Build docs" ON)
 option(immer_BUILD_EXTRAS "Build extras" ON)
diff --git a/extra/fuzzer/CMakeLists.txt b/extra/fuzzer/CMakeLists.txt
index 2c160f79..2b81bceb 100644
--- a/extra/fuzzer/CMakeLists.txt
+++ b/extra/fuzzer/CMakeLists.txt
@@ -1,32 +1,41 @@
+add_custom_target(fuzzers COMMENT "Build all fuzzers.")
 
-add_custom_target(fuzzers
-  COMMENT "Build all fuzzers.")
-
-if (CHECK_FUZZERS)
+if(CHECK_FUZZERS)
   add_dependencies(tests fuzzers)
 endif()
 
-# LIB_FUZZING_ENGINE is set by the Google OSS-Fuzz
-# infrastructure. Otherwise we use Clang's LibFuzzer
-if (DEFINED ENV{LIB_FUZZING_ENGINE})
+# LIB_FUZZING_ENGINE is set by the Google OSS-Fuzz infrastructure. Otherwise we
+# use Clang's LibFuzzer
+if(DEFINED ENV{LIB_FUZZING_ENGINE})
   set(immer_fuzzing_engine $ENV{LIB_FUZZING_ENGINE})
 else()
   set(immer_fuzzing_engine "-fsanitize=fuzzer")
 endif()
 
 file(GLOB_RECURSE immer_fuzzers "*.cpp")
+foreach(TMP_PATH ${immer_fuzzers})
+  string(FIND ${TMP_PATH} immer-archive EXCLUDE_DIR_FOUND)
+  if(NOT ${EXCLUDE_DIR_FOUND} EQUAL -1)
+    list(REMOVE_ITEM immer_fuzzers ${TMP_PATH})
+  endif()
+endforeach(TMP_PATH)
+
 foreach(_file IN LISTS immer_fuzzers)
   immer_target_name_for(_target _output "${_file}")
   add_executable(${_target} EXCLUDE_FROM_ALL "${_file}")
   set_target_properties(${_target} PROPERTIES OUTPUT_NAME ${_output})
   target_compile_options(${_target} PUBLIC ${immer_fuzzing_engine})
-  target_link_libraries(${_target} PUBLIC ${immer_fuzzing_engine}
-    immer-dev)
+  target_compile_definitions(${_target} PUBLIC IMMER_THROW_ON_INVALID_STATE=1)
+  target_link_libraries(${_target} PUBLIC ${immer_fuzzing_engine} immer-dev)
   add_dependencies(fuzzers ${_target})
-  if (CHECK_FUZZERS)
+  if(CHECK_FUZZERS)
     add_test("fuzzer/${_output}" ${_output} -max_total_time=1)
   endif()
-  if (immer_INSTALL_FUZZERS)
+  if(immer_INSTALL_FUZZERS)
     install(TARGETS ${_target} DESTINATION bin)
   endif()
 endforeach()
+
+if(immer_BUILD_ARCHIVE_TESTS)
+  add_subdirectory(immer-archive)
+endif()
diff --git a/extra/fuzzer/flex-vector-st.cpp b/extra/fuzzer/flex-vector-st.cpp
index 1f2edb85..30f48ebd 100644
--- a/extra/fuzzer/flex-vector-st.cpp
+++ b/extra/fuzzer/flex-vector-st.cpp
@@ -42,8 +42,25 @@ extern "C" int LLVMFuzzerTestOneInput(const std::uint8_t* data,
     auto is_valid_size = [](auto& v) {
         return [&](auto idx) { return idx >= 0 && idx <= v.size(); };
     };
-    auto can_concat = [](auto&& v1, auto&& v2) {
-        return v1.size() + v2.size() < vector_t::max_size();
+    auto can_concat = [](const auto& v1, const auto& v2) {
+        // First, check max_size
+        if (v1.size() + v2.size() > vector_t::max_size()) {
+            return false;
+        }
+
+        // But just checking max_size is not sufficient, because there are other
+        // conditions for the validity of the tree, like shift constraints, for
+        // example.
+        try {
+            // Try to concat and catch an exception if it fails
+            const auto v3 = v1 + v2;
+            if (v3.size()) {
+                return true;
+            }
+        } catch (const immer::detail::rbts::invalid_tree&) {
+            return false;
+        }
+        return true;
     };
     auto can_compare = [](auto&& v) {
         // avoid comparing vectors that are too big, and hence, slow to compare
diff --git a/extra/fuzzer/immer-archive/CMakeLists.txt b/extra/fuzzer/immer-archive/CMakeLists.txt
new file mode 100644
index 00000000..d3ddbd82
--- /dev/null
+++ b/extra/fuzzer/immer-archive/CMakeLists.txt
@@ -0,0 +1,19 @@
+find_package(spdlog REQUIRED)
+
+file(GLOB_RECURSE immer_fuzzers "*.cpp")
+foreach(_file IN LISTS immer_fuzzers)
+  immer_target_name_for(_target _output "${_file}")
+  add_executable(${_target} EXCLUDE_FROM_ALL "${_file}")
+  set_target_properties(${_target} PROPERTIES OUTPUT_NAME ${_output})
+  target_compile_options(${_target} PUBLIC ${immer_fuzzing_engine})
+  target_include_directories(${_target} PRIVATE ../..)
+  target_link_libraries(${_target} PUBLIC ${immer_fuzzing_engine} immer-dev
+                                          spdlog::spdlog)
+  add_dependencies(fuzzers ${_target})
+  if(CHECK_FUZZERS)
+    add_test("fuzzer/${_output}" ${_output} -max_total_time=1)
+  endif()
+  if(immer_INSTALL_FUZZERS)
+    install(TARGETS ${_target} DESTINATION bin)
+  endif()
+endforeach()
diff --git a/extra/fuzzer/immer-archive/flex-vector.cpp b/extra/fuzzer/immer-archive/flex-vector.cpp
new file mode 100644
index 00000000..5c208dd1
--- /dev/null
+++ b/extra/fuzzer/immer-archive/flex-vector.cpp
@@ -0,0 +1,184 @@
+//
+// immer: immutable data structures for C++
+// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente
+//
+// This software is distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt
+//
+
+#include <fuzzer/fuzzer_input.hpp>
+
+#include <immer/box.hpp>
+#include <immer/flex_vector.hpp>
+
+#include <fmt/ranges.h>
+#include <immer/experimental/immer-archive/rbts/load.hpp>
+#include <immer/experimental/immer-archive/rbts/save.hpp>
+
+#include <array>
+
+namespace {
+void require_eq(const auto& a, const auto& b)
+{
+    if (a != b) {
+        throw std::runtime_error{
+            fmt::format("{} != {}", fmt::join(a, ", "), fmt::join(b, ", "))};
+    }
+}
+} // namespace
+
+extern "C" int LLVMFuzzerTestOneInput(const std::uint8_t* data,
+                                      std::size_t size)
+{
+    constexpr auto var_count = 8;
+    constexpr auto bits      = 2;
+
+    using vector_t =
+        immer::flex_vector<int, immer::default_memory_policy, bits, bits>;
+    using size_t = std::uint8_t;
+
+    const auto check_save_and_load = [&](const auto& vec) {
+        auto ar        = immer_archive::rbts::make_save_archive_for(vec);
+        auto vector_id = immer_archive::container_id{};
+        std::tie(ar, vector_id) = immer_archive::rbts::save_to_archive(vec, ar);
+
+        auto loader =
+            immer_archive::rbts::make_loader_for(vec, fix_leaf_nodes(ar));
+        auto loaded = loader.load(vector_id);
+        require_eq(vec, loaded);
+    };
+
+    auto vars = std::array<vector_t, var_count>{};
+
+    auto is_valid_var = [&](auto idx) { return idx >= 0 && idx < var_count; };
+    auto is_valid_var_neq = [](auto other) {
+        return [=](auto idx) {
+            return idx >= 0 && idx < var_count && idx != other;
+        };
+    };
+    auto is_valid_index = [](auto& v) {
+        return [&](auto idx) { return idx >= 0 && idx < v.size(); };
+    };
+    auto is_valid_size = [](auto& v) {
+        return [&](auto idx) { return idx >= 0 && idx <= v.size(); };
+    };
+    auto can_concat = [](auto&& v1, auto&& v2) {
+        return v1.size() + v2.size() < vector_t::max_size() / 4;
+    };
+    auto can_compare = [](auto&& v) {
+        // avoid comparing vectors that are too big, and hence, slow to compare
+        return v.size() < (1 << 15);
+    };
+    return fuzzer_input{data, size}.run([&](auto& in) {
+        enum ops
+        {
+            op_push_back,
+            op_update,
+            op_take,
+            op_drop,
+            op_concat,
+            op_push_back_move,
+            op_update_move,
+            op_take_move,
+            op_drop_move,
+            op_concat_move_l,
+            op_concat_move_r,
+            op_concat_move_lr,
+            op_insert,
+            op_erase,
+            op_compare,
+        };
+        auto src      = read<char>(in, is_valid_var);
+        auto dst      = read<char>(in, is_valid_var);
+        const auto op = read<char>(in);
+        SPDLOG_DEBUG("op = {}", static_cast<int>(op));
+        switch (op) {
+        case op_push_back: {
+            vars[dst] = vars[src].push_back(42);
+            break;
+        }
+        case op_update: {
+            auto idx  = read<size_t>(in, is_valid_index(vars[src]));
+            vars[dst] = vars[src].update(idx, [](auto x) { return x + 1; });
+            break;
+        }
+        case op_take: {
+            auto idx  = read<size_t>(in, is_valid_size(vars[src]));
+            vars[dst] = vars[src].take(idx);
+            break;
+        }
+        case op_drop: {
+            auto idx  = read<size_t>(in, is_valid_size(vars[src]));
+            vars[dst] = vars[src].drop(idx);
+            break;
+        }
+        case op_concat: {
+            auto src2 = read<char>(in, is_valid_var);
+            if (can_concat(vars[src], vars[src2]))
+                vars[dst] = vars[src] + vars[src2];
+            break;
+        }
+        case op_push_back_move: {
+            vars[dst] = std::move(vars[src]).push_back(21);
+            break;
+        }
+        case op_update_move: {
+            auto idx = read<size_t>(in, is_valid_index(vars[src]));
+            vars[dst] =
+                std::move(vars[src]).update(idx, [](auto x) { return x + 1; });
+            break;
+        }
+        case op_take_move: {
+            auto idx  = read<size_t>(in, is_valid_size(vars[src]));
+            vars[dst] = std::move(vars[src]).take(idx);
+            break;
+        }
+        case op_drop_move: {
+            auto idx  = read<size_t>(in, is_valid_size(vars[src]));
+            vars[dst] = std::move(vars[src]).drop(idx);
+            break;
+        }
+        case op_concat_move_l: {
+            auto src2 = read<char>(in, is_valid_var_neq(src));
+            if (can_concat(vars[src], vars[src2]))
+                vars[dst] = std::move(vars[src]) + vars[src2];
+            break;
+        }
+        case op_concat_move_r: {
+            auto src2 = read<char>(in, is_valid_var_neq(src));
+            if (can_concat(vars[src], vars[src2]))
+                vars[dst] = vars[src] + std::move(vars[src2]);
+            break;
+        }
+        case op_concat_move_lr: {
+            auto src2 = read<char>(in, is_valid_var_neq(src));
+            if (can_concat(vars[src], vars[src2]))
+                vars[dst] = std::move(vars[src]) + std::move(vars[src2]);
+            break;
+        }
+        case op_compare: {
+            using std::swap;
+            if (can_compare(vars[src]) && vars[src] == vars[dst])
+                swap(vars[src], vars[dst]);
+            break;
+        }
+        case op_erase: {
+            auto idx  = read<size_t>(in, is_valid_index(vars[src]));
+            vars[dst] = vars[src].erase(idx);
+            break;
+        }
+        case op_insert: {
+            auto idx  = read<size_t>(in, is_valid_size(vars[src]));
+            vars[dst] = vars[src].insert(idx, immer::box<int>{42});
+            break;
+        }
+        default:
+            break;
+        };
+
+        check_save_and_load(vars[src]);
+        check_save_and_load(vars[dst]);
+
+        return true;
+    });
+}
diff --git a/extra/fuzzer/immer-archive/fuzz-set.cpp b/extra/fuzzer/immer-archive/fuzz-set.cpp
new file mode 100644
index 00000000..db2472ca
--- /dev/null
+++ b/extra/fuzzer/immer-archive/fuzz-set.cpp
@@ -0,0 +1,119 @@
+#include <fuzzer/fuzzer_input.hpp>
+
+#include <immer/experimental/immer-archive/champ/champ.hpp>
+
+#include <array>
+#include <bitset>
+
+namespace {
+
+struct broken_hash
+{
+    std::size_t operator()(std::size_t map_key) const { return map_key & ~15; }
+};
+
+const auto into_set = [](const auto& set) {
+    using T     = typename std::decay_t<decltype(set)>::value_type;
+    auto result = immer::set<T>{};
+    for (const auto& item : set) {
+        result = std::move(result).insert(item);
+    }
+    return result;
+};
+
+} // namespace
+
+extern "C" int LLVMFuzzerTestOneInput(const std::uint8_t* data,
+                                      std::size_t size)
+{
+    constexpr auto var_count = 4;
+
+    using set_t = immer::set<std::size_t, broken_hash>;
+
+    auto vars = std::array<set_t, var_count>{};
+
+    auto is_valid_var = [&](auto idx) { return idx >= 0 && idx < var_count; };
+
+    return fuzzer_input{data, size}.run([&](auto& in) {
+        enum ops
+        {
+            op_insert,
+            op_erase,
+            op_insert_move,
+            op_erase_move,
+            op_iterate,
+            op_check,
+        };
+        auto src = read<char>(in, is_valid_var);
+        auto dst = read<char>(in, is_valid_var);
+        switch (read<char>(in)) {
+        case op_insert: {
+            auto value = read<size_t>(in);
+            vars[dst]  = vars[src].insert(value);
+            break;
+        }
+        case op_erase: {
+            auto value = read<size_t>(in);
+            vars[dst]  = vars[src].erase(value);
+            break;
+        }
+        case op_insert_move: {
+            auto value = read<size_t>(in);
+            vars[dst]  = std::move(vars[src]).insert(value);
+            break;
+        }
+        case op_erase_move: {
+            auto value = read<size_t>(in);
+            vars[dst]  = vars[src].erase(value);
+            break;
+        }
+        case op_iterate: {
+            auto srcv = vars[src];
+            for (const auto& v : srcv) {
+                vars[dst] = vars[dst].insert(v);
+            }
+            break;
+        }
+        case op_check: {
+            const auto bitset = std::bitset<var_count>(read<size_t>(in));
+            auto ids =
+                std::vector<std::pair<std::size_t, immer_archive::node_id>>{};
+            auto archive =
+                immer_archive::champ::container_archive_save<set_t>{};
+            for (auto index = std::size_t{}; index < var_count; ++index) {
+                if (bitset[index]) {
+                    auto set_id = immer_archive::node_id{};
+                    std::tie(archive, set_id) =
+                        immer_archive::champ::save_to_archive(vars[index],
+                                                              archive);
+                    ids.emplace_back(index, set_id);
+                }
+            }
+
+            auto loader = immer_archive::champ::container_loader<set_t>{
+                to_load_archive(archive)};
+
+            for (const auto& [index, set_id] : ids) {
+                const auto& set   = vars[index];
+                const auto loaded = loader.load(set_id);
+                assert(into_set(loaded) == into_set(set));
+                assert(into_set(set).size() == set.size());
+                for (const auto& item : set) {
+                    // This is the only thing that actually breaks if the hash
+                    // of the loaded set is not the same as the hash function of
+                    // the serialized set.
+                    assert(loaded.count(item));
+                }
+                for (const auto& item : loaded) {
+                    assert(set.count(item));
+                }
+            }
+
+            break;
+        }
+        default:
+            break;
+        };
+        return true;
+    });
+}
diff --git a/flake.lock b/flake.lock
index 523601b0..68bbc90b 100644
--- a/flake.lock
+++ b/flake.lock
@@ -1,5 +1,21 @@
 {
   "nodes": {
+    "arximboldi-cereal-src": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1650443560,
+        "narHash": "sha256-G8V5g0POddpukPmiWAX/MhnIhi+EEVE/P+MQGCGH/J0=",
+        "owner": "arximboldi",
+        "repo": "cereal",
+        "rev": "4bfaf5fee1cbc69db4614169092368a29c7607c4",
+        "type": "github"
+      },
+      "original": {
+        "owner": "arximboldi",
+        "repo": "cereal",
+        "type": "github"
+      }
+    },
     "flake-compat": {
       "flake": false,
       "locked": {
@@ -118,6 +134,7 @@
     },
     "root": {
       "inputs": {
+        "arximboldi-cereal-src": "arximboldi-cereal-src",
         "flake-compat": "flake-compat",
         "flake-utils": "flake-utils",
         "gitignore": "gitignore",
diff --git a/flake.nix b/flake.nix
index 18247fff..4777ef42 100644
--- a/flake.nix
+++ b/flake.nix
@@ -21,6 +21,10 @@
         nixpkgs.follows = "nixpkgs";
       };
     };
+    arximboldi-cereal-src = {
+      url = "github:arximboldi/cereal";
+      flake = false;
+    };
   };
 
   outputs = {
@@ -30,15 +34,26 @@
     flake-compat,
     pre-commit-hooks,
     gitignore,
+    arximboldi-cereal-src,
   }:
     flake-utils.lib.eachDefaultSystem (system: let
       pkgs = nixpkgs.legacyPackages.${system};
+
       withLLVM = drv:
         if pkgs.stdenv.isLinux
         # Use LLVM for Linux to build fuzzers
         then drv.override {stdenv = pkgs.llvmPackages_latest.stdenv;}
         # macOS uses LLVM by default
         else drv;
+
+      arximboldi-cereal = pkgs.callPackage ./nix/cereal.nix {inherit arximboldi-cereal-src;};
+
+      immer-archive-inputs = with pkgs; [
+        spdlog
+        arximboldi-cereal
+        xxHash
+        nlohmann_json
+      ];
     in {
       checks =
         {
@@ -58,6 +73,9 @@
             ninjaFlags = ["tests"];
             checkPhase = ''
               ctest -D ExperimentalMemCheck
+              valgrind --quiet --error-exitcode=99 --leak-check=full --errors-for-leak-kinds=all \
+                --suppressions=./test/experimental/immer-archive/valgrind.supp \
+                ./test/experimental/immer-archive/immer-archive-tests
             '';
           });
         };
@@ -70,10 +88,14 @@
           })
         ];
 
-        packages = [
-          # for the llvm-symbolizer binary, that allows to show stacks in ASAN and LeakSanitizer.
-          pkgs.llvmPackages_latest.bintools-unwrapped
-        ];
+        packages = with pkgs;
+          [
+            # for the llvm-symbolizer binary, that allows to show stacks in ASAN and LeakSanitizer.
+            llvmPackages_latest.bintools-unwrapped
+            cmake-format
+            alejandra
+          ]
+          ++ immer-archive-inputs;
 
         shellHook =
           self.checks.${system}.pre-commit-check.shellHook;
@@ -112,7 +134,7 @@
 
         unit-tests = (withLLVM self.packages.${system}.immer).overrideAttrs (prev: {
           name = "immer-unit-tests";
-          buildInputs = with pkgs; [catch2_3 boehmgc boost fmt];
+          buildInputs = with pkgs; [catch2_3 boehmgc boost fmt] ++ immer-archive-inputs;
           nativeBuildInputs = with pkgs; [cmake ninja];
           dontBuild = false;
           doCheck = true;
@@ -124,7 +146,9 @@
           cmakeFlags = [
             "-DCMAKE_BUILD_TYPE=Debug"
             "-Dimmer_BUILD_TESTS=ON"
+            "-Dimmer_BUILD_ARCHIVE_TESTS=ON"
             "-Dimmer_BUILD_EXAMPLES=OFF"
+            "-DCXX_STANDARD=20"
           ];
         });
       };
diff --git a/immer/config.hpp b/immer/config.hpp
index af34e5f1..9942c134 100644
--- a/immer/config.hpp
+++ b/immer/config.hpp
@@ -121,6 +121,10 @@
 #endif
 #endif
 
+#ifndef IMMER_THROW_ON_INVALID_STATE
+#define IMMER_THROW_ON_INVALID_STATE 0
+#endif
+
 namespace immer {
 
 const auto default_bits           = 5;
diff --git a/immer/detail/rbts/rrbtree.hpp b/immer/detail/rbts/rrbtree.hpp
index 843921ba..ab02a20a 100644
--- a/immer/detail/rbts/rrbtree.hpp
+++ b/immer/detail/rbts/rrbtree.hpp
@@ -25,6 +25,16 @@ namespace immer {
 namespace detail {
 namespace rbts {
 
+#if IMMER_THROW_ON_INVALID_STATE
+struct invalid_tree : std::exception
+{};
+#define IMMER_INVALID_STATE_ASSERT(expr)                                       \
+    if (!(expr))                                                               \
+    IMMER_THROW(invalid_tree{})
+#else
+#define IMMER_INVALID_STATE_ASSERT(expr) assert(expr)
+#endif
+
 template <typename T, typename MemoryPolicy, bits_t B, bits_t BL>
 struct rrbtree_iterator;
 
@@ -107,13 +117,32 @@ struct rrbtree
         assert(check_tree());
     }
 
-    rrbtree(size_t sz, shift_t sh, node_t* r, node_t* t) noexcept
+    rrbtree(size_t sz, shift_t sh, node_t* r, node_t* t)
+#if IMMER_THROW_ON_INVALID_STATE
+#else
+        noexcept
+#endif
         : size{sz}
         , shift{sh}
         , root{r}
         , tail{t}
     {
+#if IMMER_THROW_ON_INVALID_STATE
+        // assert only happens in the Debug build, but when
+        // IMMER_THROW_ON_INVALID_STATE is activated, we want to just check_tree
+        // even in Release.
+        try {
+            check_tree();
+        } catch (...) {
+            // This not fully constructed rrbtree owns the nodes already, have
+            // to dec them.
+            if (r && t)
+                dec();
+            throw;
+        }
+#else
         assert(check_tree());
+#endif
     }
 
     rrbtree(const rrbtree& other) noexcept
@@ -1339,13 +1368,13 @@ struct rrbtree
 
     bool check_tree() const
     {
-        assert(shift <= sizeof(size_t) * 8 - BL);
-        assert(shift >= BL);
-        assert(tail_offset() <= size);
-        assert(tail_size() <= branches<BL>);
+        IMMER_INVALID_STATE_ASSERT(shift <= sizeof(size_t) * 8 - BL);
+        IMMER_INVALID_STATE_ASSERT(shift >= BL);
+        IMMER_INVALID_STATE_ASSERT(tail_offset() <= size);
+        IMMER_INVALID_STATE_ASSERT(tail_size() <= branches<BL>);
 #if IMMER_DEBUG_DEEP_CHECK
-        assert(check_root());
-        assert(check_tail());
+        IMMER_INVALID_STATE_ASSERT(check_root());
+        IMMER_INVALID_STATE_ASSERT(check_tail());
 #endif
         return true;
     }
diff --git a/immer/experimental/immer-archive/alias.hpp b/immer/experimental/immer-archive/alias.hpp
new file mode 100644
index 00000000..0c5f8cf3
--- /dev/null
+++ b/immer/experimental/immer-archive/alias.hpp
@@ -0,0 +1,67 @@
+#pragma once
+
+#include <fmt/format.h>
+
+namespace immer_archive {
+
+template <class T, class Tag>
+struct type_alias
+{
+    using rep_t = T;
+
+    T value{};
+
+    type_alias() = default;
+
+    explicit type_alias(T value_)
+        : value{std::move(value_)}
+    {
+    }
+
+    friend bool operator==(const type_alias& left, const type_alias& right)
+    {
+        return left.value == right.value;
+    }
+
+    /**
+     * This works only starting with fmt v10.
+     */
+    friend auto format_as(const type_alias& v) { return v.value; }
+
+    template <class Archive>
+    auto save_minimal(const Archive&) const
+    {
+        return value;
+    }
+
+    template <class Archive>
+    auto load_minimal(const Archive&, const T& value_)
+    {
+        value = value_;
+    }
+};
+
+} // namespace immer_archive
+
+/**
+ * Have to use this for fmt v9.
+ */
+template <class T, class Tag>
+struct fmt::formatter<immer_archive::type_alias<T, Tag>> : formatter<T>
+{
+    template <typename FormatContext>
+    auto format(const immer_archive::type_alias<T, Tag>& value,
+                FormatContext& ctx) const
+    {
+        return formatter<T>::format(value.value, ctx);
+    }
+};
+
+template <class T, class Tag>
+struct std::hash<immer_archive::type_alias<T, Tag>>
+{
+    auto operator()(const immer_archive::type_alias<T, Tag>& x) const
+    {
+        return hash<T>{}(x.value);
+    }
+};
diff --git a/immer/experimental/immer-archive/cereal/immer_map.hpp b/immer/experimental/immer-archive/cereal/immer_map.hpp
new file mode 100644
index 00000000..88cbc3fa
--- /dev/null
+++ b/immer/experimental/immer-archive/cereal/immer_map.hpp
@@ -0,0 +1,100 @@
+#pragma once
+
+#include <cereal/cereal.hpp>
+
+#include <immer/map.hpp>
+
+namespace cereal {
+
+template <typename Element>
+auto get_auto_id(const Element& x) -> decltype(x.id)
+{
+    return x.id;
+}
+
+template <typename K, typename T>
+struct has_auto_id : std::false_type
+{};
+
+template <typename T>
+struct has_auto_id<std::decay_t<decltype(get_auto_id(std::declval<T>()))>, T>
+    : std::true_type
+{};
+
+template <typename Archive,
+          typename K,
+          typename T,
+          typename H,
+          typename E,
+          typename MP,
+          std::uint32_t B>
+std::enable_if_t<has_auto_id<K, T>::value>
+CEREAL_LOAD_FUNCTION_NAME(Archive& ar, immer::map<K, T, H, E, MP, B>& m)
+{
+    size_type size;
+    ar(make_size_tag(size));
+
+    for (auto i = size_type{}; i < size; ++i) {
+        T x;
+        ar(x);
+        auto id = get_auto_id(x);
+        m       = std::move(m).set(std::move(id), std::move(x));
+    }
+    if (size != m.size())
+        throw std::runtime_error{"duplicate ids?"};
+}
+
+template <typename Archive,
+          typename K,
+          typename T,
+          typename H,
+          typename E,
+          typename MP,
+          std::uint32_t B>
+std::enable_if_t<has_auto_id<K, T>::value>
+CEREAL_SAVE_FUNCTION_NAME(Archive& ar, const immer::map<K, T, H, E, MP, B>& m)
+{
+    ar(make_size_tag(static_cast<size_type>(m.size())));
+    for (auto&& v : m)
+        ar(v.second);
+}
+
+template <typename Archive,
+          typename K,
+          typename T,
+          typename H,
+          typename E,
+          typename MP,
+          std::uint32_t B>
+std::enable_if_t<!has_auto_id<K, T>::value>
+CEREAL_LOAD_FUNCTION_NAME(Archive& ar, immer::map<K, T, H, E, MP, B>& m)
+{
+    size_type size;
+    ar(make_size_tag(size));
+
+    for (auto i = size_type{}; i < size; ++i) {
+        K k;
+        T x;
+        ar(make_map_item(k, x));
+        m = std::move(m).set(std::move(k), std::move(x));
+    }
+    if (size != m.size())
+        throw std::runtime_error{"duplicate ids?"};
+}
+
+template <typename Archive,
+          typename K,
+          typename T,
+          typename H,
+          typename E,
+          typename MP,
+          std::uint32_t B>
+std::enable_if_t<!has_auto_id<K, T>::value>
+CEREAL_SAVE_FUNCTION_NAME(Archive& ar, const immer::map<K, T, H, E, MP, B>& m)
+{
+    ar(make_size_tag(static_cast<size_type>(m.size())));
+    for (auto&& v : m)
+        ar(make_map_item(v.first, v.second));
+}
+
+} // namespace cereal
diff --git a/immer/experimental/immer-archive/cereal/immer_vector.hpp b/immer/experimental/immer-archive/cereal/immer_vector.hpp
new file mode 100644
index 00000000..93bef240
--- /dev/null
+++ b/immer/experimental/immer-archive/cereal/immer_vector.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cereal/cereal.hpp>
+#include <immer/vector.hpp>
+
+namespace cereal {
+
+template <typename Archive,
+          typename T,
+          typename MemoryPolicy,
+          immer::detail::rbts::bits_t B,
+          immer::detail::rbts::bits_t BL>
+void CEREAL_LOAD_FUNCTION_NAME(Archive& ar,
+                               immer::vector<T, MemoryPolicy, B, BL>& m)
+{
+    size_type size;
+    ar(make_size_tag(size));
+
+    for (auto i = size_type{}; i < size; ++i) {
+        T x;
+        ar(x);
+        m = std::move(m).push_back(std::move(x));
+    }
+}
+
+template <typename Archive,
+          typename T,
+          typename MemoryPolicy,
+          immer::detail::rbts::bits_t B,
+          immer::detail::rbts::bits_t BL>
+void CEREAL_SAVE_FUNCTION_NAME(Archive& ar,
+                               const immer::vector<T, MemoryPolicy, B, BL>& m)
+{
+    ar(make_size_tag(static_cast<size_type>(m.size())));
+    for (auto&& v : m)
+        ar(v);
+}
+
+template <typename Archive,
+          typename T,
+          typename MemoryPolicy,
+          immer::detail::rbts::bits_t B,
+          immer::detail::rbts::bits_t BL>
+void CEREAL_LOAD_FUNCTION_NAME(Archive& ar,
+                               immer::flex_vector<T, MemoryPolicy, B, BL>& m)
+{
+    size_type size;
+    ar(make_size_tag(size));
+
+    for (auto i = size_type{}; i < size; ++i) {
+        T x;
+        ar(x);
+        m = std::move(m).push_back(std::move(x));
+    }
+}
+
+template <typename Archive,
+          typename T,
+          typename MemoryPolicy,
+          immer::detail::rbts::bits_t B,
+          immer::detail::rbts::bits_t BL>
+void CEREAL_SAVE_FUNCTION_NAME(
+    Archive& ar, const immer::flex_vector<T, MemoryPolicy, B, BL>& m)
+{
+    ar(make_size_tag(static_cast<size_type>(m.size())));
+    for (auto&& v : m)
+        ar(v);
+}
+
+} // namespace cereal
diff --git a/immer/experimental/immer-archive/champ/archive.hpp b/immer/experimental/immer-archive/champ/archive.hpp
new file mode 100644
index 00000000..6f287689
--- /dev/null
+++ b/immer/experimental/immer-archive/champ/archive.hpp
@@ -0,0 +1,186 @@
+#pragma once
+
+#include <immer/experimental/immer-archive/common/archive.hpp>
+
+#include <immer/map.hpp>
+#include <immer/set.hpp>
+#include <immer/table.hpp>
+#include <immer/vector.hpp>
+
+#include <cereal/cereal.hpp>
+#include <immer/experimental/immer-archive/cereal/immer_vector.hpp>
+
+#include <boost/endian/conversion.hpp>
+
+namespace immer_archive {
+namespace champ {
+
+template <class T, immer::detail::hamts::bits_t B>
+struct inner_node_save
+{
+    using bitmap_t = typename immer::detail::hamts::get_bitmap_type<B>::type;
+
+    values_save<T> values;
+    immer::vector<node_id> children;
+    bitmap_t nodemap;
+    bitmap_t datamap;
+    bool collisions{false};
+
+    template <class Archive>
+    void save(Archive& ar) const
+    {
+        ar(CEREAL_NVP(values),
+           CEREAL_NVP(children),
+           cereal::make_nvp("nodemap", boost::endian::native_to_big(nodemap)),
+           cereal::make_nvp("datamap", boost::endian::native_to_big(datamap)),
+           CEREAL_NVP(collisions));
+    }
+};
+
+template <class T, immer::detail::hamts::bits_t B>
+struct inner_node_load
+{
+    using bitmap_t = typename immer::detail::hamts::get_bitmap_type<B>::type;
+
+    values_load<T> values;
+    immer::vector<node_id> children;
+    bitmap_t nodemap;
+    bitmap_t datamap;
+    bool collisions{false};
+
+    auto tie() const
+    {
+        return std::tie(values, children, nodemap, datamap, collisions);
+    }
+
+    friend bool operator==(const inner_node_load& left,
+                           const inner_node_load& right)
+    {
+        return left.tie() == right.tie();
+    }
+
+    template <class Archive>
+    void load(Archive& ar)
+    {
+        ar(CEREAL_NVP(values),
+           CEREAL_NVP(children),
+           CEREAL_NVP(nodemap),
+           CEREAL_NVP(datamap),
+           CEREAL_NVP(collisions));
+        boost::endian::big_to_native_inplace(nodemap);
+        boost::endian::big_to_native_inplace(datamap);
+    }
+};
+
+template <class T, immer::detail::hamts::bits_t B>
+struct nodes_save
+{
+    // Saving is simpler with a map
+    immer::map<node_id, inner_node_save<T, B>> inners;
+
+    immer::map<const void*, node_id> node_ptr_to_id;
+};
+
+template <typename T,
+          typename Hash,
+          typename Equal,
+          typename MemoryPolicy,
+          immer::detail::hamts::bits_t B>
+std::pair<nodes_save<T, B>, node_id> get_node_id(
+    nodes_save<T, B> ar,
+    const immer::detail::hamts::node<T, Hash, Equal, MemoryPolicy, B>* ptr)
+{
+    auto* ptr_void = static_cast<const void*>(ptr);
+    if (auto* maybe_id = ar.node_ptr_to_id.find(ptr_void)) {
+        auto id = *maybe_id;
+        return {std::move(ar), id};
+    }
+
+    const auto id     = node_id{ar.node_ptr_to_id.size()};
+    ar.node_ptr_to_id = std::move(ar.node_ptr_to_id).set(ptr_void, id);
+    return {std::move(ar), id};
+}
+
+template <class T, immer::detail::hamts::bits_t B>
+using nodes_load = immer::vector<inner_node_load<T, B>>;
+
+template <template <class, immer::detail::hamts::bits_t> class InnerNodeType,
+          class T,
+          immer::detail::hamts::bits_t B>
+immer::vector<InnerNodeType<T, B>>
+linearize_map(const immer::map<node_id, inner_node_save<T, B>>& inners)
+{
+    auto result = immer::vector<InnerNodeType<T, B>>{};
+    for (auto index = std::size_t{}; index < inners.size(); ++index) {
+        auto* p = inners.find(node_id{index});
+        assert(p);
+        const auto& inner = *p;
+        result            = std::move(result).push_back(InnerNodeType<T, B>{
+                       .values     = inner.values,
+                       .children   = inner.children,
+                       .nodemap    = inner.nodemap,
+                       .datamap    = inner.datamap,
+                       .collisions = inner.collisions,
+        });
+    }
+    return result;
+}
+
+/**
+ * Container is a champ-based container.
+ */
+template <class Container>
+struct container_archive_save
+{
+    using champ_t = std::decay_t<decltype(std::declval<Container>().impl())>;
+    using T       = typename champ_t::node_t::value_t;
+
+    nodes_save<T, champ_t::bits> nodes;
+
+    // Saving the archived container, so that no mutations are allowed to
+    // happen.
+    immer::vector<Container> containers;
+
+    template <class Archive>
+    void save(Archive& ar) const
+    {
+        // To serialize, just save the list of nodes
+        auto inners = linearize_map<inner_node_save>(nodes.inners);
+        using cereal::save;
+        save(ar, inners);
+    }
+};
+
+template <class Container>
+struct container_archive_load
+{
+    using champ_t = std::decay_t<decltype(std::declval<Container>().impl())>;
+    using T       = typename champ_t::node_t::value_t;
+
+    nodes_load<T, champ_t::bits> nodes;
+
+    friend bool operator==(const container_archive_load& left,
+                           const container_archive_load& right)
+    {
+        return left.nodes == right.nodes;
+    }
+
+    template <class Archive>
+    void load(Archive& ar)
+    {
+        using cereal::load;
+        load(ar, nodes);
+    }
+};
+
+template <class Container>
+container_archive_load<Container>
+to_load_archive(const container_archive_save<Container>& archive)
+{
+    return {
+        .nodes = linearize_map<inner_node_load>(archive.nodes.inners),
+    };
+}
+
+} // namespace champ
+} // namespace immer_archive
diff --git a/immer/experimental/immer-archive/champ/champ.hpp b/immer/experimental/immer-archive/champ/champ.hpp
new file mode 100644
index 00000000..807dee1f
--- /dev/null
+++ b/immer/experimental/immer-archive/champ/champ.hpp
@@ -0,0 +1,142 @@
+#pragma once
+
+#include "archive.hpp"
+#include "load.hpp"
+#include "save.hpp"
+
+#include <optional>
+
+namespace immer_archive {
+namespace champ {
+
+template <class Node>
+struct node_traits
+{
+    template <typename T>
+    struct impl;
+
+    template <typename T,
+              typename Hash,
+              typename Equal,
+              typename MemoryPolicy,
+              immer::detail::hamts::bits_t B>
+    struct impl<immer::detail::hamts::node<T, Hash, Equal, MemoryPolicy, B>>
+    {
+        using equal_t              = Equal;
+        using hash_t               = Hash;
+        using memory_t             = MemoryPolicy;
+        static constexpr auto bits = B;
+    };
+
+    using Hash                 = typename impl<Node>::hash_t;
+    using Equal                = typename impl<Node>::equal_t;
+    using MemoryPolicy         = typename impl<Node>::memory_t;
+    static constexpr auto bits = impl<Node>::bits;
+};
+
+class hash_validation_failed_exception : public archive_exception
+{
+public:
+    hash_validation_failed_exception()
+        : archive_exception{"Hash validation failed, likely different hash "
+                            "algos are used for saving and loading"}
+    {
+    }
+};
+
+template <class Container>
+class container_loader
+{
+    using champ_t = std::decay_t<decltype(std::declval<Container>().impl())>;
+    using node_t  = typename champ_t::node_t;
+    using value_t = typename node_t::value_t;
+    using traits  = node_traits<node_t>;
+
+    struct project_value_ptr
+    {
+        const value_t* operator()(const value_t& v) const noexcept
+        {
+            return &v;
+        }
+    };
+
+public:
+    explicit container_loader(container_archive_load<Container> archive)
+        : archive_{std::move(archive)}
+        , nodes_{archive_.nodes}
+    {
+    }
+
+    Container load(node_id root_id)
+    {
+        if (root_id.value >= archive_.nodes.size()) {
+            throw invalid_node_id{root_id};
+        }
+
+        auto [root, values]    = nodes_.load_inner(root_id);
+        const auto items_count = [&values = values] {
+            auto count = std::size_t{};
+            for (const auto& items : values) {
+                count += items.size();
+            }
+            return count;
+        }();
+
+        auto impl = champ_t{std::move(root).release(), items_count};
+
+        // Validate the loaded champ by ensuring that all elements can be
+        // found. This verifies the hash function is the same as used while
+        // saving it.
+        for (const auto& items : values) {
+            for (const auto& item : items) {
+                const auto* p = impl.template get<
+                    project_value_ptr,
+                    immer::detail::constantly<const value_t*, nullptr>>(item);
+                if (!p) {
+                    throw hash_validation_failed_exception{};
+                }
+                if (!(*p == item)) {
+                    throw hash_validation_failed_exception{};
+                }
+            }
+        }
+
+        // XXX This ctor is not public in immer.
+        return impl;
+    }
+
+private:
+    const container_archive_load<Container> archive_;
+    nodes_loader<typename node_t::value_t,
+                 typename traits::Hash,
+                 typename traits::Equal,
+                 typename traits::MemoryPolicy,
+                 traits::bits>
+        nodes_;
+};
+
+template <class Container>
+std::pair<container_archive_save<Container>, node_id>
+save_to_archive(Container container, container_archive_save<Container> archive)
+{
+    const auto& impl = container.impl();
+    auto root_id     = node_id{};
+    std::tie(archive.nodes, root_id) =
+        get_node_id(std::move(archive.nodes), impl.root);
+
+    if (archive.nodes.inners.count(root_id)) {
+        // Already been saved
+        return {std::move(archive), root_id};
+    }
+
+    archive.nodes = save_nodes(impl, std::move(archive.nodes));
+    assert(archive.nodes.inners.count(root_id));
+
+    archive.containers =
+        std::move(archive.containers).push_back(std::move(container));
+
+    return {std::move(archive), root_id};
+}
+
+} // namespace champ
+} // namespace immer_archive
diff --git a/immer/experimental/immer-archive/champ/load.hpp b/immer/experimental/immer-archive/champ/load.hpp
new file mode 100644
index 00000000..95b82453
--- /dev/null
+++ b/immer/experimental/immer-archive/champ/load.hpp
@@ -0,0 +1,227 @@
+#pragma once
+
+#include <immer/experimental/immer-archive/champ/archive.hpp>
+#include <immer/experimental/immer-archive/errors.hpp>
+#include <immer/experimental/immer-archive/node_ptr.hpp>
+
+#include <immer/flex_vector.hpp>
+
+#include <boost/range/adaptor/indexed.hpp>
+#include <spdlog/spdlog.h>
+
+namespace immer_archive {
+namespace champ {
+
+class children_count_corrupted_exception : public archive_exception
+{
+public:
+    children_count_corrupted_exception(node_id id,
+                                       std::uint64_t nodemap,
+                                       std::size_t expected_count,
+                                       std::size_t real_count)
+        : archive_exception{fmt::format(
+              "Loaded container is corrupted. Inner "
+              "node ID {} has nodemap {} which means it should have {} "
+              "children but it has {}",
+              id,
+              nodemap,
+              expected_count,
+              real_count)}
+    {
+    }
+};
+
+class data_count_corrupted_exception : public archive_exception
+{
+public:
+    data_count_corrupted_exception(node_id id,
+                                   std::uint64_t datamap,
+                                   std::size_t expected_count,
+                                   std::size_t real_count)
+        : archive_exception{fmt::format(
+              "Loaded container is corrupted. Inner "
+              "node ID {} has datamap {} which means it should contain {} "
+              "values but it has {}",
+              id,
+              datamap,
+              expected_count,
+              real_count)}
+    {
+    }
+};
+
+template <class T,
+          typename Hash                  = std::hash<T>,
+          typename Equal                 = std::equal_to<T>,
+          typename MemoryPolicy          = immer::default_memory_policy,
+          immer::detail::hamts::bits_t B = immer::default_bits>
+class nodes_loader
+{
+public:
+    using champ_t =
+        immer::detail::hamts::champ<T, Hash, Equal, MemoryPolicy, B>;
+    using node_t   = typename champ_t::node_t;
+    using node_ptr = immer_archive::node_ptr<node_t>;
+
+    using values_t = immer::flex_vector<immer::array<T>>;
+
+    explicit nodes_loader(nodes_load<T, B> archive)
+        : archive_{std::move(archive)}
+    {
+    }
+
+    std::pair<node_ptr, values_t> load_collision(node_id id)
+    {
+        if (auto* p = collisions_.find(id)) {
+            return *p;
+        }
+
+        if (id.value >= archive_.size()) {
+            throw invalid_node_id{id};
+        }
+
+        const auto& node_info = archive_[id.value];
+
+        const auto n = node_info.values.data.size();
+        auto node    = node_ptr{node_t::make_collision_n(n),
+                             [](auto* ptr) { node_t::delete_collision(ptr); }};
+        immer::detail::uninitialized_copy(node_info.values.data.begin(),
+                                          node_info.values.data.end(),
+                                          node.get()->collisions());
+        auto result =
+            std::make_pair(std::move(node), values_t{node_info.values.data});
+        collisions_ = std::move(collisions_).set(id, result);
+        return result;
+    }
+
+    std::pair<node_ptr, values_t> load_inner(node_id id)
+    {
+        if (auto* p = inners_.find(id)) {
+            return *p;
+        }
+
+        if (id.value >= archive_.size()) {
+            throw invalid_node_id{id};
+        }
+
+        const auto& node_info = archive_[id.value];
+
+        const auto children_count = node_info.children.size();
+        const auto values_count   = node_info.values.data.size();
+
+        // Loading validation
+        {
+            const auto expected_count =
+                immer::detail::hamts::popcount(node_info.nodemap);
+            if (expected_count != children_count) {
+                throw children_count_corrupted_exception{
+                    id, node_info.nodemap, expected_count, children_count};
+            }
+        }
+
+        {
+            const auto expected_count =
+                immer::detail::hamts::popcount(node_info.datamap);
+            if (expected_count != values_count) {
+                throw data_count_corrupted_exception{
+                    id, node_info.datamap, expected_count, values_count};
+            }
+        }
+
+        auto values = values_t{};
+
+        // Load children
+        const auto children = [&values, &node_info, this] {
+            auto [children_ptrs, children_values] =
+                load_children(node_info.children);
+
+            if (!children_values.empty()) {
+                values = std::move(values) + children_values;
+            }
+
+            /**
+             * NOTE: Be careful with release_full and exceptions, nodes will not
+             * be freed automatically.
+             */
+            auto result = immer::vector<ptr_with_deleter<node_t>>{};
+            for (auto& child : children_ptrs) {
+                result = std::move(result).push_back(
+                    std::move(child).release_full());
+            }
+            return result;
+        }();
+        const auto delete_children = [children]() {
+            for (const auto& ptr : children) {
+                ptr.dec();
+            }
+        };
+
+        auto inner =
+            node_ptr{node_t::make_inner_n(children_count, values_count),
+                     [delete_children](auto* ptr) {
+                         node_t::delete_inner(ptr);
+                         delete_children();
+                     }};
+        inner.get()->impl.d.data.inner.nodemap = node_info.nodemap;
+        inner.get()->impl.d.data.inner.datamap = node_info.datamap;
+
+        // Values
+        if (values_count) {
+            immer::detail::uninitialized_copy(node_info.values.data.begin(),
+                                              node_info.values.data.end(),
+                                              inner.get()->values());
+            values = std::move(values).push_back(node_info.values.data);
+        }
+
+        // Set children
+        for (const auto& [index, child_ptr] :
+             boost::adaptors::index(children)) {
+            inner.get()->children()[index] = child_ptr.ptr;
+        }
+
+        inners_ = std::move(inners_).set(id, std::make_pair(inner, values));
+        return {std::move(inner), std::move(values)};
+    }
+
+    std::pair<node_ptr, values_t> load_some_node(node_id id)
+    {
+        if (id.value >= archive_.size()) {
+            throw invalid_node_id{id};
+        }
+
+        if (archive_[id.value].collisions) {
+            return load_collision(id);
+        } else {
+            return load_inner(id);
+        }
+    }
+
+    std::pair<std::vector<node_ptr>, values_t>
+    load_children(const immer::vector<node_id>& children_ids)
+    {
+        auto children = std::vector<node_ptr>{};
+        auto values   = values_t{};
+        for (const auto& child_node_id : children_ids) {
+            auto [child, child_values] = load_some_node(child_node_id);
+            if (!child) {
+                throw archive_exception{
+                    fmt::format("Failed to load node ID {}", child_node_id)};
+            }
+
+            if (!child_values.empty()) {
+                values = std::move(values) + child_values;
+            }
+
+            children.push_back(std::move(child));
+        }
+        return {std::move(children), std::move(values)};
+    }
+
+private:
+    const nodes_load<T, B> archive_;
+    immer::map<node_id, std::pair<node_ptr, values_t>> collisions_;
+    immer::map<node_id, std::pair<node_ptr, values_t>> inners_;
+};
+
+} // namespace champ
+} // namespace immer_archive
diff --git a/immer/experimental/immer-archive/champ/save.hpp b/immer/experimental/immer-archive/champ/save.hpp
new file mode 100644
index 00000000..d7faee97
--- /dev/null
+++ b/immer/experimental/immer-archive/champ/save.hpp
@@ -0,0 +1,101 @@
+#pragma once
+
+#include <immer/experimental/immer-archive/champ/archive.hpp>
+
+#include <spdlog/spdlog.h>
+
+namespace immer_archive {
+namespace champ {
+
+template <class T, immer::detail::hamts::bits_t B>
+struct nodes_archive_builder
+{
+    nodes_save<T, B> ar;
+
+    void visit_inner(const auto* node, auto depth)
+    {
+        auto id = get_node_id(node);
+        if (ar.inners.count(id)) {
+            return;
+        }
+
+        auto node_info = inner_node_save<T, B>{
+            .nodemap = node->nodemap(),
+            .datamap = node->datamap(),
+        };
+
+        if (node->datamap()) {
+            node_info.values = {node->values(),
+                                node->values() + node->data_count()};
+        }
+        if (node->nodemap()) {
+            auto fst = node->children();
+            auto lst = fst + node->children_count();
+            for (; fst != lst; ++fst) {
+                node_info.children =
+                    std::move(node_info.children).push_back(get_node_id(*fst));
+                visit(*fst, depth + 1);
+            }
+        }
+
+        ar.inners = std::move(ar.inners).set(id, node_info);
+    }
+
+    void visit_collision(const auto* node)
+    {
+        auto id = get_node_id(node);
+        if (ar.inners.count(id)) {
+            return;
+        }
+
+        ar.inners = std::move(ar.inners).set(
+            id,
+            inner_node_save<T, B>{
+                .values     = {node->collisions(),
+                               node->collisions() + node->collision_count()},
+                .collisions = true,
+            });
+    }
+
+    void visit(const auto* node, immer::detail::hamts::count_t depth)
+    {
+        using immer::detail::hamts::max_depth;
+
+        if (depth < max_depth<B>) {
+            visit_inner(node, depth);
+        } else {
+            visit_collision(node);
+        }
+    }
+
+    node_id get_node_id(auto* ptr)
+    {
+        auto [ar2, id] = immer_archive::champ::get_node_id(std::move(ar), ptr);
+        ar             = std::move(ar2);
+        return id;
+    }
+};
+
+template <typename T,
+          typename Hash,
+          typename Equal,
+          typename MemoryPolicy,
+          immer::detail::hamts::bits_t B,
+          class Archive>
+auto save_nodes(
+    const immer::detail::hamts::champ<T, Hash, Equal, MemoryPolicy, B>& champ,
+    Archive ar)
+{
+    using champ_t = std::decay_t<decltype(champ)>;
+    using node_t  = typename champ_t::node_t;
+
+    auto save = nodes_archive_builder<typename node_t::value_t, B>{
+        .ar = std::move(ar),
+    };
+    save.visit(champ.root, 0);
+
+    return std::move(save.ar);
+}
+
+} // namespace champ
+} // namespace immer_archive
diff --git a/immer/experimental/immer-archive/champ/traits.hpp b/immer/experimental/immer-archive/champ/traits.hpp
new file mode 100644
index 00000000..53e21497
--- /dev/null
+++ b/immer/experimental/immer-archive/champ/traits.hpp
@@ -0,0 +1,40 @@
+#pragma once
+
+#include <immer/experimental/immer-archive/champ/archive.hpp>
+#include <immer/experimental/immer-archive/champ/champ.hpp>
+#include <immer/experimental/immer-archive/traits.hpp>
+
+namespace immer_archive {
+
+template <class Container>
+struct champ_traits
+{
+    using save_archive_t =
+        immer_archive::champ::container_archive_save<Container>;
+    using load_archive_t =
+        immer_archive::champ::container_archive_load<Container>;
+    using loader_t     = immer_archive::champ::container_loader<Container>;
+    using container_id = immer_archive::node_id;
+};
+
+template <typename K,
+          typename T,
+          typename Hash,
+          typename Equal,
+          typename MemoryPolicy,
+          immer::detail::hamts::bits_t B>
+struct container_traits<immer::map<K, T, Hash, Equal, MemoryPolicy, B>>
+    : champ_traits<immer::map<K, T, Hash, Equal, MemoryPolicy, B>>
+{};
+
+template <typename T,
+          typename KeyFn,
+          typename Hash,
+          typename Equal,
+          typename MemoryPolicy,
+          immer::detail::hamts::bits_t B>
+struct container_traits<immer::table<T, KeyFn, Hash, Equal, MemoryPolicy, B>>
+    : champ_traits<immer::table<T, KeyFn, Hash, Equal, MemoryPolicy, B>>
+{};
+
+} // namespace immer_archive
diff --git a/immer/experimental/immer-archive/common/archive.hpp b/immer/experimental/immer-archive/common/archive.hpp
new file mode 100644
index 00000000..ad964090
--- /dev/null
+++ b/immer/experimental/immer-archive/common/archive.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <immer/experimental/immer-archive/alias.hpp>
+
+#include <immer/array.hpp>
+
+#include <cereal/types/utility.hpp>
+
+namespace immer_archive {
+
+struct node_id_tag;
+using node_id = type_alias<std::size_t, node_id_tag>;
+
+struct container_id_tag;
+using container_id = type_alias<std::size_t, container_id_tag>;
+
+template <class T>
+struct values_save
+{
+    const T* begin = nullptr;
+    const T* end   = nullptr;
+};
+
+template <class T>
+struct values_load
+{
+    immer::array<T> data;
+
+    values_load() = default;
+
+    values_load(immer::array<T> data_)
+        : data{std::move(data_)}
+    {
+    }
+
+    values_load(const values_save<T>& save)
+        : data{save.begin, save.end}
+    {
+    }
+
+    friend bool operator==(const values_load& left, const values_load& right)
+    {
+        return left.data == right.data;
+    }
+};
+
+template <class Archive, class T>
+void save(Archive& ar, const values_save<T>& value)
+{
+    ar(cereal::make_size_tag(
+        static_cast<cereal::size_type>(value.end - value.begin)));
+    for (auto p = value.begin; p != value.end; ++p) {
+        ar(*p);
+    }
+}
+
+template <class Archive, class T>
+void load(Archive& ar, values_load<T>& m)
+{
+    cereal::size_type size;
+    ar(cereal::make_size_tag(size));
+
+    for (auto i = cereal::size_type{}; i < size; ++i) {
+        T x;
+        ar(x);
+        m.data = std::move(m.data).push_back(std::move(x));
+    }
+}
+
+} // namespace immer_archive
diff --git a/immer/experimental/immer-archive/errors.hpp b/immer/experimental/immer-archive/errors.hpp
new file mode 100644
index 00000000..5d8583bb
--- /dev/null
+++ b/immer/experimental/immer-archive/errors.hpp
@@ -0,0 +1,54 @@
+#pragma once
+
+#include <immer/experimental/immer-archive/common/archive.hpp>
+
+#include <stdexcept>
+
+#include <fmt/format.h>
+
+namespace immer_archive {
+
+class archive_exception : public std::invalid_argument
+{
+public:
+    using invalid_argument::invalid_argument;
+};
+
+class archive_has_cycles : public archive_exception
+{
+public:
+    explicit archive_has_cycles(node_id id)
+        : archive_exception{fmt::format("Cycle detected with node ID {}", id)}
+    {
+    }
+};
+
+class invalid_node_id : public archive_exception
+{
+public:
+    explicit invalid_node_id(node_id id)
+        : archive_exception{fmt::format("Node ID {} is not found", id)}
+    {
+    }
+};
+
+class invalid_container_id : public archive_exception
+{
+public:
+    explicit invalid_container_id(container_id id)
+        : archive_exception{fmt::format("Container ID {} is not found", id)}
+    {
+    }
+};
+
+class invalid_children_count : public archive_exception
+{
+public:
+    explicit invalid_children_count(node_id id)
+        : archive_exception{
+              fmt::format("Node ID {} has more children than allowed", id)}
+    {
+    }
+};
+
+} // namespace immer_archive
diff --git a/immer/experimental/immer-archive/json/archivable.hpp b/immer/experimental/immer-archive/json/archivable.hpp
new file mode 100644
index 00000000..a91cdc7c
--- /dev/null
+++ b/immer/experimental/immer-archive/json/archivable.hpp
@@ -0,0 +1,114 @@
+#pragma once
+
+#include <immer/experimental/immer-archive/errors.hpp>
+#include <immer/experimental/immer-archive/json/json_immer.hpp>
+#include <immer/experimental/immer-archive/json/json_with_archive.hpp>
+#include <immer/experimental/immer-archive/traits.hpp>
+
+#include <fmt/format.h>
+
+namespace immer_archive {
+
+template <class Container>
+struct archivable
+{
+    Container container;
+
+    archivable() = default;
+
+    archivable(std::initializer_list<typename Container::value_type> values)
+        : container{std::move(values)}
+    {
+    }
+
+    archivable(Container container_)
+        : container{std::move(container_)}
+    {
+    }
+
+    friend bool operator==(const archivable& left, const archivable& right)
+    {
+        return left.container == right.container;
+    }
+
+    friend auto begin(const archivable& value)
+    {
+        return value.container.begin();
+    }
+
+    friend auto end(const archivable& value) { return value.container.end(); }
+};
+
+template <class Storage, class Names, class Container>
+auto save_minimal(
+    const json_immer_output_archive<detail::archives_save<Storage, Names>>& ar,
+    const archivable<Container>& value)
+{
+    auto& save_archive =
+        const_cast<
+            json_immer_output_archive<detail::archives_save<Storage, Names>>&>(
+            ar)
+            .get_output_archives()
+            .template get_save_archive<Container>();
+    auto [archive, id] =
+        save_to_archive(value.container, std::move(save_archive));
+    save_archive = std::move(archive);
+    return id.value;
+}
+
+// This function must exist because cereal does some checks and it's not
+// possible to have only load_minimal for a type without having save_minimal.
+template <class Storage, class Names, class Container>
+auto save_minimal(
+    const json_immer_output_archive<detail::archives_load<Storage, Names>>& ar,
+    const archivable<Container>& value) ->
+    typename container_traits<Container>::container_id::rep_t
+{
+    throw std::logic_error{"Should never be called"};
+}
+
+template <class ImmerArchives, class Container>
+void load_minimal(
+    const json_immer_input_archive<ImmerArchives>& ar,
+    archivable<Container>& value,
+    const typename container_traits<Container>::container_id::rep_t& id)
+{
+    auto& loader = const_cast<json_immer_input_archive<ImmerArchives>&>(ar)
+                       .get_input_archives()
+                       .template get_loader<Container>();
+
+    // Have to be specific because for vectors container_id is different from
+    // node_id, but for hash-based containers, a container is identified just by
+    // its root node.
+    using container_id_ = typename container_traits<Container>::container_id;
+
+    try {
+        value.container = loader.load(container_id_{id});
+    } catch (const archive_exception& ex) {
+        throw ::cereal::Exception{
+            fmt::format("Failed to load a container ID {} from the archive: {}",
+                        id,
+                        ex.what())};
+    }
+}
+
+// This function must exist because cereal does some checks and it's not
+// possible to have only load_minimal for a type without having save_minimal.
+template <class Archive, class Container>
+auto save_minimal(const Archive& ar, const archivable<Container>& value) ->
+    typename container_traits<Container>::container_id::rep_t
+{
+    throw std::logic_error{"Should never be called"};
+}
+
+template <class Archive, class Container>
+void load_minimal(
+    const Archive& ar,
+    archivable<Container>& value,
+    const typename container_traits<Container>::container_id::rep_t& id)
+{
+    // This one is actually called while loading with not-yet-fully-loaded
+    // archive.
+}
+
+} // namespace immer_archive
diff --git a/immer/experimental/immer-archive/json/json_immer.hpp b/immer/experimental/immer-archive/json/json_immer.hpp
new file mode 100644
index 00000000..c1b23d3e
--- /dev/null
+++ b/immer/experimental/immer-archive/json/json_immer.hpp
@@ -0,0 +1,511 @@
+#pragma once
+
+#include <cereal/archives/json.hpp>
+
+/**
+ * Special types of archives, working with JSON, that support providing extra
+ * context (ImmerArchives) to serialize immer data structures using
+ * immer-archive.
+ */
+
+namespace immer_archive {
+
+/**
+ * Adapted from cereal/archives/adapters.hpp
+ */
+
+template <class ImmerArchives>
+class json_immer_output_archive
+    : public cereal::OutputArchive<json_immer_output_archive<ImmerArchives>>
+    , public cereal::traits::TextArchive
+{
+public:
+    json_immer_output_archive(std::ostream& stream)
+        : cereal::OutputArchive<json_immer_output_archive<ImmerArchives>>{this}
+        , archive{stream}
+    {
+    }
+
+    json_immer_output_archive(ImmerArchives archives, std::ostream& stream)
+        : cereal::OutputArchive<json_immer_output_archive<ImmerArchives>>{this}
+        , archive{stream}
+        , archives{std::move(archives)}
+    {
+    }
+
+    ~json_immer_output_archive() {}
+
+    void startNode() { archive.startNode(); }
+    void writeName() { archive.writeName(); }
+    void finishNode() { archive.finishNode(); }
+    void setNextName(const char* name) { archive.setNextName(name); }
+    void makeArray() { archive.makeArray(); }
+
+    template <class T>
+    void saveValue(const T& value)
+    {
+        archive.saveValue(value);
+    }
+
+    ImmerArchives& get_output_archives() { return archives; }
+
+    void finalize()
+    {
+        auto& self = *this;
+        self(CEREAL_NVP(archives));
+    }
+
+private:
+    cereal::JSONOutputArchive archive;
+    ImmerArchives archives;
+};
+
+template <class ImmerArchives>
+class json_immer_input_archive
+    : public cereal::InputArchive<json_immer_input_archive<ImmerArchives>>
+    , public cereal::traits::TextArchive
+{
+public:
+    template <class... Args>
+    json_immer_input_archive(ImmerArchives archives_, Args&&... args)
+        : cereal::InputArchive<json_immer_input_archive<ImmerArchives>>{this}
+        , archive{std::forward<Args>(args)...}
+        , archives{std::move(archives_)}
+    {
+    }
+
+    void startNode() { archive.startNode(); }
+    void finishNode() { archive.finishNode(); }
+    void setNextName(const char* name) { archive.setNextName(name); }
+    void loadSize(cereal::size_type& size) { archive.loadSize(size); }
+    bool hasName(const char* name) { return archive.hasName(name); }
+
+    template <class T>
+    void loadValue(T& value)
+    {
+        archive.loadValue(value);
+    }
+
+    ImmerArchives& get_input_archives() { return archives; }
+
+private:
+    cereal::JSONInputArchive archive;
+    ImmerArchives archives;
+};
+
+/**
+ * NOTE: All of the following is needed, ultimately, to enable specializing
+ * serializing functions specifically for this type of archive that provides
+ * access to the immer-related archive.
+ *
+ * template <class ImmerArchives, class T>
+ * void load(json_immer_input_archive<ImmerArchives>& ar,
+ *           vector_one_archivable<T>& value)
+ */
+
+// ######################################################################
+// json_immer_{input/output}_archive prologue and epilogue functions
+// ######################################################################
+
+// ######################################################################
+//! Prologue for NVPs for JSON archives
+/*! NVPs do not start or finish nodes - they just set up the names */
+template <class ImmerArchives, class T>
+inline void prologue(json_immer_output_archive<ImmerArchives>&,
+                     cereal::NameValuePair<T> const&)
+{
+}
+
+//! Prologue for NVPs for JSON archives
+template <class ImmerArchives, class T>
+inline void prologue(json_immer_input_archive<ImmerArchives>&,
+                     cereal::NameValuePair<T> const&)
+{
+}
+
+// ######################################################################
+//! Epilogue for NVPs for JSON archives
+/*! NVPs do not start or finish nodes - they just set up the names */
+template <class ImmerArchives, class T>
+inline void epilogue(json_immer_output_archive<ImmerArchives>&,
+                     cereal::NameValuePair<T> const&)
+{
+}
+
+//! Epilogue for NVPs for JSON archives
+/*! NVPs do not start or finish nodes - they just set up the names */
+template <class ImmerArchives, class T>
+inline void epilogue(json_immer_input_archive<ImmerArchives>&,
+                     cereal::NameValuePair<T> const&)
+{
+}
+
+// ######################################################################
+//! Prologue for deferred data for JSON archives
+/*! Do nothing for the defer wrapper */
+template <class ImmerArchives, class T>
+inline void prologue(json_immer_output_archive<ImmerArchives>&,
+                     cereal::DeferredData<T> const&)
+{
+}
+
+//! Prologue for deferred data for JSON archives
+template <class ImmerArchives, class T>
+inline void prologue(json_immer_input_archive<ImmerArchives>&,
+                     cereal::DeferredData<T> const&)
+{
+}
+
+// ######################################################################
+//! Epilogue for deferred for JSON archives
+/*! NVPs do not start or finish nodes - they just set up the names */
+template <class ImmerArchives, class T>
+inline void epilogue(json_immer_output_archive<ImmerArchives>&,
+                     cereal::DeferredData<T> const&)
+{
+}
+
+//! Epilogue for deferred for JSON archives
+/*! Do nothing for the defer wrapper */
+template <class ImmerArchives, class T>
+inline void epilogue(json_immer_input_archive<ImmerArchives>&,
+                     cereal::DeferredData<T> const&)
+{
+}
+
+// ######################################################################
+//! Prologue for SizeTags for JSON archives
+/*! SizeTags are strictly ignored for JSON, they just indicate
+    that the current node should be made into an array */
+template <class ImmerArchives, class T>
+inline void prologue(json_immer_output_archive<ImmerArchives>& ar,
+                     cereal::SizeTag<T> const&)
+{
+    ar.makeArray();
+}
+
+//! Prologue for SizeTags for JSON archives
+template <class ImmerArchives, class T>
+inline void prologue(json_immer_input_archive<ImmerArchives>&,
+                     cereal::SizeTag<T> const&)
+{
+}
+
+// ######################################################################
+//! Epilogue for SizeTags for JSON archives
+/*! SizeTags are strictly ignored for JSON */
+template <class ImmerArchives, class T>
+inline void epilogue(json_immer_output_archive<ImmerArchives>&,
+                     cereal::SizeTag<T> const&)
+{
+}
+
+//! Epilogue for SizeTags for JSON archives
+template <class ImmerArchives, class T>
+inline void epilogue(json_immer_input_archive<ImmerArchives>&,
+                     cereal::SizeTag<T> const&)
+{
+}
+
+// ######################################################################
+//! Prologue for all other types for JSON archives (except minimal types)
+/*! Starts a new node, named either automatically or by some NVP,
+    that may be given data by the type about to be archived
+
+    Minimal types do not start or finish nodes */
+template <class ImmerArchives,
+          class T,
+          cereal::traits::EnableIf<
+              !std::is_arithmetic<T>::value,
+              !cereal::traits::has_minimal_base_class_serialization<
+                  T,
+                  cereal::traits::has_minimal_output_serialization,
+                  json_immer_output_archive<ImmerArchives>>::value,
+              !cereal::traits::has_minimal_output_serialization<
+                  T,
+                  json_immer_output_archive<ImmerArchives>>::value> =
+              cereal::traits::sfinae>
+inline void prologue(json_immer_output_archive<ImmerArchives>& ar, T const&)
+{
+    ar.startNode();
+}
+
+//! Prologue for all other types for JSON archives
+template <class ImmerArchives,
+          class T,
+          cereal::traits::EnableIf<
+              !std::is_arithmetic<T>::value,
+              !cereal::traits::has_minimal_base_class_serialization<
+                  T,
+                  cereal::traits::has_minimal_input_serialization,
+                  json_immer_input_archive<ImmerArchives>>::value,
+              !cereal::traits::has_minimal_input_serialization<
+                  T,
+                  json_immer_input_archive<ImmerArchives>>::value> =
+              cereal::traits::sfinae>
+inline void prologue(json_immer_input_archive<ImmerArchives>& ar, T const&)
+{
+    ar.startNode();
+}
+
+// ######################################################################
+//! Epilogue for all other types other for JSON archives (except minimal types)
+/*! Finishes the node created in the prologue
+
+    Minimal types do not start or finish nodes */
+template <class ImmerArchives,
+          class T,
+          cereal::traits::EnableIf<
+              !std::is_arithmetic<T>::value,
+              !cereal::traits::has_minimal_base_class_serialization<
+                  T,
+                  cereal::traits::has_minimal_output_serialization,
+                  json_immer_output_archive<ImmerArchives>>::value,
+              !cereal::traits::has_minimal_output_serialization<
+                  T,
+                  json_immer_output_archive<ImmerArchives>>::value> =
+              cereal::traits::sfinae>
+inline void epilogue(json_immer_output_archive<ImmerArchives>& ar, T const&)
+{
+    ar.finishNode();
+}
+
+//! Epilogue for all other types other for JSON archives
+template <class ImmerArchives,
+          class T,
+          cereal::traits::EnableIf<
+              !std::is_arithmetic<T>::value,
+              !cereal::traits::has_minimal_base_class_serialization<
+                  T,
+                  cereal::traits::has_minimal_input_serialization,
+                  json_immer_input_archive<ImmerArchives>>::value,
+              !cereal::traits::has_minimal_input_serialization<
+                  T,
+                  json_immer_input_archive<ImmerArchives>>::value> =
+              cereal::traits::sfinae>
+inline void epilogue(json_immer_input_archive<ImmerArchives>& ar, T const&)
+{
+    ar.finishNode();
+}
+
+// ######################################################################
+//! Prologue for arithmetic types for JSON archives
+template <class ImmerArchives>
+inline void prologue(json_immer_output_archive<ImmerArchives>& ar,
+                     std::nullptr_t const&)
+{
+    ar.writeName();
+}
+
+//! Prologue for arithmetic types for JSON archives
+template <class ImmerArchives>
+inline void prologue(json_immer_input_archive<ImmerArchives>&,
+                     std::nullptr_t const&)
+{
+}
+
+// ######################################################################
+//! Epilogue for arithmetic types for JSON archives
+template <class ImmerArchives>
+inline void epilogue(json_immer_output_archive<ImmerArchives>&,
+                     std::nullptr_t const&)
+{
+}
+
+//! Epilogue for arithmetic types for JSON archives
+template <class ImmerArchives>
+inline void epilogue(json_immer_input_archive<ImmerArchives>&,
+                     std::nullptr_t const&)
+{
+}
+
+// ######################################################################
+//! Prologue for arithmetic types for JSON archives
+template <class ImmerArchives,
+          class T,
+          cereal::traits::EnableIf<std::is_arithmetic<T>::value> =
+              cereal::traits::sfinae>
+inline void prologue(json_immer_output_archive<ImmerArchives>& ar, T const&)
+{
+    ar.writeName();
+}
+
+//! Prologue for arithmetic types for JSON archives
+template <class ImmerArchives,
+          class T,
+          cereal::traits::EnableIf<std::is_arithmetic<T>::value> =
+              cereal::traits::sfinae>
+inline void prologue(json_immer_input_archive<ImmerArchives>&, T const&)
+{
+}
+
+// ######################################################################
+//! Epilogue for arithmetic types for JSON archives
+template <class ImmerArchives,
+          class T,
+          cereal::traits::EnableIf<std::is_arithmetic<T>::value> =
+              cereal::traits::sfinae>
+inline void epilogue(json_immer_output_archive<ImmerArchives>&, T const&)
+{
+}
+
+//! Epilogue for arithmetic types for JSON archives
+template <class ImmerArchives,
+          class T,
+          cereal::traits::EnableIf<std::is_arithmetic<T>::value> =
+              cereal::traits::sfinae>
+inline void epilogue(json_immer_input_archive<ImmerArchives>&, T const&)
+{
+}
+
+// ######################################################################
+//! Prologue for strings for JSON archives
+template <class ImmerArchives, class CharT, class Traits, class Alloc>
+inline void prologue(json_immer_output_archive<ImmerArchives>& ar,
+                     std::basic_string<CharT, Traits, Alloc> const&)
+{
+    ar.writeName();
+}
+
+//! Prologue for strings for JSON archives
+template <class ImmerArchives, class CharT, class Traits, class Alloc>
+inline void prologue(json_immer_input_archive<ImmerArchives>&,
+                     std::basic_string<CharT, Traits, Alloc> const&)
+{
+}
+
+// ######################################################################
+//! Epilogue for strings for JSON archives
+template <class ImmerArchives, class CharT, class Traits, class Alloc>
+inline void epilogue(json_immer_output_archive<ImmerArchives>&,
+                     std::basic_string<CharT, Traits, Alloc> const&)
+{
+}
+
+//! Epilogue for strings for JSON archives
+template <class ImmerArchives, class CharT, class Traits, class Alloc>
+inline void epilogue(json_immer_input_archive<ImmerArchives>&,
+                     std::basic_string<CharT, Traits, Alloc> const&)
+{
+}
+
+// ######################################################################
+// Common JSONArchive serialization functions
+// ######################################################################
+//! Serializing NVP types to JSON
+template <class ImmerArchives, class T>
+inline void
+CEREAL_SAVE_FUNCTION_NAME(json_immer_output_archive<ImmerArchives>& ar,
+                          cereal::NameValuePair<T> const& t)
+{
+    ar.setNextName(t.name);
+    ar(t.value);
+}
+
+template <class ImmerArchives, class T>
+inline void
+CEREAL_LOAD_FUNCTION_NAME(json_immer_input_archive<ImmerArchives>& ar,
+                          cereal::NameValuePair<T>& t)
+{
+    ar.setNextName(t.name);
+    ar(t.value);
+}
+
+//! Saving for nullptr to JSON
+template <class ImmerArchives>
+inline void
+CEREAL_SAVE_FUNCTION_NAME(json_immer_output_archive<ImmerArchives>& ar,
+                          std::nullptr_t const& t)
+{
+    ar.saveValue(t);
+}
+
+//! Loading arithmetic from JSON
+template <class ImmerArchives>
+inline void
+CEREAL_LOAD_FUNCTION_NAME(json_immer_input_archive<ImmerArchives>& ar,
+                          std::nullptr_t& t)
+{
+    ar.loadValue(t);
+}
+
+//! Saving for arithmetic to JSON
+template <class ImmerArchives,
+          class T,
+          cereal::traits::EnableIf<std::is_arithmetic<T>::value> =
+              cereal::traits::sfinae>
+inline void
+CEREAL_SAVE_FUNCTION_NAME(json_immer_output_archive<ImmerArchives>& ar,
+                          T const& t)
+{
+    ar.saveValue(t);
+}
+
+//! Loading arithmetic from JSON
+template <class ImmerArchives,
+          class T,
+          cereal::traits::EnableIf<std::is_arithmetic<T>::value> =
+              cereal::traits::sfinae>
+inline void
+CEREAL_LOAD_FUNCTION_NAME(json_immer_input_archive<ImmerArchives>& ar, T& t)
+{
+    ar.loadValue(t);
+}
+
+//! saving string to JSON
+template <class ImmerArchives, class CharT, class Traits, class Alloc>
+inline void
+CEREAL_SAVE_FUNCTION_NAME(json_immer_output_archive<ImmerArchives>& ar,
+                          std::basic_string<CharT, Traits, Alloc> const& str)
+{
+    ar.saveValue(str);
+}
+
+//! loading string from JSON
+template <class ImmerArchives, class CharT, class Traits, class Alloc>
+inline void
+CEREAL_LOAD_FUNCTION_NAME(json_immer_input_archive<ImmerArchives>& ar,
+                          std::basic_string<CharT, Traits, Alloc>& str)
+{
+    ar.loadValue(str);
+}
+
+// ######################################################################
+//! Saving SizeTags to JSON
+template <class ImmerArchives, class T>
+inline void CEREAL_SAVE_FUNCTION_NAME(json_immer_output_archive<ImmerArchives>&,
+                                      cereal::SizeTag<T> const&)
+{
+    // nothing to do here, we don't explicitly save the size
+}
+
+//! Loading SizeTags from JSON
+template <class ImmerArchives, class T>
+inline void
+CEREAL_LOAD_FUNCTION_NAME(json_immer_input_archive<ImmerArchives>& ar,
+                          cereal::SizeTag<T>& st)
+{
+    ar.loadSize(st.size);
+}
+
+} // namespace immer_archive
+
+// tie input and output archives together
+namespace cereal {
+namespace traits {
+namespace detail {
+template <class ImmerArchives>
+struct get_output_from_input<
+    immer_archive::json_immer_input_archive<ImmerArchives>>
+{
+    using type = immer_archive::json_immer_output_archive<ImmerArchives>;
+};
+template <class ImmerArchives>
+struct get_input_from_output<
+    immer_archive::json_immer_output_archive<ImmerArchives>>
+{
+    using type = immer_archive::json_immer_input_archive<ImmerArchives>;
+};
+} // namespace detail
+} // namespace traits
+} // namespace cereal
diff --git a/immer/experimental/immer-archive/json/json_with_archive.hpp b/immer/experimental/immer-archive/json/json_with_archive.hpp
new file mode 100644
index 00000000..72872b8e
--- /dev/null
+++ b/immer/experimental/immer-archive/json/json_with_archive.hpp
@@ -0,0 +1,248 @@
+#pragma once
+
+#include <immer/experimental/immer-archive/json/json_immer.hpp>
+#include <immer/experimental/immer-archive/traits.hpp>
+
+#include <boost/hana.hpp>
+
+#include <optional>
+
+/**
+ * to_json_with_archive
+ */
+
+namespace immer_archive {
+
+namespace detail {
+
+namespace hana = boost::hana;
+
+/**
+ * Unimplemented class to generate a compile-time error and show what the type T
+ * is.
+ */
+template <class T>
+class error_no_archive_for_the_given_type_check_get_archives_types_function;
+
+/**
+ * Archives and functions to serialize types that contain immer-archivable data
+ * structures.
+ */
+template <class Storage, class Names>
+struct archives_save
+{
+    using names_t = Names;
+
+    Storage storage;
+
+    template <class Archive>
+    void save(Archive& ar) const
+    {
+        constexpr auto keys = hana::keys(names_t{});
+        hana::for_each(keys, [&](auto key) {
+            constexpr auto name = names_t{}[key];
+            ar(cereal::make_nvp(name.c_str(), storage[key]));
+        });
+    }
+
+    template <class T>
+    auto& get_save_archive()
+    {
+        using Contains = decltype(hana::contains(storage, hana::type_c<T>));
+        constexpr bool contains = hana::value<Contains>();
+        if constexpr (!contains) {
+            auto err =
+                error_no_archive_for_the_given_type_check_get_archives_types_function<
+                    T>{};
+        }
+        return storage[hana::type_c<T>];
+    }
+};
+
+template <class Container>
+struct archive_type_load
+{
+    typename container_traits<Container>::load_archive_t archive = {};
+    std::optional<typename container_traits<Container>::loader_t> loader;
+
+    archive_type_load() = default;
+
+    archive_type_load(const archive_type_load& other)
+        : archive{other.archive}
+    {
+    }
+
+    archive_type_load& operator=(const archive_type_load& other)
+    {
+        archive = other.archive;
+        return *this;
+    }
+
+    friend bool operator==(const archive_type_load& left,
+                           const archive_type_load& right)
+    {
+        return left.archive == right.archive;
+    }
+};
+
+template <class Storage, class Names>
+struct archives_load
+{
+    using names_t = Names;
+
+    Storage storage;
+
+    template <class Container>
+    auto& get_loader()
+    {
+        auto& load = storage[hana::type_c<Container>];
+        if (!load.loader) {
+            load.loader.emplace(load.archive);
+        }
+        return *load.loader;
+    }
+
+    template <class Archive>
+    void load(Archive& ar)
+    {
+        constexpr auto keys = hana::keys(names_t{});
+        hana::for_each(keys, [&](auto key) {
+            constexpr auto name = names_t{}[key];
+            ar(cereal::make_nvp(name.c_str(), storage[key].archive));
+        });
+    }
+
+    friend bool operator==(const archives_load& left,
+                           const archives_load& right)
+    {
+        return left.storage == right.storage;
+    }
+};
+
+inline auto generate_archives_save(auto type_names)
+{
+    auto storage =
+        hana::fold_left(type_names, hana::make_map(), [](auto map, auto pair) {
+            using Type = typename decltype(+hana::first(pair))::type;
+            return hana::insert(
+                map,
+                hana::make_pair(
+                    hana::first(pair),
+                    typename container_traits<Type>::save_archive_t{}));
+        });
+
+    using Storage = decltype(storage);
+    using Names   = decltype(type_names);
+    return archives_save<Storage, Names>{storage};
+}
+
+inline auto generate_archives_load(auto type_names)
+{
+    auto storage =
+        hana::fold_left(type_names, hana::make_map(), [](auto map, auto pair) {
+            using Type = typename decltype(+hana::first(pair))::type;
+            return hana::insert(
+                map,
+                hana::make_pair(hana::first(pair), archive_type_load<Type>{}));
+        });
+
+    using Storage = decltype(storage);
+    using Names   = decltype(type_names);
+    return archives_load<Storage, Names>{storage};
+}
+
+} // namespace detail
+
+template <class T>
+auto get_archives_types(const T&)
+{
+    return boost::hana::make_map();
+}
+
+template <class Archives>
+constexpr bool is_archive_empty(const Archives& archives)
+{
+    using Result =
+        decltype(boost::hana::is_empty(boost::hana::keys(archives.storage)));
+    return boost::hana::value<Result>();
+}
+
+/**
+ * Type T must provide a callable free function get_archives_types(const T&).
+ */
+template <typename T>
+auto to_json_with_archive(const T& serializable)
+{
+    auto archives =
+        detail::generate_archives_save(get_archives_types(serializable));
+    auto os = std::ostringstream{};
+    {
+        auto ar =
+            immer_archive::json_immer_output_archive<decltype(archives)>{os};
+        ar(serializable);
+        archives = ar.get_output_archives();
+
+        {
+            auto os2 = std::ostringstream{};
+            auto ar2 =
+                immer_archive::json_immer_output_archive<decltype(archives)>{
+                    archives, os2};
+            ar2(archives);
+            archives = ar2.get_output_archives();
+        }
+
+        ar.get_output_archives() = archives;
+        if constexpr (!is_archive_empty(archives)) {
+            ar.finalize();
+        }
+    }
+    return std::make_pair(os.str(), std::move(archives));
+}
+
+template <typename T>
+T from_json_with_archive(const std::string& input)
+{
+    using Archives = std::decay_t<decltype(detail::generate_archives_load(
+        get_archives_types(std::declval<T>())))>;
+    auto archives  = Archives{};
+
+    if constexpr (!is_archive_empty(archives)) {
+        {
+            auto is = std::istringstream{input};
+            auto ar = cereal::JSONInputArchive{is};
+            ar(CEREAL_NVP(archives));
+        }
+
+        const auto reload_archive = [&] {
+            auto is = std::istringstream{input};
+            auto ar =
+                immer_archive::json_immer_input_archive<Archives>{archives, is};
+            /**
+             * NOTE: Critical to clear the archives before loading into it
+             * again. I hit a bug when archives contained a vector and every
+             * load would append to it, instead of replacing the contents.
+             */
+            archives = {};
+            ar(CEREAL_NVP(archives));
+        };
+
+        auto prev = archives;
+        while (true) {
+            // Keep reloading until everything is loaded.
+            reload_archive();
+            if (prev == archives) {
+                break;
+            }
+            prev = archives;
+        }
+    }
+
+    auto is = std::istringstream{input};
+    auto ar = immer_archive::json_immer_input_archive<Archives>{
+        std::move(archives), is};
+    auto r = T{};
+    ar(r);
+    return r;
+}
+
+} // namespace immer_archive
diff --git a/immer/experimental/immer-archive/node_ptr.hpp b/immer/experimental/immer-archive/node_ptr.hpp
new file mode 100644
index 00000000..4c3186d8
--- /dev/null
+++ b/immer/experimental/immer-archive/node_ptr.hpp
@@ -0,0 +1,123 @@
+#pragma once
+
+#include <immer/vector.hpp>
+
+#include <spdlog/spdlog.h>
+
+namespace immer_archive {
+
+template <typename Node>
+struct ptr_with_deleter
+{
+    Node* ptr;
+    std::function<void(Node* ptr)> deleter;
+
+    ptr_with_deleter()
+        : ptr{nullptr}
+        , deleter{}
+    {
+    }
+
+    ptr_with_deleter(Node* ptr_, std::function<void(Node* ptr)> deleter_)
+        : ptr{ptr_}
+        , deleter{std::move(deleter_)}
+    {
+    }
+
+    void dec() const
+    {
+        if (ptr && ptr->dec()) {
+            SPDLOG_TRACE("calling deleter for {}", (void*) ptr);
+            deleter(ptr);
+        }
+    }
+
+    friend void swap(ptr_with_deleter& x, ptr_with_deleter& y)
+    {
+        using std::swap;
+        swap(x.ptr, y.ptr);
+        swap(x.deleter, y.deleter);
+    }
+};
+
+template <typename Node>
+class node_ptr
+{
+public:
+    node_ptr() = default;
+
+    node_ptr(Node* ptr_, std::function<void(Node* ptr)> deleter_)
+        : ptr{ptr_, std::move(deleter_)}
+    {
+        SPDLOG_TRACE("ctor {} with ptr {}", (void*) this, (void*) ptr.ptr);
+        // Assuming the node has just been created and not calling inc() on
+        // it.
+    }
+
+    node_ptr(const node_ptr& other)
+        : ptr{other.ptr}
+    {
+        SPDLOG_TRACE("copy ctor {} from {}", (void*) this, (void*) &other);
+        if (ptr.ptr) {
+            ptr.ptr->inc();
+        }
+    }
+
+    node_ptr(node_ptr&& other)
+        : node_ptr{}
+    {
+        SPDLOG_TRACE("move ctor {} from {}", (void*) this, (void*) &other);
+        swap(*this, other);
+    }
+
+    node_ptr& operator=(const node_ptr& other)
+    {
+        SPDLOG_TRACE("copy assign {} = {}", (void*) this, (void*) &other);
+        auto temp = other;
+        swap(*this, temp);
+        return *this;
+    }
+
+    node_ptr& operator=(node_ptr&& other)
+    {
+        SPDLOG_TRACE("move assign {} = {}", (void*) this, (void*) &other);
+        auto temp = node_ptr{std::move(other)};
+        swap(*this, temp);
+        return *this;
+    }
+
+    ~node_ptr()
+    {
+        SPDLOG_TRACE("dtor {}", (void*) this);
+        ptr.dec();
+    }
+
+    explicit operator bool() const { return ptr.ptr; }
+
+    Node* release() &&
+    {
+        auto result = ptr.ptr;
+        ptr.ptr     = nullptr;
+        return result;
+    }
+
+    auto release_full() &&
+    {
+        auto result = ptr;
+        ptr         = {};
+        return result;
+    }
+
+    Node* get() { return ptr.ptr; }
+
+    friend void swap(node_ptr& x, node_ptr& y)
+    {
+        using std::swap;
+        swap(x.ptr, y.ptr);
+    }
+
+private:
+    ptr_with_deleter<Node> ptr;
+};
+
+} // namespace immer_archive
diff --git a/immer/experimental/immer-archive/rbts/archive.hpp b/immer/experimental/immer-archive/rbts/archive.hpp
new file mode 100644
index 00000000..a7536ed9
--- /dev/null
+++ b/immer/experimental/immer-archive/rbts/archive.hpp
@@ -0,0 +1,162 @@
+#pragma once
+
+#include <immer/experimental/immer-archive/alias.hpp>
+#include <immer/experimental/immer-archive/cereal/immer_map.hpp>
+#include <immer/experimental/immer-archive/cereal/immer_vector.hpp>
+#include <immer/experimental/immer-archive/common/archive.hpp>
+
+#include <immer/array.hpp>
+#include <immer/flex_vector.hpp>
+#include <immer/map.hpp>
+#include <immer/vector.hpp>
+
+#include <cereal/cereal.hpp>
+
+namespace immer_archive::rbts {
+
+struct inner_node
+{
+    immer::vector<node_id> children;
+    bool relaxed = {};
+
+    auto tie() const { return std::tie(children, relaxed); }
+
+    friend bool operator==(const inner_node& left, const inner_node& right)
+    {
+        return left.tie() == right.tie();
+    }
+
+    template <class Archive>
+    void serialize(Archive& ar)
+    {
+        ar(CEREAL_NVP(children), CEREAL_NVP(relaxed));
+    }
+};
+
+struct rbts_info
+{
+    node_id root;
+    node_id tail;
+
+    auto tie() const { return std::tie(root, tail); }
+
+    friend bool operator==(const rbts_info& left, const rbts_info& right)
+    {
+        return left.tie() == right.tie();
+    }
+
+    template <class Archive>
+    void serialize(Archive& ar)
+    {
+        ar(CEREAL_NVP(root), CEREAL_NVP(tail));
+    }
+};
+
+template <typename T,
+          typename MemoryPolicy,
+          immer::detail::rbts::bits_t B,
+          immer::detail::rbts::bits_t BL>
+struct archive_save
+{
+    immer::map<node_id, values_save<T>> leaves;
+    immer::map<node_id, inner_node> inners;
+    immer::vector<rbts_info> vectors;
+
+    immer::map<rbts_info, container_id> rbts_to_id;
+    immer::map<const void*, node_id> node_ptr_to_id;
+
+    // Saving the archived vectors, so that no mutations are allowed to happen.
+    immer::vector<immer::vector<T, MemoryPolicy, B, BL>> saved_vectors;
+    immer::vector<immer::flex_vector<T, MemoryPolicy, B, BL>>
+        saved_flex_vectors;
+
+    template <class Archive>
+    void save(Archive& ar) const
+    {
+        ar(CEREAL_NVP(leaves), CEREAL_NVP(inners), CEREAL_NVP(vectors));
+    }
+};
+
+template <typename T,
+          typename MemoryPolicy,
+          immer::detail::rbts::bits_t B,
+          immer::detail::rbts::bits_t BL>
+inline auto make_save_archive_for(const immer::vector<T, MemoryPolicy, B, BL>&)
+{
+    return archive_save<T, MemoryPolicy, B, BL>{};
+}
+
+template <typename T,
+          typename MemoryPolicy,
+          immer::detail::rbts::bits_t B,
+          immer::detail::rbts::bits_t BL>
+inline auto
+make_save_archive_for(const immer::flex_vector<T, MemoryPolicy, B, BL>&)
+{
+    return archive_save<T, MemoryPolicy, B, BL>{};
+}
+
+template <typename T>
+struct archive_load
+{
+    immer::map<node_id, values_load<T>> leaves;
+    immer::map<node_id, inner_node> inners;
+    immer::vector<rbts_info> vectors;
+
+    auto tie() const { return std::tie(leaves, inners, vectors); }
+
+    friend bool operator==(const archive_load& left, const archive_load& right)
+    {
+        return left.tie() == right.tie();
+    }
+
+    template <class Archive>
+    void load(Archive& ar)
+    {
+        ar(CEREAL_NVP(leaves), CEREAL_NVP(inners), CEREAL_NVP(vectors));
+    }
+};
+
+// This is needed to be able to use the archive that was not read from JSON
+// because .data is set only while reading from JSON.
+template <typename T,
+          typename MemoryPolicy,
+          immer::detail::rbts::bits_t B,
+          immer::detail::rbts::bits_t BL>
+archive_load<T> fix_leaf_nodes(archive_save<T, MemoryPolicy, B, BL> ar)
+{
+    auto leaves = immer::map<node_id, values_load<T>>{};
+    for (const auto& item : ar.leaves) {
+        leaves = std::move(leaves).set(item.first, item.second);
+    }
+
+    return {
+        .leaves  = std::move(leaves),
+        .inners  = std::move(ar.inners),
+        .vectors = std::move(ar.vectors),
+    };
+}
+
+} // namespace immer_archive::rbts
+
+namespace std {
+
+template <>
+struct hash<immer_archive::rbts::rbts_info>
+{
+    auto operator()(const immer_archive::rbts::rbts_info& x) const
+    {
+        const auto boost_combine = [](std::size_t& seed, std::size_t hash) {
+            seed ^= hash + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+        };
+
+        auto seed = std::size_t{};
+        boost_combine(seed,
+                      hash<immer_archive::node_id::rep_t>{}(x.root.value));
+        boost_combine(seed,
+                      hash<immer_archive::node_id::rep_t>{}(x.tail.value));
+        return seed;
+    }
+};
+
+} // namespace std
diff --git a/immer/experimental/immer-archive/rbts/load.hpp b/immer/experimental/immer-archive/rbts/load.hpp
new file mode 100644
index 00000000..a127c836
--- /dev/null
+++ b/immer/experimental/immer-archive/rbts/load.hpp
@@ -0,0 +1,531 @@
+#pragma once
+
+#include <immer/experimental/immer-archive/errors.hpp>
+#include <immer/experimental/immer-archive/node_ptr.hpp>
+#include <immer/experimental/immer-archive/rbts/archive.hpp>
+#include <immer/experimental/immer-archive/rbts/traverse.hpp>
+
+#include <boost/hana.hpp>
+#include <boost/range/adaptor/indexed.hpp>
+#include <immer/set.hpp>
+#include <immer/vector.hpp>
+#include <optional>
+
+#include <spdlog/spdlog.h>
+
+namespace immer_archive::rbts {
+
+inline constexpr auto get_shift_for_depth(immer::detail::rbts::bits_t b,
+                                          immer::detail::rbts::bits_t bl,
+                                          immer::detail::rbts::count_t depth)
+{
+    auto bits      = immer::detail::rbts::shift_t{b};
+    auto bits_leaf = immer::detail::rbts::shift_t{bl};
+    return bits_leaf + bits * (immer::detail::rbts::shift_t{depth} - 1);
+}
+
+class vector_corrupted_exception : public archive_exception
+{
+public:
+    vector_corrupted_exception(node_id id_,
+                               std::size_t expected_count_,
+                               std::size_t real_count_)
+        : archive_exception{fmt::format("Loaded vector is corrupted. Inner "
+                                        "node ID {} should "
+                                        "have {} children but it has {}",
+                                        id_,
+                                        expected_count_,
+                                        real_count_)}
+        , id{id_}
+        , expected_count{expected_count_}
+        , real_count{real_count_}
+    {
+    }
+
+    node_id id;
+    std::size_t expected_count;
+    std::size_t real_count;
+};
+
+class relaxed_node_not_allowed_exception : public archive_exception
+{
+public:
+    relaxed_node_not_allowed_exception(node_id id_)
+        : archive_exception{fmt::format("Node ID {} can't be a relaxed node",
+                                        id_)}
+        , id{id_}
+    {
+    }
+
+    node_id id;
+};
+
+class same_depth_children_exception : public archive_exception
+{
+public:
+    same_depth_children_exception(node_id id,
+                                  std::size_t expected_depth,
+                                  node_id child_id,
+                                  std::size_t real_depth)
+        : archive_exception{
+              fmt::format("All children of node {} must have the same depth "
+                          "{}, but the child {} has depth {}",
+                          id,
+                          expected_depth,
+                          child_id,
+                          real_depth)}
+    {
+    }
+};
+
+template <class T,
+          typename MemoryPolicy,
+          immer::detail::rbts::bits_t B,
+          immer::detail::rbts::bits_t BL>
+class loader
+{
+public:
+    using rbtree      = immer::detail::rbts::rbtree<T, MemoryPolicy, B, BL>;
+    using rrbtree     = immer::detail::rbts::rrbtree<T, MemoryPolicy, B, BL>;
+    using node_t      = typename rbtree::node_t;
+    using node_ptr    = node_ptr<node_t>;
+    using nodes_set_t = immer::set<node_id>;
+
+    explicit loader(archive_load<T> ar)
+        : ar_{std::move(ar)}
+    {
+    }
+
+    immer::vector<T, MemoryPolicy, B, BL> load_vector(container_id id)
+    {
+        if (id.value >= ar_.vectors.size()) {
+            throw invalid_container_id{id};
+        }
+
+        const auto& info = ar_.vectors[id.value];
+
+        const auto relaxed_allowed = false;
+        auto root                  = load_inner(info.root, {}, relaxed_allowed);
+        auto tail                  = load_leaf(info.tail);
+
+        const auto tree_size =
+            get_node_size(info.root) + get_node_size(info.tail);
+        const auto depth = get_node_depth(info.root);
+        const auto shift = get_shift_for_depth(B, BL, depth);
+
+        auto impl = rbtree{tree_size,
+                           shift,
+                           std::move(root).release(),
+                           std::move(tail).release()};
+
+        verify_tree(impl);
+        return impl;
+    }
+
+    immer::flex_vector<T, MemoryPolicy, B, BL> load_flex_vector(container_id id)
+    {
+        if (id.value >= ar_.vectors.size()) {
+            throw invalid_container_id{id};
+        }
+
+        const auto& info = ar_.vectors[id.value];
+
+        const auto relaxed_allowed = true;
+        auto root                  = load_inner(info.root, {}, relaxed_allowed);
+        auto tail                  = load_leaf(info.tail);
+
+        const auto tree_size =
+            get_node_size(info.root) + get_node_size(info.tail);
+        const auto depth = get_node_depth(info.root);
+        const auto shift = get_shift_for_depth(B, BL, depth);
+
+        auto impl = rrbtree{tree_size,
+                            shift,
+                            std::move(root).release(),
+                            std::move(tail).release()};
+
+        verify_tree(impl);
+
+        return impl;
+    }
+
+private:
+    node_ptr load_leaf(node_id id)
+    {
+        if (auto* p = leaves_.find(id)) {
+            return *p;
+        }
+
+        auto* node_info = ar_.leaves.find(id);
+        if (!node_info) {
+            throw invalid_node_id{id};
+        }
+
+        const auto n         = node_info->data.size();
+        constexpr auto max_n = immer::detail::rbts::branches<BL>;
+        if (n > max_n) {
+            throw invalid_children_count{id};
+        }
+
+        auto leaf = node_ptr{node_t::make_leaf_n(n),
+                             [n](auto* ptr) { node_t::delete_leaf(ptr, n); }};
+        immer::detail::uninitialized_copy(
+            node_info->data.begin(), node_info->data.end(), leaf.get()->leaf());
+        leaves_        = std::move(leaves_).set(id, leaf);
+        loaded_leaves_ = std::move(loaded_leaves_).set(leaf.get(), id);
+        return leaf;
+    }
+
+    node_ptr
+    load_inner(node_id id, nodes_set_t loading_nodes, bool relaxed_allowed)
+    {
+        if (loading_nodes.count(id)) {
+            throw archive_has_cycles{id};
+        }
+
+        if (auto* p = inners_.find(id)) {
+            return *p;
+        }
+
+        auto* node_info = ar_.inners.find(id);
+        if (!node_info) {
+            throw invalid_node_id{id};
+        }
+
+        const auto children_ids = get_node_children(*node_info);
+
+        const auto n         = children_ids.size();
+        constexpr auto max_n = immer::detail::rbts::branches<B>;
+        if (n > max_n) {
+            throw invalid_children_count{id};
+        }
+
+        // The code doesn't handle very well a relaxed node with size zero.
+        // Pretend it's a strict node.
+        const bool is_relaxed = node_info->relaxed && n > 0;
+
+        if (!is_relaxed) {
+            // Children of a non-relaxed node are not allowed to be relaxed.
+            relaxed_allowed = false;
+        }
+
+        if (is_relaxed && !relaxed_allowed) {
+            throw relaxed_node_not_allowed_exception{id};
+        }
+
+        /**
+         * We have to have the same behavior of inner nodes deallocating
+         * children as vectors themselves, otherwise memory leaks appear.
+         *
+         * Specifically this: children's ref-counts must be decreased only when
+         * the inner node that references them is deleted.
+         */
+        const auto children = [&] {
+            /**
+             * NOTE: load_children may throw an exception if same-depth
+             * validation doesn't pass. Be careful with release_full, nodes will
+             * not be freed automatically.
+             */
+            auto children_ptrs =
+                load_children(id,
+                              children_ids,
+                              std::move(loading_nodes).insert(id),
+                              relaxed_allowed);
+            auto result = immer::vector<ptr_with_deleter<node_t>>{};
+            for (auto& item : children_ptrs) {
+                result =
+                    std::move(result).push_back(std::move(item).release_full());
+            }
+            return result;
+        }();
+        const auto delete_children = [children]() {
+            for (const auto& ptr : children) {
+                ptr.dec();
+            }
+        };
+
+        auto inner = is_relaxed ? node_ptr{node_t::make_inner_r_n(n),
+                                           [n, delete_children](auto* ptr) {
+                                               node_t::delete_inner_r(ptr, n);
+                                               delete_children();
+                                           }}
+                                : node_ptr{node_t::make_inner_n(n),
+                                           [n, delete_children](auto* ptr) {
+                                               node_t::delete_inner(ptr, n);
+                                               delete_children();
+                                           }};
+        if (is_relaxed) {
+            inner.get()->relaxed()->d.count = n;
+        }
+
+        {
+            auto running_size = std::size_t{};
+            for (const auto& [index, child_node_id] :
+                 boost::adaptors::index(children_ids)) {
+                inner.get()->inner()[index] = children[index].ptr;
+                if (is_relaxed) {
+                    running_size += get_node_size(child_node_id);
+                    inner.get()->relaxed()->d.sizes[index] = running_size;
+                }
+            }
+        }
+
+        inners_        = std::move(inners_).set(id, inner);
+        loaded_inners_ = std::move(loaded_inners_).set(inner.get(), id);
+        return inner;
+    }
+
+    node_ptr
+    load_some_node(node_id id, nodes_set_t loading_nodes, bool relaxed_allowed)
+    {
+        // Unknown type: leaf, inner or relaxed
+        if (ar_.leaves.count(id)) {
+            return load_leaf(id);
+        }
+        if (ar_.inners.count(id)) {
+            return load_inner(id, std::move(loading_nodes), relaxed_allowed);
+        }
+        throw invalid_node_id{id};
+    }
+
+    immer::vector<node_id> get_node_children(const inner_node& node_info)
+    {
+        // Ignore empty children
+        auto result = immer::vector<node_id>{};
+        for (const auto& child_node_id : node_info.children) {
+            const auto child_size = get_node_size(child_node_id);
+            if (child_size) {
+                result = std::move(result).push_back(child_node_id);
+            }
+        }
+        return result;
+    }
+
+    std::size_t get_node_size(node_id id, nodes_set_t loading_nodes = {})
+    {
+        if (auto* p = sizes_.find(id)) {
+            return *p;
+        }
+        auto size = [&] {
+            if (auto* p = ar_.leaves.find(id)) {
+                return p->data.size();
+            }
+            if (auto* p = ar_.inners.find(id)) {
+                auto result   = std::size_t{};
+                loading_nodes = std::move(loading_nodes).insert(id);
+                for (const auto& child_id : p->children) {
+                    if (loading_nodes.count(child_id)) {
+                        throw archive_has_cycles{child_id};
+                    }
+                    result += get_node_size(child_id, loading_nodes);
+                }
+                return result;
+            }
+            throw invalid_node_id{id};
+        }();
+        sizes_ = std::move(sizes_).set(id, size);
+        return size;
+    }
+
+    immer::detail::rbts::count_t get_node_depth(node_id id)
+    {
+        if (auto* p = depths_.find(id)) {
+            return *p;
+        }
+        auto depth = [&]() -> immer::detail::rbts::count_t {
+            if (auto* p = ar_.leaves.find(id)) {
+                return 0;
+            }
+            if (auto* p = ar_.inners.find(id)) {
+                if (p->children.empty()) {
+                    return 1;
+                } else {
+                    return 1 + get_node_depth(p->children.front());
+                }
+            }
+            throw invalid_node_id{id};
+        }();
+        depths_ = std::move(depths_).set(id, depth);
+        return depth;
+    }
+
+    std::vector<node_ptr>
+    load_children(node_id id,
+                  const immer::vector<node_id>& children_ids,
+                  const nodes_set_t& loading_nodes,
+                  bool relaxed_allowed)
+    {
+        auto children_depth = immer::detail::rbts::count_t{};
+        auto result         = std::vector<node_ptr>{};
+        for (const auto& child_node_id : children_ids) {
+            // Better to load the node first and then check the depth, because
+            // loading has extra protections against loops.
+            auto child =
+                load_some_node(child_node_id, loading_nodes, relaxed_allowed);
+
+            const auto depth = get_node_depth(child_node_id);
+            if (result.empty()) {
+                children_depth = depth;
+            } else if (depth != children_depth) {
+                throw same_depth_children_exception{
+                    id, children_depth, child_node_id, depth};
+            }
+
+            result.emplace_back(std::move(child));
+        }
+        return result;
+    }
+
+    template <class Tree>
+    void verify_tree(const Tree& impl)
+    {
+        const auto check_inner = [&](auto&& pos,
+                                     auto&& visit,
+                                     bool visiting_relaxed) {
+            const auto* id = loaded_inners_.find(pos.node());
+            if (!id) {
+                if (loaded_leaves_.find(pos.node())) {
+                    throw std::logic_error{"A node is expected to be an inner "
+                                           "node but it's actually a leaf"};
+                }
+
+                throw std::logic_error{"Inner node of a freshly loaded "
+                                       "vector is unknown"};
+            }
+            const auto* info = ar_.inners.find(*id);
+            assert(info);
+            if (!info) {
+                throw std::logic_error{
+                    "No info for the just loaded inner node"};
+            }
+
+            /**
+             * NOTE: Not sure how useful this check is.
+             */
+            // if (visiting_relaxed != info->relaxed) {
+            //     throw std::logic_error{fmt::format(
+            //         "Node {} is expected to be relaxed == {} but it is {}",
+            //         *id,
+            //         info->relaxed,
+            //         visiting_relaxed)};
+            // }
+
+            const auto expected_count = pos.count();
+            const auto real_count     = get_node_children(*info).size();
+            if (expected_count != real_count) {
+                throw vector_corrupted_exception{
+                    *id, expected_count, real_count};
+            }
+
+            pos.each(detail::visitor_helper{},
+                     [&visit](auto any_tag, auto& child_pos, auto&&) {
+                         visit(child_pos);
+                     });
+        };
+
+        impl.traverse(
+            detail::visitor_helper{},
+            boost::hana::overload(
+                [&](detail::regular_pos_tag, auto&& pos, auto&& visit) {
+                    // SPDLOG_INFO("regular_pos_tag");
+                    const bool visiting_relaxed = false;
+                    check_inner(pos, visit, visiting_relaxed);
+                },
+                [&](detail::relaxed_pos_tag, auto&& pos, auto&& visit) {
+                    // SPDLOG_INFO("relaxed_pos_tag");
+                    const bool visiting_relaxed = true;
+                    check_inner(pos, visit, visiting_relaxed);
+                },
+                [&](detail::leaf_pos_tag, auto&& pos, auto&& visit) {
+                    // SPDLOG_INFO("leaf_pos_tag");
+                    const auto* id = loaded_leaves_.find(pos.node());
+                    assert(id);
+                    if (!id) {
+                        throw std::logic_error{
+                            "Leaf of a freshly loaded vector is unknown"};
+                    }
+                    const auto* info = ar_.leaves.find(*id);
+                    assert(info);
+                    if (!info) {
+                        throw std::logic_error{
+                            "No info for the just loaded leaf"};
+                    }
+
+                    const auto expected_count = pos.count();
+                    const auto real_count     = info->data.size();
+                    if (expected_count != real_count) {
+                        throw vector_corrupted_exception{
+                            *id, expected_count, real_count};
+                    }
+                }));
+    }
+
+private:
+    const archive_load<T> ar_;
+    immer::map<node_id, node_ptr> leaves_;
+    immer::map<node_id, node_ptr> inners_;
+    immer::map<node_t*, node_id> loaded_leaves_;
+    immer::map<node_t*, node_id> loaded_inners_;
+    immer::map<node_id, std::size_t> sizes_;
+    immer::map<node_id, immer::detail::rbts::count_t> depths_;
+};
+
+template <typename T,
+          typename MemoryPolicy,
+          immer::detail::rbts::bits_t B,
+          immer::detail::rbts::bits_t BL>
+class vector_loader
+{
+public:
+    explicit vector_loader(archive_load<T> ar)
+        : loader{std::move(ar)}
+    {
+    }
+
+    auto load(container_id id) { return loader.load_vector(id); }
+
+private:
+    loader<T, MemoryPolicy, B, BL> loader;
+};
+
+template <typename T,
+          typename MemoryPolicy,
+          immer::detail::rbts::bits_t B,
+          immer::detail::rbts::bits_t BL>
+vector_loader<T, MemoryPolicy, B, BL>
+make_loader_for(const immer::vector<T, MemoryPolicy, B, BL>&,
+                archive_load<T> ar)
+{
+    return vector_loader<T, MemoryPolicy, B, BL>{std::move(ar)};
+}
+
+template <typename T,
+          typename MemoryPolicy,
+          immer::detail::rbts::bits_t B,
+          immer::detail::rbts::bits_t BL>
+class flex_vector_loader
+{
+public:
+    explicit flex_vector_loader(archive_load<T> ar)
+        : loader{std::move(ar)}
+    {
+    }
+
+    auto load(container_id id) { return loader.load_flex_vector(id); }
+
+private:
+    loader<T, MemoryPolicy, B, BL> loader;
+};
+
+template <typename T,
+          typename MemoryPolicy,
+          immer::detail::rbts::bits_t B,
+          immer::detail::rbts::bits_t BL>
+flex_vector_loader<T, MemoryPolicy, B, BL>
+make_loader_for(const immer::flex_vector<T, MemoryPolicy, B, BL>&,
+                archive_load<T> ar)
+{
+    return flex_vector_loader<T, MemoryPolicy, B, BL>{std::move(ar)};
+}
+
+} // namespace immer_archive::rbts
diff --git a/immer/experimental/immer-archive/rbts/save.hpp b/immer/experimental/immer-archive/rbts/save.hpp
new file mode 100644
index 00000000..f79acecd
--- /dev/null
+++ b/immer/experimental/immer-archive/rbts/save.hpp
@@ -0,0 +1,221 @@
+#pragma once
+
+#include <immer/experimental/immer-archive/rbts/traverse.hpp>
+
+namespace immer_archive::rbts {
+
+namespace detail {
+
+template <typename T,
+          typename MemoryPolicy,
+          immer::detail::rbts::bits_t B,
+          immer::detail::rbts::bits_t BL>
+std::pair<archive_save<T, MemoryPolicy, B, BL>, node_id>
+get_node_id(archive_save<T, MemoryPolicy, B, BL> ar,
+            const immer::detail::rbts::node<T, MemoryPolicy, B, BL>* ptr)
+{
+    auto* ptr_void = static_cast<const void*>(ptr);
+    if (auto* maybe_id = ar.node_ptr_to_id.find(ptr_void)) {
+        auto id = *maybe_id;
+        return {std::move(ar), id};
+    }
+
+    const auto id     = node_id{ar.node_ptr_to_id.size()};
+    ar.node_ptr_to_id = std::move(ar.node_ptr_to_id).set(ptr_void, id);
+    return {std::move(ar), id};
+}
+
+template <typename T,
+          typename MemoryPolicy,
+          immer::detail::rbts::bits_t B,
+          immer::detail::rbts::bits_t BL>
+struct archive_builder
+{
+    archive_save<T, MemoryPolicy, B, BL> ar;
+
+    template <class Pos>
+    void operator()(regular_pos_tag, Pos& pos, auto&& visit)
+    {
+        auto id = get_node_id(pos.node());
+        if (ar.inners.count(id)) {
+            return;
+        }
+
+        auto node_info = inner_node{};
+        // Explicit this-> call to workaround an "unused this" warning.
+        pos.each(visitor_helper{},
+                 [&node_info, &visit, this](
+                     auto any_tag, auto& child_pos, auto&&) mutable {
+                     node_info.children =
+                         std::move(node_info.children)
+                             .push_back(this->get_node_id(child_pos.node()));
+                     visit(child_pos);
+                 });
+        ar.inners = std::move(ar.inners).set(id, node_info);
+    }
+
+    template <class Pos>
+    void operator()(relaxed_pos_tag, Pos& pos, auto&& visit)
+    {
+        auto id = get_node_id(pos.node());
+        if (ar.inners.count(id)) {
+            return;
+        }
+
+        auto node_info = inner_node{
+            .relaxed = true,
+        };
+
+        pos.each(visitor_helper{}, [&](auto any_tag, auto& child_pos, auto&&) {
+            node_info.children = std::move(node_info.children)
+                                     .push_back(get_node_id(child_pos.node()));
+
+            visit(child_pos);
+        });
+
+        assert(node_info.children.size() == pos.node()->relaxed()->d.count);
+
+        ar.inners = std::move(ar.inners).set(id, node_info);
+    }
+
+    template <class Pos>
+    void operator()(leaf_pos_tag, Pos& pos, auto&& visit)
+    {
+        T* first = pos.node()->leaf();
+        auto id  = get_node_id(pos.node());
+        if (ar.leaves.count(id)) {
+            return;
+        }
+
+        auto info = values_save<T>{
+            .begin = first,
+            .end   = first + pos.count(),
+        };
+        ar.leaves = std::move(ar.leaves).set(id, std::move(info));
+    }
+
+    node_id get_node_id(immer::detail::rbts::node<T, MemoryPolicy, B, BL>* ptr)
+    {
+        auto [ar2, id] =
+            immer_archive::rbts::detail::get_node_id(std::move(ar), ptr);
+        ar = std::move(ar2);
+        return id;
+    }
+};
+
+template <typename T,
+          typename MemoryPolicy,
+          immer::detail::rbts::bits_t B,
+          immer::detail::rbts::bits_t BL,
+          class Archive>
+auto save_nodes(const immer::detail::rbts::rbtree<T, MemoryPolicy, B, BL>& tree,
+                Archive ar)
+{
+    auto save = archive_builder<T, MemoryPolicy, B, BL>{
+        .ar = std::move(ar),
+    };
+    tree.traverse(visitor_helper{}, save);
+    return std::move(save.ar);
+}
+
+template <typename T,
+          typename MemoryPolicy,
+          immer::detail::rbts::bits_t B,
+          immer::detail::rbts::bits_t BL,
+          class Archive>
+auto save_nodes(
+    const immer::detail::rbts::rrbtree<T, MemoryPolicy, B, BL>& tree,
+    Archive ar)
+{
+    auto save = archive_builder<T, MemoryPolicy, B, BL>{
+        .ar = std::move(ar),
+    };
+    tree.traverse(visitor_helper{}, save);
+    return std::move(save.ar);
+}
+
+} // namespace detail
+
+template <typename T,
+          typename MemoryPolicy,
+          immer::detail::rbts::bits_t B,
+          immer::detail::rbts::bits_t BL>
+std::pair<archive_save<T, MemoryPolicy, B, BL>, container_id>
+save_to_archive(immer::vector<T, MemoryPolicy, B, BL> vec,
+                archive_save<T, MemoryPolicy, B, BL> archive)
+{
+    const auto& impl = vec.impl();
+    auto root_id     = node_id{};
+    auto tail_id     = node_id{};
+    std::tie(archive, root_id) =
+        detail::get_node_id(std::move(archive), impl.root);
+    std::tie(archive, tail_id) =
+        detail::get_node_id(std::move(archive), impl.tail);
+    const auto tree_id = rbts_info{
+        .root = root_id,
+        .tail = tail_id,
+    };
+
+    if (auto* p = archive.rbts_to_id.find(tree_id)) {
+        // Already been saved
+        auto vector_id = *p;
+        return {std::move(archive), vector_id};
+    }
+
+    archive = detail::save_nodes(impl, std::move(archive));
+
+    assert(archive.inners.count(root_id));
+    assert(archive.leaves.count(tail_id));
+
+    const auto vector_id = container_id{archive.vectors.size()};
+
+    archive.rbts_to_id = std::move(archive.rbts_to_id).set(tree_id, vector_id);
+    archive.vectors    = std::move(archive.vectors).push_back(tree_id);
+    archive.saved_vectors =
+        std::move(archive.saved_vectors).push_back(std::move(vec));
+
+    return {std::move(archive), vector_id};
+}
+
+template <typename T,
+          typename MemoryPolicy,
+          immer::detail::rbts::bits_t B,
+          immer::detail::rbts::bits_t BL>
+std::pair<archive_save<T, MemoryPolicy, B, BL>, container_id>
+save_to_archive(immer::flex_vector<T, MemoryPolicy, B, BL> vec,
+                archive_save<T, MemoryPolicy, B, BL> archive)
+{
+    const auto& impl = vec.impl();
+    auto root_id     = node_id{};
+    auto tail_id     = node_id{};
+    std::tie(archive, root_id) =
+        detail::get_node_id(std::move(archive), impl.root);
+    std::tie(archive, tail_id) =
+        detail::get_node_id(std::move(archive), impl.tail);
+    const auto tree_id = rbts_info{
+        .root = root_id,
+        .tail = tail_id,
+    };
+
+    if (auto* p = archive.rbts_to_id.find(tree_id)) {
+        // Already been saved
+        auto vector_id = *p;
+        return {std::move(archive), vector_id};
+    }
+
+    archive = detail::save_nodes(impl, std::move(archive));
+
+    assert(archive.inners.count(root_id));
+    assert(archive.leaves.count(tail_id));
+
+    const auto vector_id = container_id{archive.vectors.size()};
+
+    archive.rbts_to_id = std::move(archive.rbts_to_id).set(tree_id, vector_id);
+    archive.vectors    = std::move(archive.vectors).push_back(tree_id);
+    archive.saved_flex_vectors =
+        std::move(archive.saved_flex_vectors).push_back(std::move(vec));
+
+    return {std::move(archive), vector_id};
+}
+
+} // namespace immer_archive::rbts
diff --git a/immer/experimental/immer-archive/rbts/traits.hpp b/immer/experimental/immer-archive/rbts/traits.hpp
new file mode 100644
index 00000000..f4d10cb6
--- /dev/null
+++ b/immer/experimental/immer-archive/rbts/traits.hpp
@@ -0,0 +1,33 @@
+#pragma once
+
+#include <immer/experimental/immer-archive/rbts/load.hpp>
+#include <immer/experimental/immer-archive/rbts/save.hpp>
+#include <immer/experimental/immer-archive/traits.hpp>
+
+namespace immer_archive {
+
+template <typename T,
+          typename MemoryPolicy,
+          immer::detail::rbts::bits_t B,
+          immer::detail::rbts::bits_t BL>
+struct container_traits<immer::vector<T, MemoryPolicy, B, BL>>
+{
+    using save_archive_t = rbts::archive_save<T, MemoryPolicy, B, BL>;
+    using load_archive_t = rbts::archive_load<T>;
+    using loader_t       = rbts::vector_loader<T, MemoryPolicy, B, BL>;
+    using container_id   = immer_archive::container_id;
+};
+
+template <typename T,
+          typename MemoryPolicy,
+          immer::detail::rbts::bits_t B,
+          immer::detail::rbts::bits_t BL>
+struct container_traits<immer::flex_vector<T, MemoryPolicy, B, BL>>
+{
+    using save_archive_t = rbts::archive_save<T, MemoryPolicy, B, BL>;
+    using load_archive_t = rbts::archive_load<T>;
+    using loader_t       = rbts::flex_vector_loader<T, MemoryPolicy, B, BL>;
+    using container_id   = immer_archive::container_id;
+};
+
+} // namespace immer_archive
diff --git a/immer/experimental/immer-archive/rbts/traverse.hpp b/immer/experimental/immer-archive/rbts/traverse.hpp
new file mode 100644
index 00000000..771a35d5
--- /dev/null
+++ b/immer/experimental/immer-archive/rbts/traverse.hpp
@@ -0,0 +1,99 @@
+#pragma once
+
+#include <immer/experimental/immer-archive/rbts/archive.hpp>
+
+#include <immer/detail/rbts/rrbtree.hpp>
+
+namespace immer_archive::rbts::detail {
+
+struct regular_pos_tag
+{};
+struct leaf_pos_tag
+{};
+struct relaxed_pos_tag
+{};
+
+template <class T>
+struct position_tag : std::false_type
+{};
+
+template <class... Rest>
+struct position_tag<immer::detail::rbts::regular_sub_pos<Rest...>>
+{
+    using type = regular_pos_tag;
+};
+
+template <class... Rest>
+struct position_tag<immer::detail::rbts::full_pos<Rest...>>
+{
+    using type = regular_pos_tag;
+};
+template <class... Rest>
+struct position_tag<immer::detail::rbts::regular_pos<Rest...>>
+{
+    using type = regular_pos_tag;
+};
+template <class... Rest>
+struct position_tag<immer::detail::rbts::empty_regular_pos<Rest...>>
+{
+    using type = regular_pos_tag;
+};
+
+template <class... Rest>
+struct position_tag<immer::detail::rbts::leaf_sub_pos<Rest...>>
+{
+    using type = leaf_pos_tag;
+};
+template <class... Rest>
+struct position_tag<immer::detail::rbts::full_leaf_pos<Rest...>>
+{
+    using type = leaf_pos_tag;
+};
+template <class... Rest>
+struct position_tag<immer::detail::rbts::leaf_pos<Rest...>>
+{
+    using type = leaf_pos_tag;
+};
+template <class... Rest>
+struct position_tag<immer::detail::rbts::empty_leaf_pos<Rest...>>
+{
+    using type = leaf_pos_tag;
+};
+
+template <class... Rest>
+struct position_tag<immer::detail::rbts::relaxed_pos<Rest...>>
+{
+    using type = relaxed_pos_tag;
+};
+
+struct visitor_helper
+{
+    template <class T, class F>
+    static void visit_regular(T&& pos, F&& fn)
+    {
+        visit_by_tag(std::forward<T>(pos), std::forward<F>(fn));
+    }
+
+    template <class T, class F>
+    static void visit_relaxed(T&& pos, F&& fn)
+    {
+        visit_by_tag(std::forward<T>(pos), std::forward<F>(fn));
+    }
+
+    template <class T, class F>
+    static void visit_leaf(T&& pos, F&& fn)
+    {
+        visit_by_tag(std::forward<T>(pos), std::forward<F>(fn));
+    }
+
+    template <class T, class F>
+    static void visit_by_tag(T&& pos, F&& fn)
+    {
+        using Tag = typename position_tag<std::decay_t<T>>::type;
+        fn(Tag{}, std::forward<T>(pos), [&fn](auto&& other_pos) {
+            visit_by_tag(other_pos, fn);
+        });
+    }
+};
+
+} // namespace immer_archive::rbts::detail
diff --git a/immer/experimental/immer-archive/traits.hpp b/immer/experimental/immer-archive/traits.hpp
new file mode 100644
index 00000000..3d001fee
--- /dev/null
+++ b/immer/experimental/immer-archive/traits.hpp
@@ -0,0 +1,13 @@
+#pragma once
+
+namespace immer_archive {
+
+/**
+ * Define these traits to connect a type (vector_one<T>) to its archive
+ * (archive_save<T>).
+ */
+template <class T>
+struct container_traits
+{};
+
+} // namespace immer_archive
diff --git a/immer/experimental/immer-archive/xxhash/xxhash.hpp b/immer/experimental/immer-archive/xxhash/xxhash.hpp
new file mode 100644
index 00000000..d87bb4c6
--- /dev/null
+++ b/immer/experimental/immer-archive/xxhash/xxhash.hpp
@@ -0,0 +1,27 @@
+#pragma once
+
+#include <string>
+
+namespace immer_archive {
+
+template <typename T>
+struct xx_hash;
+
+std::size_t xx_hash_value_string(const std::string& str);
+
+template <class T, class U>
+using enable_for = std::enable_if_t<std::is_same_v<T, U>, std::size_t>;
+
+template <class T>
+enable_for<T, std::string> xx_hash_value(const T& str)
+{
+    return xx_hash_value_string(str);
+}
+
+template <class T>
+struct xx_hash
+{
+    std::size_t operator()(const T& val) const { return xx_hash_value(val); }
+};
+
+} // namespace immer_archive
diff --git a/immer/experimental/immer-archive/xxhash/xxhash_64.cpp b/immer/experimental/immer-archive/xxhash/xxhash_64.cpp
new file mode 100644
index 00000000..9f395481
--- /dev/null
+++ b/immer/experimental/immer-archive/xxhash/xxhash_64.cpp
@@ -0,0 +1,15 @@
+#include "xxhash.hpp"
+
+#include <xxhash.h>
+
+namespace immer_archive {
+
+static_assert(sizeof(std::size_t) == 8); // 64 bits
+static_assert(sizeof(XXH64_hash_t) == sizeof(std::size_t));
+
+std::size_t xx_hash_value_string(const std::string& str)
+{
+    return XXH3_64bits(str.c_str(), str.size());
+}
+
+} // namespace immer_archive
diff --git a/immer/flex_vector.hpp b/immer/flex_vector.hpp
index f970db91..cf00f569 100644
--- a/immer/flex_vector.hpp
+++ b/immer/flex_vector.hpp
@@ -527,6 +527,7 @@ class flex_vector
 private:
     friend transient_type;
 
+public:
     flex_vector(impl_t impl)
         : impl_(std::move(impl))
     {
@@ -537,6 +538,7 @@ class flex_vector
 #endif
     }
 
+private:
     flex_vector&& push_back_move(std::true_type, value_type value)
     {
         impl_.push_back_mut({}, std::move(value));
diff --git a/immer/map.hpp b/immer/map.hpp
index cab8e5d5..5e8ca440 100644
--- a/immer/map.hpp
+++ b/immer/map.hpp
@@ -540,10 +540,13 @@ class map
         return impl_.sub(value);
     }
 
+// for immer-archive
+public:
     map(impl_t impl)
         : impl_(std::move(impl))
     {}
 
+private:
     impl_t impl_ = impl_t::empty();
 };
 
diff --git a/immer/set.hpp b/immer/set.hpp
index df4192f5..d81146a8 100644
--- a/immer/set.hpp
+++ b/immer/set.hpp
@@ -285,10 +285,13 @@ class set
         return impl_.sub(value);
     }
 
+// for immer-archive
+public:
     set(impl_t impl)
         : impl_(std::move(impl))
     {}
 
+private:
     impl_t impl_ = impl_t::empty();
 };
 
diff --git a/immer/table.hpp b/immer/table.hpp
index 0e977c6a..4c4daf3c 100644
--- a/immer/table.hpp
+++ b/immer/table.hpp
@@ -537,10 +537,13 @@ class table
         return impl_.sub(value);
     }
 
+// for immer-archive
+public:
     table(impl_t impl)
         : impl_(std::move(impl))
     {}
 
+private:
     impl_t impl_ = impl_t::empty();
 };
 
diff --git a/immer/vector.hpp b/immer/vector.hpp
index 8c8ab05d..0a8ad09e 100644
--- a/immer/vector.hpp
+++ b/immer/vector.hpp
@@ -365,6 +365,8 @@ class vector
     friend flex_t;
     friend transient_type;
 
+// for immer-archive
+public:
     vector(impl_t impl)
         : impl_(std::move(impl))
     {
@@ -375,6 +377,7 @@ class vector
 #endif
     }
 
+private:
     vector&& push_back_move(std::true_type, value_type value)
     {
         impl_.push_back_mut({}, std::move(value));
diff --git a/nix/cereal.nix b/nix/cereal.nix
new file mode 100644
index 00000000..3889433f
--- /dev/null
+++ b/nix/cereal.nix
@@ -0,0 +1,19 @@
+{
+  arximboldi-cereal-src,
+  stdenv,
+  cmake,
+  lib,
+}:
+stdenv.mkDerivation rec {
+  name = "cereal-${version}";
+  version = "git-${commit}";
+  commit = arximboldi-cereal-src.rev;
+  src = arximboldi-cereal-src;
+  nativeBuildInputs = [cmake];
+  cmakeFlags = ["-DJUST_INSTALL_CEREAL=true"];
+  meta = {
+    homepage = "http://uscilab.github.io/cereal";
+    description = "A C++11 library for serialization";
+    license = lib.licenses.bsd3;
+  };
+}
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 1812e9ed..0e0a3e35 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -1,23 +1,40 @@
+# Targets
+# =======
 
-#  Targets
-#  =======
-
-add_custom_target(tests
-  COMMENT "Build all the unit tests.")
+add_custom_target(tests COMMENT "Build all the unit tests.")
 add_dependencies(check tests)
 
+# The variable MEMORYCHECK_SUPPRESSIONS_FILE must be set before including CTest,
+# because including it triggers the generation of the config
+# DartConfiguration.tcl.
+set(MEMORYCHECK_SUPPRESSIONS_FILE
+    "${PROJECT_SOURCE_DIR}/test/valgrind_suppress.txt"
+    CACHE FILEPATH "")
 find_package(Catch2 REQUIRED)
 include(CTest)
 
 file(GLOB_RECURSE immer_unit_tests "*.cpp")
+foreach(TMP_PATH ${immer_unit_tests})
+  string(FIND ${TMP_PATH} immer-archive EXCLUDE_DIR_FOUND)
+  if(NOT ${EXCLUDE_DIR_FOUND} EQUAL -1)
+    list(REMOVE_ITEM immer_unit_tests ${TMP_PATH})
+  endif()
+endforeach(TMP_PATH)
+
 foreach(_file IN LISTS immer_unit_tests)
   immer_target_name_for(_target _output "${_file}")
   add_executable(${_target} EXCLUDE_FROM_ALL "${_file}")
   set_target_properties(${_target} PROPERTIES OUTPUT_NAME ${_output})
   add_dependencies(tests ${_target})
-  target_compile_definitions(${_target} PUBLIC
-    -DIMMER_OSS_FUZZ_DATA_PATH="${CMAKE_CURRENT_SOURCE_DIR}/oss-fuzz/data")
+  target_compile_definitions(
+    ${_target}
+    PUBLIC IMMER_OSS_FUZZ_DATA_PATH="${CMAKE_CURRENT_SOURCE_DIR}/oss-fuzz/data"
+           IMMER_THROW_ON_INVALID_STATE=1)
   target_link_libraries(${_target} PUBLIC immer-dev Catch2::Catch2WithMain)
   set_target_properties(${_target} PROPERTIES CXX_VISIBILITY_PRESET hidden)
   add_test("test/${_output}" ${_output})
 endforeach()
+
+if(immer_BUILD_ARCHIVE_TESTS)
+  add_subdirectory(experimental/immer-archive)
+endif()
diff --git a/test/experimental/immer-archive/CMakeLists.txt b/test/experimental/immer-archive/CMakeLists.txt
new file mode 100644
index 00000000..0c63f5e6
--- /dev/null
+++ b/test/experimental/immer-archive/CMakeLists.txt
@@ -0,0 +1,40 @@
+find_package(spdlog REQUIRED)
+find_package(cereal REQUIRED)
+find_package(xxHash 0.8 CONFIG REQUIRED)
+
+if(${CXX_STANDARD} LESS 20)
+  # Maybe no particular reason, but we're not targeting older compilers anyway.
+  message(FATAL_ERROR "immer-archive requires C++20")
+endif()
+
+include(CTest)
+
+add_executable(
+  immer-archive-tests EXCLUDE_FROM_ALL
+  test_vectors.cpp test_special_archive.cpp test_champ.cpp test_xxhash.cpp
+  ${PROJECT_SOURCE_DIR}/immer/experimental/immer-archive/xxhash/xxhash_64.cpp)
+add_dependencies(tests immer-archive-tests)
+add_test("test/immer-archive-tests" immer-archive-tests)
+target_include_directories(immer-archive-tests PRIVATE ${CMAKE_SOURCE_DIR})
+target_link_libraries(
+  immer-archive-tests PRIVATE spdlog::spdlog Catch2::Catch2WithMain
+                              xxHash::xxhash)
+
+target_compile_options(
+  immer-archive-tests PRIVATE -O1 -fno-optimize-sibling-calls -g
+                              -fno-omit-frame-pointer)
+target_compile_options(immer-archive-tests PRIVATE -Wno-unused-function)
+
+if(ENABLE_ASAN)
+  target_compile_options(
+    immer-archive-tests PRIVATE -fsanitize-coverage=trace-pc-guard
+                                -fsanitize=address)
+  target_link_options(immer-archive-tests PRIVATE -fsanitize=address)
+endif()
+target_compile_definitions(immer-archive-tests PRIVATE BOOST_USE_ASAN=1)
+target_compile_definitions(
+  immer-archive-tests PRIVATE SPDLOG_ACTIVE_LEVEL=SPDLOG_LEVEL_TRACE
+                              IMMER_NO_FREE_LIST=1)
+
+install(TARGETS immer-archive-tests DESTINATION bin)
+install(FILES valgrind.supp DESTINATION bin)
diff --git a/test/experimental/immer-archive/suppr.txt b/test/experimental/immer-archive/suppr.txt
new file mode 100644
index 00000000..51e88f97
--- /dev/null
+++ b/test/experimental/immer-archive/suppr.txt
@@ -0,0 +1,9 @@
+leak:fetchInitializingClassList
+leak:class_rw_t::extAlloc
+leak:logger.h
+leak:cache_t::insert
+leak:realizeClassWithoutSwift
+leak:cereal::JSONInputArchive::Iterator::search
+leak:cereal::Exception::~Exception()
+leak:__lsan::CheckForLeaks
+leak:__sanitizer::Symbolizer::SymbolizePC
diff --git a/test/experimental/immer-archive/test_champ.cpp b/test/experimental/immer-archive/test_champ.cpp
new file mode 100644
index 00000000..e34070a9
--- /dev/null
+++ b/test/experimental/immer-archive/test_champ.cpp
@@ -0,0 +1,772 @@
+#include <catch2/catch_test_macros.hpp>
+
+#include <immer/experimental/immer-archive/champ/champ.hpp>
+#include <immer/experimental/immer-archive/xxhash/xxhash.hpp>
+
+#include "utils.hpp"
+
+#include <nlohmann/json.hpp>
+
+using namespace test;
+using json_t = nlohmann::json;
+using immer_archive::node_id;
+
+namespace {
+
+const auto gen_set = [](auto set, int count) {
+    for (int i = 0; i < count; ++i) {
+        set = std::move(set).insert(fmt::format("{}", i));
+    }
+    return set;
+};
+
+const auto gen_map = [](auto map, int count) {
+    for (int i = 0; i < count; ++i) {
+        map = std::move(map).set(i, fmt::format("_{}_", i));
+    }
+    return map;
+};
+
+auto gen_table(auto table, std::size_t from, std::size_t to)
+{
+    for (auto i = std::min(from, to); i < std::max(from, to); ++i) {
+        table = std::move(table).insert(test_value{i, fmt::format("_{}_", i)});
+    }
+    return table;
+}
+
+const auto into_set = [](const auto& set) {
+    using T     = typename std::decay_t<decltype(set)>::value_type;
+    auto result = immer::set<T>{};
+    for (const auto& item : set) {
+        result = std::move(result).insert(item);
+    }
+    return result;
+};
+
+const auto into_map = [](const auto& map) {
+    using K     = typename std::decay_t<decltype(map)>::key_type;
+    using V     = typename std::decay_t<decltype(map)>::mapped_type;
+    auto result = immer::map<K, V>{};
+    for (const auto& item : map) {
+        result = std::move(result).insert(item);
+    }
+    return result;
+};
+
+struct broken_hash
+{
+    std::size_t operator()(const std::string& str) const
+    {
+        if ("10" < str && str < "19") {
+            return 123;
+        }
+        return immer_archive::xx_hash<std::string>{}(str);
+    }
+
+    std::size_t operator()(int map_key) const
+    {
+        if (10 < map_key && map_key < 19) {
+            return 123;
+        }
+        return std::hash<int>{}(map_key);
+    }
+};
+
+} // namespace
+
+TEST_CASE("Test saving a set")
+{
+    using Container = immer::set<std::string, broken_hash>;
+
+    const auto set          = gen_set(Container{}, 200);
+    const auto [ar, set_id] = immer_archive::champ::save_to_archive(set, {});
+    const auto ar_str       = to_json(ar);
+    // REQUIRE(ar_str == "");
+
+    SECTION("Load with the correct hash")
+    {
+        const auto loaded_archive =
+            from_json<immer_archive::champ::container_archive_load<Container>>(
+                ar_str);
+
+        auto loader = immer_archive::champ::container_loader{loaded_archive};
+        const auto loaded = loader.load(set_id);
+        REQUIRE(into_set(set).size() == set.size());
+        for (const auto& item : set) {
+            // This is the only thing that actually breaks if the hash of the
+            // loaded set is not the same as the hash function of the serialized
+            // set.
+            REQUIRE(loaded.count(item));
+        }
+    }
+
+    SECTION("Load with a different hash")
+    {
+        using WrongContainer      = immer::set<std::string>;
+        const auto loaded_archive = from_json<
+            immer_archive::champ::container_archive_load<WrongContainer>>(
+            ar_str);
+
+        auto loader = immer_archive::champ::container_loader{loaded_archive};
+        REQUIRE_THROWS_AS(
+            loader.load(set_id),
+            immer_archive::champ::hash_validation_failed_exception);
+    }
+}
+
+TEST_CASE("Test set with xxHash")
+{
+    using Container =
+        immer::set<std::string, immer_archive::xx_hash<std::string>>;
+
+    const auto set          = gen_set(Container{}, 200);
+    const auto [ar, set_id] = immer_archive::champ::save_to_archive(set, {});
+    const auto ar_str       = to_json(ar);
+    // REQUIRE(ar_str == "");
+
+    SECTION("Load with the correct hash")
+    {
+        const auto loaded_archive =
+            from_json<immer_archive::champ::container_archive_load<Container>>(
+                ar_str);
+
+        auto loader = immer_archive::champ::container_loader{loaded_archive};
+        const auto loaded = loader.load(set_id);
+        REQUIRE(into_set(set).size() == set.size());
+        for (const auto& item : set) {
+            // This is the only thing that actually breaks if the hash of the
+            // loaded set is not the same as the hash function of the serialized
+            // set.
+            REQUIRE(loaded.count(item));
+        }
+    }
+}
+
+TEST_CASE("Test archive conversion, no json")
+{
+    using Container = immer::set<std::string, broken_hash>;
+
+    const auto set        = gen_set(Container{}, 200);
+    const auto set2       = gen_set(set, 300);
+    auto [ar, set_id]     = immer_archive::champ::save_to_archive(set, {});
+    auto set2_id          = immer_archive::node_id{};
+    std::tie(ar, set2_id) = immer_archive::champ::save_to_archive(set2, ar);
+
+    auto loader = immer_archive::champ::container_loader{to_load_archive(ar)};
+
+    const auto check_set = [&loader](auto id, const auto& expected) {
+        const auto loaded = loader.load(id);
+        REQUIRE(into_set(loaded) == into_set(expected));
+        REQUIRE(into_set(expected).size() == expected.size());
+        for (const auto& item : expected) {
+            // This is the only thing that actually breaks if the hash of the
+            // loaded set is not the same as the hash function of the serialized
+            // set.
+            REQUIRE(loaded.count(item));
+        }
+        for (const auto& item : loaded) {
+            REQUIRE(expected.count(item));
+        }
+    };
+
+    check_set(set_id, set);
+    check_set(set2_id, set2);
+}
+
+TEST_CASE("Test save mutated set")
+{
+    using Container = immer::set<std::string, broken_hash>;
+
+    auto set          = gen_set(Container{}, 200);
+    auto [ar, set_id] = immer_archive::champ::save_to_archive(set, {});
+
+    set                   = std::move(set).insert("435");
+    auto set_id2          = immer_archive::node_id{};
+    std::tie(ar, set_id2) = immer_archive::champ::save_to_archive(set, ar);
+
+    REQUIRE(set_id != set_id2);
+}
+
+TEST_CASE("Test saving a map")
+{
+    using Container = immer::map<int, std::string, broken_hash>;
+
+    const auto map          = gen_map(Container{}, 200);
+    const auto [ar, map_id] = immer_archive::champ::save_to_archive(map, {});
+    const auto ar_str       = to_json(ar);
+    // REQUIRE(ar_str == "");
+
+    SECTION("Load with the correct hash")
+    {
+        const auto loaded_archive =
+            from_json<immer_archive::champ::container_archive_load<Container>>(
+                ar_str);
+
+        auto loader = immer_archive::champ::container_loader{loaded_archive};
+        const auto loaded = loader.load(map_id);
+        REQUIRE(into_map(map).size() == map.size());
+        for (const auto& [key, value] : map) {
+            // This is the only thing that actually breaks if the hash of the
+            // loaded map is not the same as the hash function of the serialized
+            // map.
+            REQUIRE(loaded.count(key));
+            REQUIRE(loaded[key] == value);
+        }
+    }
+
+    SECTION("Load with a different hash")
+    {
+        using WrongContainer      = immer::map<int, std::string>;
+        const auto loaded_archive = from_json<
+            immer_archive::champ::container_archive_load<WrongContainer>>(
+            ar_str);
+
+        auto loader = immer_archive::champ::container_loader{loaded_archive};
+        REQUIRE_THROWS_AS(
+            loader.load(map_id),
+            immer_archive::champ::hash_validation_failed_exception);
+    }
+}
+
+TEST_CASE("Test map archive conversion, no json")
+{
+    using Container = immer::map<int, std::string, broken_hash>;
+
+    const auto map        = gen_map(Container{}, 200);
+    const auto map2       = gen_map(map, 300);
+    auto [ar, map_id]     = immer_archive::champ::save_to_archive(map, {});
+    auto map2_id          = immer_archive::node_id{};
+    std::tie(ar, map2_id) = immer_archive::champ::save_to_archive(map2, ar);
+
+    auto loader = immer_archive::champ::container_loader{to_load_archive(ar)};
+
+    const auto check_map = [&loader](auto id, const auto& expected) {
+        const auto loaded = loader.load(id);
+        REQUIRE(into_map(loaded) == into_map(expected));
+        REQUIRE(into_map(expected).size() == expected.size());
+        for (const auto& [key, value] : expected) {
+            // This is the only thing that actually breaks if the hash of the
+            // loaded map is not the same as the hash function of the serialized
+            // map.
+            REQUIRE(loaded.count(key));
+            REQUIRE(loaded[key] == value);
+        }
+        for (const auto& [key, value] : loaded) {
+            REQUIRE(expected.count(key));
+            REQUIRE(expected[key] == value);
+        }
+    };
+
+    check_map(map_id, map);
+    check_map(map2_id, map2);
+}
+
+TEST_CASE("Test save mutated map")
+{
+    auto map = gen_map(immer::map<int, std::string, broken_hash>{}, 200);
+    auto [ar, map_id] = immer_archive::champ::save_to_archive(map, {});
+
+    map                   = std::move(map).set(999, "435");
+    auto map_id2          = immer_archive::node_id{};
+    std::tie(ar, map_id2) = immer_archive::champ::save_to_archive(map, ar);
+
+    REQUIRE(map_id != map_id2);
+}
+
+namespace {
+template <class T1, class T2, class Verify>
+void test_table_types(Verify&& verify)
+{
+    const auto t1 = gen_table(T1{}, 0, 100);
+    const auto t2 = gen_table(t1, 200, 210);
+
+    auto [ar, t1_id] = immer_archive::champ::save_to_archive(t1, {});
+
+    auto t2_id          = immer_archive::node_id{};
+    std::tie(ar, t2_id) = immer_archive::champ::save_to_archive(t2, ar);
+
+    const auto ar_str = to_json(ar);
+    // REQUIRE(ar_str == "");
+
+    const auto loaded_archive =
+        from_json<immer_archive::champ::container_archive_load<T2>>(ar_str);
+
+    auto loader = immer_archive::champ::container_loader{loaded_archive};
+
+    const auto check = [&loader, &verify](auto id, const auto& expected) {
+        const auto loaded = loader.load(id);
+        verify(loaded, expected);
+    };
+
+    check(t1_id, t1);
+    check(t2_id, t2);
+}
+} // namespace
+
+TEST_CASE("Test saving a table")
+{
+    using different_table_t =
+        immer::table<test_value, immer::table_key_fn, broken_hash>;
+    using table_t = immer::table<test_value>;
+
+    const auto verify_is_equal = [](const auto& loaded, const auto& expected) {
+        for (const auto& item : expected) {
+            INFO(item);
+            REQUIRE(loaded.count(item.id));
+            REQUIRE(loaded[item.id] == item);
+        }
+        for (const auto& item : loaded) {
+            REQUIRE(expected[item.id] == item);
+        }
+    };
+
+    // Verify that saving and loading with customized hash works.
+    test_table_types<table_t, table_t>(verify_is_equal);
+    test_table_types<different_table_t, different_table_t>(verify_is_equal);
+
+    const auto test1 = [&] {
+        test_table_types<different_table_t, table_t>(verify_is_equal);
+    };
+    const auto test2 = [&] {
+        test_table_types<table_t, different_table_t>(verify_is_equal);
+    };
+
+    REQUIRE_THROWS_AS(test1(),
+                      immer_archive::champ::hash_validation_failed_exception);
+    REQUIRE_THROWS_AS(test2(),
+                      immer_archive::champ::hash_validation_failed_exception);
+}
+
+TEST_CASE("Test saving a table, no json")
+{
+    using table_t = immer::table<test_value>;
+    const auto t1 = gen_table(table_t{}, 0, 100);
+    const auto t2 = gen_table(t1, 200, 210);
+
+    auto [ar, t1_id] = immer_archive::champ::save_to_archive(t1, {});
+
+    auto t2_id          = immer_archive::node_id{};
+    std::tie(ar, t2_id) = immer_archive::champ::save_to_archive(t2, ar);
+
+    const auto ar_str = to_json(ar);
+    // REQUIRE(ar_str == "");
+
+    auto loader = immer_archive::champ::container_loader{to_load_archive(ar)};
+
+    const auto check = [&loader](auto id, const auto& expected) {
+        const auto loaded = loader.load(id);
+
+        for (const auto& item : expected) {
+            REQUIRE(loaded[item.id] == item);
+        }
+        for (const auto& item : loaded) {
+            REQUIRE(expected[item.id] == item);
+        }
+    };
+
+    check(t1_id, t1);
+    check(t2_id, t2);
+}
+
+TEST_CASE("Test modifying set nodes")
+{
+    using Container =
+        immer::set<std::string, immer_archive::xx_hash<std::string>>;
+
+    const auto expected_set  = gen_set(Container{}, 30);
+    const auto expected_set2 = expected_set.insert("thirty");
+
+    auto [ar, set_id] = immer_archive::champ::save_to_archive(expected_set, {});
+    auto set2_id      = immer_archive::node_id{};
+    std::tie(ar, set2_id) =
+        immer_archive::champ::save_to_archive(expected_set2, std::move(ar));
+    const auto ar_str        = to_json(ar);
+    const auto expected_data = json_t::parse(ar_str);
+    // REQUIRE(ar_str == "");
+
+    auto data = json_t::parse(R"({
+  "value0": [
+      {
+        "values": ["15", "27", "6", "0", "1", "20", "4"],
+        "children": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
+        "nodemap": 1343560972,
+        "datamap": 19407009,
+        "collisions": false
+      },
+      {
+        "values": ["25", "24"],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 536875008,
+        "collisions": false
+      },
+      {
+        "values": ["14", "16"],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 16777224,
+        "collisions": false
+      },
+      {
+        "values": ["23", "26", "9"],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 2147747840,
+        "collisions": false
+      },
+      {
+        "values": ["13", "8"],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 16512,
+        "collisions": false
+      },
+      {
+        "values": ["28", "22"],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 8388640,
+        "collisions": false
+      },
+      {
+        "values": ["3", "19"],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 2147485696,
+        "collisions": false
+      },
+      {
+        "values": ["10", "5"],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 33556480,
+        "collisions": false
+      },
+      {
+        "values": ["29", "18"],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 16778240,
+        "collisions": false
+      },
+      {
+        "values": ["2", "12"],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 9,
+        "collisions": false
+      },
+      {
+        "values": ["7", "11"],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 8388616,
+        "collisions": false
+      },
+      {
+        "values": ["21", "17"],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 268451840,
+        "collisions": false
+      },
+      {
+        "values": ["15", "27", "6", "0", "1", "thirty", "20", "4"],
+        "children": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
+        "nodemap": 1343560972,
+        "datamap": 19407011,
+        "collisions": false
+      }
+    ]
+})");
+    REQUIRE(data == expected_data);
+
+    const auto load_set = [&data](auto id) {
+        const auto loaded_archive =
+            from_json<immer_archive::champ::container_archive_load<Container>>(
+                data.dump());
+        auto loader = immer_archive::champ::container_loader{loaded_archive};
+        return loader.load(id);
+    };
+
+    SECTION("Loads correctly")
+    {
+        REQUIRE(load_set(set_id) == expected_set);
+        REQUIRE(load_set(set2_id) == expected_set2);
+    }
+    SECTION("Modify nodemap of node 0")
+    {
+        auto& nodemap = data["value0"][0]["nodemap"];
+        REQUIRE(nodemap == 1343560972);
+        nodemap = 1343560971;
+        REQUIRE_THROWS_AS(
+            load_set(set_id),
+            immer_archive::champ::children_count_corrupted_exception);
+        // Node 0 doesn't affect the second set
+        REQUIRE(load_set(set2_id) == expected_set2);
+    }
+    SECTION("Modify datamap of node 0")
+    {
+        auto& datamap = data["value0"][0]["datamap"];
+        REQUIRE(datamap == 19407009);
+        datamap = 19407008;
+        REQUIRE_THROWS_AS(load_set(set_id),
+                          immer_archive::champ::data_count_corrupted_exception);
+        // Node 0 doesn't affect the second set
+        REQUIRE(load_set(set2_id) == expected_set2);
+    }
+    SECTION("Modify nodemap of node 1")
+    {
+        auto& nodemap = data["value0"][1]["nodemap"];
+        REQUIRE(nodemap == 0);
+        nodemap = 1;
+        REQUIRE_THROWS_AS(
+            load_set(set_id),
+            immer_archive::champ::children_count_corrupted_exception);
+        REQUIRE_THROWS_AS(
+            load_set(set2_id),
+            immer_archive::champ::children_count_corrupted_exception);
+    }
+    SECTION("Modify datamap of node 1")
+    {
+        auto& datamap = data["value0"][1]["datamap"];
+        REQUIRE(datamap == 536875008);
+        datamap = 536875007;
+        REQUIRE_THROWS_AS(load_set(set_id),
+                          immer_archive::champ::data_count_corrupted_exception);
+        REQUIRE_THROWS_AS(load_set(set2_id),
+                          immer_archive::champ::data_count_corrupted_exception);
+    }
+    SECTION("Corrupt datamap but keep the same popcount")
+    {
+        auto& datamap = data["value0"][2]["datamap"];
+        REQUIRE(datamap == 16777224);
+        datamap = 536875008; // This number also has 2 bits set
+        REQUIRE_THROWS_AS(
+            load_set(set_id),
+            immer_archive::champ::hash_validation_failed_exception);
+        REQUIRE_THROWS_AS(
+            load_set(set2_id),
+            immer_archive::champ::hash_validation_failed_exception);
+    }
+    SECTION("Corrupt nodemap but keep the same popcount")
+    {
+        auto& nodemap = data["value0"][0]["nodemap"];
+        REQUIRE(nodemap == 1343560972);
+        nodemap = 1343560460; // This number has the same number of bits set
+        REQUIRE_THROWS_AS(
+            load_set(set_id),
+            immer_archive::champ::hash_validation_failed_exception);
+        // Node 0 doesn't affect the second set
+        REQUIRE(load_set(set2_id) == expected_set2);
+    }
+    SECTION("Missing a child node")
+    {
+        auto& children = data["value0"][0]["children"];
+        children       = {1, 2, 99, 4, 5, 6, 7, 8, 9, 10, 11};
+        REQUIRE_THROWS_AS(load_set(set_id), immer_archive::invalid_node_id);
+        REQUIRE(load_set(set2_id) == expected_set2);
+    }
+    SECTION("Same identity")
+    {
+        // Have to keep the loader alive between loads, otherwise there's no way
+        // to share the nodes.
+        const auto loaded_archive =
+            from_json<immer_archive::champ::container_archive_load<Container>>(
+                data.dump());
+        auto loader = immer_archive::champ::container_loader{loaded_archive};
+        REQUIRE(loader.load(node_id{0}).identity() ==
+                loader.load(node_id{0}).identity());
+    }
+}
+
+TEST_CASE("Test modifying nodes with collisions")
+{
+    using Container = immer::set<std::string, broken_hash>;
+
+    const auto expected_set  = gen_set(Container{}, 30);
+    const auto expected_set2 = expected_set.insert("thirty");
+
+    auto [ar, set_id] = immer_archive::champ::save_to_archive(expected_set, {});
+    auto set2_id      = immer_archive::node_id{};
+    std::tie(ar, set2_id) =
+        immer_archive::champ::save_to_archive(expected_set2, std::move(ar));
+    const auto ar_str        = to_json(ar);
+    const auto expected_data = json_t::parse(ar_str);
+
+    auto data = json_t::parse(R"({
+  "value0": [
+    {
+      "values": ["8", "27", "6", "29", "2", "0", "1", "7", "20", "4"],
+      "children": [1, 2, 3, 4, 5, 6],
+      "nodemap": 269550856,
+      "datamap": 2898085,
+      "collisions": false
+    },
+    {
+      "values": ["25", "24"],
+      "children": [],
+      "nodemap": 0,
+      "datamap": 536875008,
+      "collisions": false
+    },
+    {
+      "values": ["23", "26", "9"],
+      "children": [],
+      "nodemap": 0,
+      "datamap": 2147747840,
+      "collisions": false
+    },
+    {
+      "values": ["28", "22"],
+      "children": [],
+      "nodemap": 0,
+      "datamap": 8388640,
+      "collisions": false
+    },
+    {
+      "values": ["3", "19"],
+      "children": [],
+      "nodemap": 0,
+      "datamap": 2147485696,
+      "collisions": false
+    },
+    {
+      "values": ["10", "5"],
+      "children": [],
+      "nodemap": 0,
+      "datamap": 33556480,
+      "collisions": false
+    },
+    {
+      "values": ["21"],
+      "children": [7],
+      "nodemap": 134217728,
+      "datamap": 268435456,
+      "collisions": false
+    },
+    {
+      "values": [],
+      "children": [8],
+      "nodemap": 16777216,
+      "datamap": 0,
+      "collisions": false
+    },
+    {
+      "values": [],
+      "children": [9],
+      "nodemap": 16777216,
+      "datamap": 0,
+      "collisions": false
+    },
+    {
+      "values": [],
+      "children": [10],
+      "nodemap": 16777216,
+      "datamap": 0,
+      "collisions": false
+    },
+    {
+      "values": [],
+      "children": [11],
+      "nodemap": 16777216,
+      "datamap": 0,
+      "collisions": false
+    },
+    {
+      "values": [],
+      "children": [12],
+      "nodemap": 16777216,
+      "datamap": 0,
+      "collisions": false
+    },
+    {
+      "values": [],
+      "children": [13],
+      "nodemap": 16777216,
+      "datamap": 0,
+      "collisions": false
+    },
+    {
+      "values": [],
+      "children": [14],
+      "nodemap": 16777216,
+      "datamap": 0,
+      "collisions": false
+    },
+    {
+      "values": [],
+      "children": [15],
+      "nodemap": 16777216,
+      "datamap": 0,
+      "collisions": false
+    },
+    {
+      "values": [],
+      "children": [16],
+      "nodemap": 16777216,
+      "datamap": 0,
+      "collisions": false
+    },
+    {
+      "values": [],
+      "children": [17],
+      "nodemap": 16777216,
+      "datamap": 0,
+      "collisions": false
+    },
+    {
+      "values": [],
+      "children": [18],
+      "nodemap": 16777216,
+      "datamap": 0,
+      "collisions": false
+    },
+    {
+      "values": ["18", "17", "16", "15", "14", "13", "12", "11"],
+      "children": [],
+      "nodemap": 0,
+      "datamap": 0,
+      "collisions": true
+    },
+    {
+      "values": ["8", "27", "6", "29", "2", "0", "1", "thirty", "7", "20", "4"],
+      "children": [1, 2, 3, 4, 5, 6],
+      "nodemap": 269550856,
+      "datamap": 2898087,
+      "collisions": false
+    }
+  ]
+})");
+    INFO(ar_str);
+    REQUIRE(data == expected_data);
+
+    const auto load_set = [&data](auto id) {
+        const auto loaded_archive =
+            from_json<immer_archive::champ::container_archive_load<Container>>(
+                data.dump());
+        auto loader = immer_archive::champ::container_loader{loaded_archive};
+        return loader.load(id);
+    };
+
+    SECTION("Loads correctly")
+    {
+        REQUIRE(load_set(set_id) == expected_set);
+        REQUIRE(load_set(set2_id) == expected_set2);
+    }
+    SECTION("Order of collisions doesn't matter")
+    {
+        auto& node = data["value0"][18];
+        REQUIRE(
+            node["values"] ==
+            json_t::array({"18", "17", "16", "15", "14", "13", "12", "11"}));
+        node["values"] = {"15", "16", "17", "18", "14", "13", "12", "11"};
+        REQUIRE(load_set(set_id) == expected_set);
+        REQUIRE(load_set(set2_id) == expected_set2);
+
+        // Remove "18"
+        node["values"] = {"15", "16", "17", "14", "13", "12", "11"};
+        REQUIRE(load_set(set_id) == expected_set.erase("18"));
+    }
+}
diff --git a/test/experimental/immer-archive/test_special_archive.cpp b/test/experimental/immer-archive/test_special_archive.cpp
new file mode 100644
index 00000000..5c8d3501
--- /dev/null
+++ b/test/experimental/immer-archive/test_special_archive.cpp
@@ -0,0 +1,566 @@
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/matchers/catch_matchers_exception.hpp>
+
+#include "utils.hpp"
+
+#include <boost/hana.hpp>
+#include <immer/experimental/immer-archive/champ/traits.hpp>
+#include <immer/experimental/immer-archive/json/archivable.hpp>
+#include <immer/experimental/immer-archive/json/json_with_archive.hpp>
+#include <immer/experimental/immer-archive/rbts/traits.hpp>
+
+// to save std::pair
+#include <cereal/types/utility.hpp>
+
+#include <boost/hana/ext/std/tuple.hpp>
+
+namespace {
+
+namespace hana = boost::hana;
+
+/**
+ * Some user data type that contains some vector_one_archivable, which should be
+ * serialized in a special way.
+ */
+
+using test::flex_vector_one;
+using test::test_value;
+using test::vector_one;
+
+template <class T>
+std::string string_via_tie(const T& value)
+{
+    std::string result;
+    hana::for_each(value.tie(), [&](const auto& item) {
+        using Item = std::decay_t<decltype(item)>;
+        result += (result.empty() ? "" : ", ") +
+                  Catch::StringMaker<Item>::convert(item);
+    });
+    return result;
+}
+
+struct meta_meta
+{
+    immer_archive::archivable<vector_one<int>> ints;
+    immer_archive::archivable<immer::table<test_value>> table;
+
+    auto tie() const { return std::tie(ints, table); }
+
+    friend bool operator==(const meta_meta& left, const meta_meta& right)
+    {
+        return left.tie() == right.tie();
+    }
+
+    friend std::ostream& operator<<(std::ostream& s, const meta_meta& value)
+    {
+        return s << string_via_tie(value);
+    }
+
+    template <class Archive>
+    void serialize(Archive& ar)
+    {
+        ar(CEREAL_NVP(ints), CEREAL_NVP(table));
+    }
+};
+
+struct meta
+{
+    immer_archive::archivable<vector_one<int>> ints;
+    immer_archive::archivable<vector_one<meta_meta>> metas;
+
+    auto tie() const { return std::tie(ints, metas); }
+
+    friend bool operator==(const meta& left, const meta& right)
+    {
+        return left.tie() == right.tie();
+    }
+
+    friend std::ostream& operator<<(std::ostream& s, const meta& value)
+    {
+        return s << string_via_tie(value);
+    }
+
+    template <class Archive>
+    void serialize(Archive& ar)
+    {
+        ar(CEREAL_NVP(ints), CEREAL_NVP(metas));
+    }
+};
+
+struct test_data
+{
+    immer_archive::archivable<vector_one<int>> ints;
+    immer_archive::archivable<vector_one<std::string>> strings;
+
+    immer_archive::archivable<flex_vector_one<int>> flex_ints;
+    immer_archive::archivable<immer::map<int, std::string>> map;
+
+    immer_archive::archivable<vector_one<meta>> metas;
+
+    // Map value is indirectly archivable
+    immer_archive::archivable<immer::map<int, meta>> metas_map;
+
+    // Map value is directly archivable
+    immer_archive::archivable<
+        immer::map<int, immer_archive::archivable<vector_one<int>>>>
+        vectors_map;
+
+    // Also test having meta directly, not inside an archivable type
+    meta single_meta;
+
+    auto tie() const
+    {
+        return std::tie(ints,
+                        strings,
+                        flex_ints,
+                        map,
+                        metas,
+                        metas_map,
+                        vectors_map,
+                        single_meta);
+    }
+
+    friend bool operator==(const test_data& left, const test_data& right)
+    {
+        return left.tie() == right.tie();
+    }
+
+    /**
+     * Serialization function is defined as normal.
+     */
+    template <class Archive>
+    void serialize(Archive& ar)
+    {
+        ar(CEREAL_NVP(ints),
+           CEREAL_NVP(strings),
+           CEREAL_NVP(flex_ints),
+           CEREAL_NVP(map),
+           CEREAL_NVP(metas),
+           CEREAL_NVP(metas_map),
+           CEREAL_NVP(vectors_map),
+           CEREAL_NVP(single_meta));
+    }
+};
+
+/**
+ * A special function that enumerates which types of immer-archives are
+ * required. Explicitly name each type, for simplicity.
+ */
+inline auto get_archives_types(const test_data&)
+{
+    auto names = hana::make_map(
+        hana::make_pair(hana::type_c<vector_one<int>>,
+                        BOOST_HANA_STRING("ints")),
+        hana::make_pair(hana::type_c<vector_one<std::string>>,
+                        BOOST_HANA_STRING("strings")),
+        hana::make_pair(hana::type_c<flex_vector_one<int>>,
+                        BOOST_HANA_STRING("flex_ints")),
+        hana::make_pair(hana::type_c<immer::map<int, std::string>>,
+                        BOOST_HANA_STRING("int_string_map")),
+        hana::make_pair(hana::type_c<vector_one<meta>>,
+                        BOOST_HANA_STRING("metas")),
+        hana::make_pair(hana::type_c<vector_one<meta_meta>>,
+                        BOOST_HANA_STRING("meta_metas")),
+        hana::make_pair(hana::type_c<immer::table<test_value>>,
+                        BOOST_HANA_STRING("table_test_value")),
+        hana::make_pair(hana::type_c<immer::map<int, meta>>,
+                        BOOST_HANA_STRING("int_meta_map")),
+        hana::make_pair(
+            hana::type_c<
+                immer::map<int, immer_archive::archivable<vector_one<int>>>>,
+            BOOST_HANA_STRING("int_vector_map"))
+
+    );
+    return names;
+}
+
+inline auto get_archives_types(const std::pair<test_data, test_data>&)
+{
+    return get_archives_types(test_data{});
+}
+
+} // namespace
+
+template <>
+struct fmt::formatter<meta_meta> : ostream_formatter
+{};
+
+template <>
+struct fmt::formatter<meta> : ostream_formatter
+{};
+
+namespace Catch {
+template <>
+struct StringMaker<test_data>
+{
+    static std::string convert(const test_data& value)
+    {
+        return string_via_tie(value);
+    }
+};
+
+template <>
+struct StringMaker<meta>
+{
+    static std::string convert(const meta& value)
+    {
+        return string_via_tie(value);
+    }
+};
+
+template <>
+struct StringMaker<meta_meta>
+{
+    static std::string convert(const meta_meta& value)
+    {
+        return string_via_tie(value);
+    }
+};
+} // namespace Catch
+
+TEST_CASE("Special archive minimal test")
+{
+    const auto ints1 = vector_one<int>{
+        1,
+        2,
+        3,
+        4,
+        5,
+    };
+    const auto meta_value = meta{
+        .ints = ints1,
+        .metas =
+            {
+                meta_meta{
+                    .ints = ints1,
+                },
+            },
+    };
+    const auto test1 = test_data{
+        .metas =
+            {
+                meta_value,
+            },
+        .metas_map =
+            {
+                {234, meta_value},
+            },
+        .vectors_map =
+            {
+                {234, {2, 3, 4}},
+                {567, {5, 6, 7}},
+                {789, ints1},
+            },
+    };
+
+    const auto [json_str, archives] =
+        immer_archive::to_json_with_archive(test1);
+
+    // REQUIRE(json_str == "");
+
+    {
+        auto full_load =
+            immer_archive::from_json_with_archive<test_data>(json_str);
+        REQUIRE(full_load == test1);
+        // REQUIRE(immer_archive::to_json_with_archive(full_load).first == "");
+    }
+}
+
+TEST_CASE("Save with a special archive")
+{
+    spdlog::set_level(spdlog::level::debug);
+
+    const auto ints1 = test::gen(test::example_vector{}, 3);
+    const auto test1 = test_data{
+        .ints      = ints1,
+        .strings   = {"one", "two"},
+        .flex_ints = flex_vector_one<int>{ints1},
+        .map =
+            {
+                {1, "_one_"},
+                {2, "two__"},
+            },
+        .metas = {vector_one<meta>{
+            meta{
+                .ints =
+                    {
+                        1,
+                        2,
+                        3,
+                        4,
+                        5,
+                    },
+            },
+            meta{
+                .ints = ints1,
+            },
+        }},
+        .single_meta =
+            meta{
+                .ints = {66, 50, 55},
+            },
+    };
+
+    const auto [json_str, archives] =
+        immer_archive::to_json_with_archive(test1);
+    SECTION("Try to save and load the archive")
+    {
+        const auto archives_json = [&archives = archives] {
+            auto os = std::ostringstream{};
+            {
+                auto ar = immer_archive::json_immer_output_archive<
+                    std::decay_t<decltype(archives)>>{os};
+                ar(123);
+                ar(CEREAL_NVP(archives));
+            }
+            return os.str();
+        }();
+        // REQUIRE(archives_json == "");
+        const auto archives_loaded = [&archives_json] {
+            using Archives =
+                decltype(immer_archive::detail::generate_archives_load(
+                    get_archives_types(test_data{})));
+            auto archives = Archives{};
+
+            {
+                auto is = std::istringstream{archives_json};
+                auto ar = cereal::JSONInputArchive{is};
+                ar(CEREAL_NVP(archives));
+            }
+
+            {
+                auto is = std::istringstream{archives_json};
+                auto ar = immer_archive::json_immer_input_archive<Archives>{
+                    archives, is};
+                ar(CEREAL_NVP(archives));
+            }
+
+            return archives;
+        }();
+        REQUIRE(archives_loaded.storage[hana::type_c<vector_one<int>>]
+                    .archive.leaves.size() == 7);
+    }
+
+    // REQUIRE(json_str == "");
+
+    {
+        auto full_load =
+            immer_archive::from_json_with_archive<test_data>(json_str);
+        REQUIRE(full_load == test1);
+        // REQUIRE(immer_archive::to_json_with_archive(full_load).first == "");
+    }
+}
+
+TEST_CASE("Save with a special archive, special type is enclosed")
+{
+    const auto map = immer::map<int, std::string>{
+        {1, "_one_"},
+        {2, "two__"},
+    };
+    const auto ints1 = test::gen(test::example_vector{}, 3);
+    const auto ints5 = vector_one<int>{
+        1,
+        2,
+        3,
+        4,
+        5,
+    };
+    const auto metas = vector_one<meta>{
+        meta{
+            .ints = ints5,
+        },
+        meta{
+            .ints = ints1,
+        },
+    };
+    const auto test1 = test_data{
+        .ints      = ints1,
+        .strings   = {"one", "two"},
+        .flex_ints = flex_vector_one<int>{ints1},
+        .map       = map,
+        .metas     = metas,
+    };
+    const auto test2 = test_data{
+        .ints      = ints1,
+        .strings   = {"three"},
+        .flex_ints = flex_vector_one<int>{ints1},
+        .map       = map.set(3, "__three"),
+        .metas =
+            {
+                meta{
+                    .ints = ints5,
+                },
+            },
+    };
+
+    // At the beginning, the vector is shared, it's the same data.
+    REQUIRE(test1.ints.container.identity() == test2.ints.container.identity());
+    REQUIRE(test1.flex_ints.container.identity() ==
+            test2.flex_ints.container.identity());
+
+    const auto [json_str, archives] =
+        immer_archive::to_json_with_archive(std::make_pair(test1, test2));
+
+    // REQUIRE(json_str == "");
+
+    {
+        auto [loaded1, loaded2] = immer_archive::from_json_with_archive<
+            std::pair<test_data, test_data>>(json_str);
+        REQUIRE(loaded1 == test1);
+        REQUIRE(loaded2 == test2);
+
+        REQUIRE(loaded1.metas.container.size() == 2);
+        REQUIRE(loaded1.metas.container[0].ints == ints5);
+        REQUIRE(loaded1.metas.container[1].ints == ints1);
+
+        // After loading, two vectors are still reused.
+        REQUIRE(loaded1.ints.container.identity() ==
+                loaded2.ints.container.identity());
+        REQUIRE(loaded1.flex_ints.container.identity() ==
+                loaded2.flex_ints.container.identity());
+
+        REQUIRE(loaded1.metas.container[0].ints.container.identity() ==
+                loaded2.metas.container[0].ints.container.identity());
+    }
+}
+
+TEST_CASE("Special archive must load and save types that have no archive")
+{
+    const auto val1  = test_value{123, "value1"};
+    const auto val2  = test_value{234, "value2"};
+    const auto value = std::make_pair(val1, val2);
+
+    const auto json_archive_str =
+        immer_archive::to_json_with_archive(value).first;
+    REQUIRE(json_archive_str == test::to_json(value));
+
+    {
+        auto loaded = immer_archive::from_json_with_archive<
+            std::decay_t<decltype(value)>>(json_archive_str);
+        REQUIRE(loaded == value);
+    }
+}
+
+TEST_CASE("Special archive loads empty test_data")
+{
+    const auto value = test_data{};
+
+    // const auto json_archive_str =
+    //     immer_archive::to_json_with_archive(value).first;
+    // REQUIRE(json_archive_str == "");
+
+    const auto json_archive_str = R"({
+  "value0": {
+    "ints": 0,
+    "strings": 0,
+    "flex_ints": 0,
+    "map": 0,
+    "metas": 0,
+    "metas_map": 0,
+    "vectors_map": 0,
+    "single_meta": {"ints": 0, "metas": 0}
+  },
+  "archives": {
+    "ints": {
+      "leaves": [{"key": 1, "value": []}],
+      "inners": [{"key": 0, "value": {"children": [], "relaxed": false}}],
+      "vectors": [{"root": 0, "tail": 1}]
+    },
+    "strings": {
+      "leaves": [{"key": 1, "value": []}],
+      "inners": [{"key": 0, "value": {"children": [], "relaxed": false}}],
+      "vectors": [{"root": 0, "tail": 1}]
+    },
+    "flex_ints": {
+      "leaves": [{"key": 1, "value": []}],
+      "inners": [{"key": 0, "value": {"children": [], "relaxed": false}}],
+      "vectors": [{"root": 0, "tail": 1}]
+    },
+    "int_string_map": [
+          {"values": [], "children": [], "nodemap": 0, "datamap": 0, "collisions": false}
+    ],
+    "metas": {
+      "leaves": [{"key": 1, "value": []}],
+      "inners": [{"key": 0, "value": {"children": [], "relaxed": false}}],
+      "vectors": [{"root": 0, "tail": 1}]
+    },
+    "meta_metas": {
+      "leaves": [{"key": 1, "value": []}],
+      "inners": [{"key": 0, "value": {"children": [], "relaxed": false}}],
+      "vectors": [{"root": 0, "tail": 1}]
+    },
+    "table_test_value": [],
+    "int_meta_map": [
+        {"values": [], "children": [], "nodemap": 0, "datamap": 0, "collisions": false}
+    ],
+    "int_vector_map": [
+        {"values": [], "children": [], "nodemap": 0, "datamap": 0, "collisions": false}
+    ]
+  }
+})";
+
+    {
+        auto loaded = immer_archive::from_json_with_archive<
+            std::decay_t<decltype(value)>>(json_archive_str);
+        REQUIRE(loaded == value);
+    }
+}
+
+TEST_CASE("Special archive throws cereal::Exception")
+{
+    const auto value = test_data{};
+
+    // const auto json_archive_str =
+    //     immer_archive::to_json_with_archive(value).first;
+    // REQUIRE(json_archive_str == "");
+
+    const auto json_archive_str = R"({
+  "value0": {
+    "ints": 99,
+    "strings": 0,
+    "flex_ints": 0,
+    "map": 0,
+    "metas": 0,
+    "single_meta": {"ints": 0, "metas": 0}
+  },
+  "archives": {
+    "ints": {
+      "leaves": [{"key": 1, "value": []}],
+      "inners": [{"key": 0, "value": {"children": [], "relaxed": false}}],
+      "vectors": [{"root": 0, "tail": 1}]
+    },
+    "strings": {
+      "leaves": [{"key": 1, "value": []}],
+      "inners": [{"key": 0, "value": {"children": [], "relaxed": false}}],
+      "vectors": [{"root": 0, "tail": 1}]
+    },
+    "flex_ints": {
+      "leaves": [{"key": 1, "value": []}],
+      "inners": [{"key": 0, "value": {"children": [], "relaxed": false}}],
+      "vectors": [{"root": 0, "tail": 1}]
+    },
+    "int_string_map": [
+        {"values": [], "children": [], "nodemap": 0, "datamap": 0, "collisions": false}
+    ],
+    "metas": {
+      "leaves": [{"key": 1, "value": []}],
+      "inners": [{"key": 0, "value": {"children": [], "relaxed": false}}],
+      "vectors": [{"root": 0, "tail": 1}]
+    },
+    "meta_metas": {
+      "leaves": [{"key": 1, "value": []}],
+      "inners": [{"key": 0, "value": {"children": [], "relaxed": false}}],
+      "vectors": [{"root": 0, "tail": 1}]
+    },
+    "table_test_value": [],
+    "int_meta_map": [],
+    "int_vector_map": []
+  }
+})";
+
+    REQUIRE_THROWS_MATCHES(
+        immer_archive::from_json_with_archive<test_data>(json_archive_str),
+        ::cereal::Exception,
+        Catch::Matchers::Message("Failed to load a container ID 99 from the "
+                                 "archive: Container ID 99 is not found"));
+}
diff --git a/test/experimental/immer-archive/test_vectors.cpp b/test/experimental/immer-archive/test_vectors.cpp
new file mode 100644
index 00000000..79e1746f
--- /dev/null
+++ b/test/experimental/immer-archive/test_vectors.cpp
@@ -0,0 +1,1545 @@
+//
+//  main.cpp
+//  immer-test
+//
+//  Created by Alex Shabalin on 11/10/2023.
+//
+
+#include <catch2/catch_template_test_macros.hpp>
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/generators/catch_generators.hpp>
+
+#include <immer/experimental/immer-archive/rbts/load.hpp>
+#include <immer/experimental/immer-archive/rbts/save.hpp>
+
+#include "utils.hpp"
+
+#include <boost/hana.hpp>
+#include <boost/hana/ext/std/tuple.hpp>
+#include <spdlog/spdlog.h>
+
+#include <nlohmann/json.hpp>
+
+namespace {
+
+using namespace test;
+using immer_archive::container_id;
+using immer_archive::rbts::save_to_archive;
+using json_t   = nlohmann::json;
+namespace hana = boost::hana;
+
+auto load_vec(const auto& json, std::size_t vec_id)
+{
+    const auto archive =
+        test::from_json<immer_archive::rbts::archive_load<int>>(json);
+    auto loader =
+        immer_archive::rbts::make_loader_for(test::example_vector{}, archive);
+    return loader.load(container_id{vec_id});
+}
+
+auto load_flex_vec(const auto& json, std::size_t vec_id)
+{
+    const auto archive =
+        test::from_json<immer_archive::rbts::archive_load<int>>(json);
+    auto loader = immer_archive::rbts::make_loader_for(
+        test::example_flex_vector{}, archive);
+    return loader.load(container_id{vec_id});
+}
+
+} // namespace
+
+TEST_CASE("Save and load multiple times into the same archive")
+{
+    // spdlog::set_level(spdlog::level::trace);
+
+    auto test_vectors = std::vector<example_vector>{
+        // gen(example_vector{}, 4)
+        example_vector{},
+    };
+    auto counter = std::size_t{};
+    auto ar      = immer_archive::rbts::make_save_archive_for(example_vector{});
+    const auto save_and_load = [&]() {
+        const auto vec = test_vectors.back().push_back(++counter);
+        test_vectors.push_back(vec);
+
+        auto vector_id          = immer_archive::container_id{};
+        std::tie(ar, vector_id) = immer_archive::rbts::save_to_archive(vec, ar);
+
+        SPDLOG_DEBUG("start test size {}", vec.size());
+        {
+            auto loader =
+                std::make_optional(example_loader{fix_leaf_nodes(ar)});
+            auto loaded_vec = loader->load_vector(vector_id);
+            REQUIRE(loaded_vec == vec);
+        }
+        SPDLOG_DEBUG("end test size {}", vec.size());
+    };
+    // Memory leak investigation: starts only with 4 iterations.
+    // for (int i = 0; i < 4; ++i) {
+    //     save_and_load();
+    // }
+    save_and_load();
+    save_and_load();
+    save_and_load();
+    save_and_load();
+}
+
+TEST_CASE("Save and load vectors with shared nodes")
+{
+    // Create a bunch of vectors with shared nodes
+    const auto generate_vectors = [] {
+        const auto v1 = gen(example_vector{}, 69);
+        const auto v2 = v1.push_back(900);
+        const auto v3 = v2.push_back(901);
+        return std::vector<example_vector>{v1, v2, v3};
+    };
+
+    // Save them
+    const auto save_vectors = [](const auto& vectors)
+        -> std::pair<example_archive_save,
+                     std::vector<immer_archive::container_id>> {
+        auto ar  = example_archive_save{};
+        auto ids = std::vector<immer_archive::container_id>{};
+        for (const auto& v : vectors) {
+            auto [ar2, id] = save_to_archive(v, ar);
+            ar             = ar2;
+            ids.push_back(id);
+        }
+        REQUIRE(ids.size() == vectors.size());
+        return {std::move(ar), std::move(ids)};
+    };
+
+    const auto vectors   = generate_vectors();
+    const auto [ar, ids] = save_vectors(vectors);
+
+    {
+        // Check that if we generate the same but independent vectors and save
+        // them again, the archives look the same
+        const auto [ar2, ids2] = save_vectors(generate_vectors());
+        REQUIRE(to_json(ar) == to_json(ar2));
+    }
+
+    // Load them and verify they're equal to the original vectors
+    auto loader = std::make_optional(example_loader{fix_leaf_nodes(ar)});
+    std::vector<example_vector> loaded;
+    auto index = std::size_t{};
+    for (const auto& id : ids) {
+        auto v = loader->load_vector(id);
+        REQUIRE(v == vectors[index]);
+        loaded.push_back(v);
+        ++index;
+    }
+
+    SPDLOG_DEBUG("loaded == vectors {}", loaded == vectors);
+    REQUIRE(loaded == vectors);
+
+    SECTION("Deallocate loaded first, loader should collect all nodes")
+    {
+        loaded = {};
+        // Now the loader should deallocate all the nodes it has.
+    }
+    SECTION("Deallocate loader first, vectors should collect their nodes")
+    {
+        loader.reset();
+    }
+}
+
+TEST_CASE("Save and load vectors and flex vectors with shared nodes")
+{
+    // Create a bunch of vectors with shared nodes
+    const auto generate_vectors = [] {
+        const auto v1 = gen(example_vector{}, 69);
+        const auto v2 = v1.push_back(900);
+        const auto v3 = v2.push_back(901);
+        return std::vector<example_vector>{
+            v1,
+            v2,
+            v3,
+        };
+    };
+
+    const auto generate_flex_vectors = [] {
+        const auto v1 = gen(example_vector{}, 69);
+        const auto v2 = example_flex_vector{v1}.push_back(900);
+        const auto v3 = v2.push_back(901);
+        return std::vector<example_flex_vector>{
+            v1,
+            v2,
+            v3,
+            v1 + v3,
+            v3 + v2,
+            v2 + v3 + v1,
+        };
+    };
+
+    // Save them
+    const auto save_vectors = [](example_archive_save ar, const auto& vectors)
+        -> std::pair<example_archive_save,
+                     std::vector<immer_archive::container_id>> {
+        auto ids = std::vector<immer_archive::container_id>{};
+        for (const auto& v : vectors) {
+            auto [ar2, id] = save_to_archive(v, ar);
+            ar             = ar2;
+            ids.push_back(id);
+        }
+        REQUIRE(ids.size() == vectors.size());
+        return {std::move(ar), std::move(ids)};
+    };
+
+    auto ar                        = example_archive_save{};
+    const auto vectors             = generate_vectors();
+    const auto flex_vectors        = generate_flex_vectors();
+    auto vector_ids                = std::vector<immer_archive::container_id>{};
+    auto flex_vectors_ids          = std::vector<immer_archive::container_id>{};
+    std::tie(ar, vector_ids)       = save_vectors(ar, vectors);
+    std::tie(ar, flex_vectors_ids) = save_vectors(ar, flex_vectors);
+    REQUIRE(!vector_ids.empty());
+    REQUIRE(!flex_vectors_ids.empty());
+
+    {
+        // Check that if we generate the same but independent vectors and save
+        // them again, the archives look the same
+        const auto ar2 =
+            save_vectors(save_vectors({}, generate_vectors()).first,
+                         generate_flex_vectors())
+                .first;
+        REQUIRE(to_json(ar) == to_json(ar2));
+    }
+
+    // Load them and verify they're equal to the original vectors
+    auto loader = example_loader{fix_leaf_nodes(ar)};
+    auto loaded = [&] {
+        auto result = std::vector<example_vector>{};
+        auto index  = std::size_t{};
+        for (const auto& id : vector_ids) {
+            auto v = loader.load_vector(id);
+            REQUIRE(v == vectors[index]);
+            result.push_back(v);
+            ++index;
+        }
+        return result;
+    }();
+    REQUIRE(loaded == vectors);
+
+    auto loaded_flex = [&] {
+        auto result = std::vector<example_flex_vector>{};
+        auto index  = std::size_t{};
+        for (const auto& id : flex_vectors_ids) {
+            auto v = loader.load_flex_vector(id);
+            REQUIRE(v == flex_vectors[index]);
+            result.push_back(v);
+            ++index;
+        }
+        return result;
+    }();
+    REQUIRE(loaded_flex == flex_vectors);
+
+    loaded = {};
+    // Now the loader should deallocated all the nodes it has.
+}
+
+TEST_CASE("Archive in-place mutated vector")
+{
+    auto vec          = example_vector{1, 2, 3};
+    auto ar           = example_archive_save{};
+    auto id1          = immer_archive::container_id{};
+    std::tie(ar, id1) = save_to_archive(vec, ar);
+
+    vec               = std::move(vec).push_back(90);
+    auto id2          = immer_archive::container_id{};
+    std::tie(ar, id2) = save_to_archive(vec, ar);
+
+    REQUIRE(id1 != id2);
+
+    auto loader        = example_loader{fix_leaf_nodes(ar)};
+    const auto loaded1 = loader.load_vector(id1);
+    const auto loaded2 = loader.load_vector(id2);
+    REQUIRE(loaded2 == loaded1.push_back(90));
+}
+
+TEST_CASE("Archive in-place mutated flex_vector")
+{
+    auto vec          = example_flex_vector{1, 2, 3};
+    auto ar           = example_archive_save{};
+    auto id1          = immer_archive::container_id{};
+    std::tie(ar, id1) = save_to_archive(vec, ar);
+
+    vec               = std::move(vec).push_back(90);
+    auto id2          = immer_archive::container_id{};
+    std::tie(ar, id2) = save_to_archive(vec, ar);
+
+    REQUIRE(id1 != id2);
+
+    auto loader        = example_loader{fix_leaf_nodes(ar)};
+    const auto loaded1 = loader.load_flex_vector(id1);
+    const auto loaded2 = loader.load_flex_vector(id2);
+    REQUIRE(loaded2 == loaded1.push_back(90));
+}
+
+TEST_CASE("Test nodes reuse")
+{
+    const auto small_vec = gen(test::flex_vector_one<int>{}, 67);
+    const auto big_vec   = small_vec + small_vec;
+
+    auto ar           = example_archive_save{};
+    auto id1          = immer_archive::container_id{};
+    std::tie(ar, id1) = save_to_archive(big_vec, ar);
+
+    {
+        // Loads correctly
+        auto loader        = example_loader{fix_leaf_nodes(ar)};
+        const auto loaded1 = loader.load_flex_vector(id1);
+        REQUIRE(loaded1 == big_vec);
+    }
+
+    // REQUIRE(to_json(ar) == "");
+}
+
+TEST_CASE("Test saving and loading vectors of different lengths", "[slow]")
+{
+    constexpr auto for_each_generated_length =
+        [](auto init, int count, auto&& process) {
+            process(init);
+            for (int i = 0; i < count; ++i) {
+                init = std::move(init).push_back(i);
+                process(init);
+            }
+        };
+
+    SECTION("archive each vector by itself")
+    {
+        for_each_generated_length(
+            test::vector_one<int>{}, 350, [&](const auto& vec) {
+                auto ar           = example_archive_save{};
+                auto id1          = immer_archive::container_id{};
+                std::tie(ar, id1) = save_to_archive(vec, ar);
+
+                {
+                    // Loads correctly
+                    auto loader        = example_loader{fix_leaf_nodes(ar)};
+                    const auto loaded1 = loader.load_vector(id1);
+                    REQUIRE(loaded1 == vec);
+                }
+            });
+    }
+
+    SECTION("keep archiving into the same archive")
+    {
+        auto ar = example_archive_save{};
+        for_each_generated_length(
+            test::vector_one<int>{}, 350, [&](const auto& vec) {
+                auto id1          = immer_archive::container_id{};
+                std::tie(ar, id1) = save_to_archive(vec, ar);
+
+                {
+                    // Loads correctly
+                    auto loader        = example_loader{fix_leaf_nodes(ar)};
+                    const auto loaded1 = loader.load_vector(id1);
+                    REQUIRE(loaded1 == vec);
+                }
+            });
+    }
+}
+
+TEST_CASE("Test flex vectors memory leak")
+{
+    constexpr auto for_each_generated_length_flex =
+        [](auto init, int count, auto&& process) {
+            for (int i = 0; i < count; ++i) {
+                init = std::move(init).push_back(i);
+                process(init);
+            }
+        };
+
+    constexpr auto max_length = 350;
+
+    SECTION("Loader deallocates nodes")
+    {
+        auto loaders = std::vector<example_loader>{};
+
+        for_each_generated_length_flex(
+            test::flex_vector_one<int>{}, max_length, [&](const auto& vec) {
+                auto ar           = example_archive_save{};
+                auto id1          = immer_archive::container_id{};
+                std::tie(ar, id1) = save_to_archive(vec, ar);
+
+                {
+                    // Loads correctly
+                    loaders.emplace_back(fix_leaf_nodes(ar));
+                    auto& loader       = loaders.back();
+                    const auto loaded1 = loader.load_flex_vector(id1);
+                    REQUIRE(loaded1 == vec);
+                }
+            });
+    }
+    SECTION("Inner node should deallocate its children")
+    {
+        /**
+         * The goal is to trigger the branch where the loader has to deallocate
+         * an inner node AND its children which also must be inner nodes.
+         *
+         * It's not that easy because if a child is a leaf, leaves are stored in
+         * the separate map `immer::map<node_id, node_ptr> leaves_` and
+         * therefore, will never be deallocated by an inner node.
+         *
+         * So it must be an inner node that has the last pointer to another
+         * inner node.
+         */
+        auto ar   = example_archive_save{};
+        auto ids  = std::vector<immer_archive::container_id>{};
+        auto vecs = std::vector<test::flex_vector_one<int>>{};
+
+        for_each_generated_length_flex(
+            test::flex_vector_one<int>{}, max_length, [&](const auto& vec) {
+                auto id1          = immer_archive::container_id{};
+                std::tie(ar, id1) = save_to_archive(vec, ar);
+                ids.push_back(id1);
+                vecs.push_back(vec);
+            });
+
+        auto index = std::size_t{};
+        for (const auto& id : ids) {
+            auto loader        = example_loader{fix_leaf_nodes(ar)};
+            const auto loaded1 = loader.load_flex_vector(id);
+            REQUIRE(loaded1 == vecs[index]);
+            ++index;
+        }
+    }
+    SECTION("Vector deallocates nodes")
+    {
+        for_each_generated_length_flex(
+            test::flex_vector_one<int>{}, max_length, [&](const auto& vec) {
+                auto ar           = example_archive_save{};
+                auto id1          = immer_archive::container_id{};
+                std::tie(ar, id1) = save_to_archive(vec, ar);
+
+                {
+                    // Loads correctly
+                    const auto loaded1 =
+                        example_loader{fix_leaf_nodes(ar)}.load_flex_vector(
+                            id1);
+                    REQUIRE(loaded1 == vec);
+                }
+            });
+    }
+}
+
+TEST_CASE("Test saving and loading flex vectors of different lengths", "[slow]")
+{
+    constexpr auto for_each_generated_length_flex =
+        [](auto init, int count, auto&& process) {
+            // Combine flex and non-flex
+            process(init);
+            process(flex_vector_one<int>{init});
+            process(flex_vector_one<int>{init} + init);
+            for (int i = 0; i < count; ++i) {
+                auto prev = init;
+                init      = std::move(init).push_back(i);
+
+                process(init);
+                process(flex_vector_one<int>{prev} + init);
+                process(flex_vector_one<int>{init} + prev);
+                process(flex_vector_one<int>{init} + init);
+            }
+        };
+
+    SECTION("one vector per archive")
+    {
+        for_each_generated_length_flex(
+            test::flex_vector_one<int>{}, 350, [&](const auto& vec) {
+                auto ar           = example_archive_save{};
+                auto id1          = immer_archive::container_id{};
+                std::tie(ar, id1) = save_to_archive(vec, ar);
+
+                {
+                    // Loads correctly
+                    auto loader        = example_loader{fix_leaf_nodes(ar)};
+                    const auto loaded1 = loader.load_flex_vector(id1);
+                    REQUIRE(loaded1 == vec);
+                }
+            });
+    }
+
+    SECTION("one archive for all")
+    {
+        auto ar = example_archive_save{};
+        for_each_generated_length_flex(
+            test::vector_one<int>{}, 350, [&](const auto& vec) {
+                auto id1          = immer_archive::container_id{};
+                std::tie(ar, id1) = save_to_archive(vec, ar);
+
+                // Loads correctly
+                auto loader        = make_loader_for(vec, fix_leaf_nodes(ar));
+                const auto loaded1 = loader.load(id1);
+                REQUIRE(loaded1 == vec);
+            });
+    }
+}
+
+TEST_CASE("A loop with 2 nodes")
+{
+    const auto json = std::string{R"({
+    "value0": {
+        "leaves": [
+            {
+                "key": 32,
+                "value": [
+                    58,
+                    59
+                ]
+            },
+            {
+                "key": 34,
+                "value": [
+                    62,
+                    63
+                ]
+            },
+            {
+                "key": 3,
+                "value": [
+                    0,
+                    1
+                ]
+            },
+            {
+                "key": 5,
+                "value": [
+                    4,
+                    5
+                ]
+            },
+            {
+                "key": 6,
+                "value": [
+                    6,
+                    7
+                ]
+            },
+            {
+                "key": 7,
+                "value": [
+                    8,
+                    9
+                ]
+            },
+            {
+                "key": 8,
+                "value": [
+                    10,
+                    11
+                ]
+            },
+            {
+                "key": 9,
+                "value": [
+                    12,
+                    13
+                ]
+            },
+            {
+                "key": 10,
+                "value": [
+                    14,
+                    15
+                ]
+            },
+            {
+                "key": 11,
+                "value": [
+                    16,
+                    17
+                ]
+            },
+            {
+                "key": 12,
+                "value": [
+                    18,
+                    19
+                ]
+            },
+            {
+                "key": 13,
+                "value": [
+                    20,
+                    21
+                ]
+            },
+            {
+                "key": 14,
+                "value": [
+                    22,
+                    23
+                ]
+            },
+            {
+                "key": 15,
+                "value": [
+                    24,
+                    25
+                ]
+            },
+            {
+                "key": 16,
+                "value": [
+                    26,
+                    27
+                ]
+            },
+            {
+                "key": 17,
+                "value": [
+                    28,
+                    29
+                ]
+            },
+            {
+                "key": 18,
+                "value": [
+                    30,
+                    31
+                ]
+            },
+            {
+                "key": 19,
+                "value": [
+                    32,
+                    33
+                ]
+            },
+            {
+                "key": 20,
+                "value": [
+                    34,
+                    35
+                ]
+            },
+            {
+                "key": 21,
+                "value": [
+                    36,
+                    37
+                ]
+            },
+            {
+                "key": 22,
+                "value": [
+                    38,
+                    39
+                ]
+            },
+            {
+                "key": 23,
+                "value": [
+                    40,
+                    41
+                ]
+            },
+            {
+                "key": 24,
+                "value": [
+                    42,
+                    43
+                ]
+            },
+            {
+                "key": 25,
+                "value": [
+                    44,
+                    45
+                ]
+            },
+            {
+                "key": 26,
+                "value": [
+                    46,
+                    47
+                ]
+            },
+            {
+                "key": 27,
+                "value": [
+                    48,
+                    49
+                ]
+            },
+            {
+                "key": 28,
+                "value": [
+                    50,
+                    51
+                ]
+            },
+            {
+                "key": 29,
+                "value": [
+                    52,
+                    53
+                ]
+            },
+            {
+                "key": 30,
+                "value": [
+                    54,
+                    55
+                ]
+            },
+            {
+                "key": 31,
+                "value": [
+                    56,
+                    57
+                ]
+            },
+            {
+                "key": 1,
+                "value": [
+                    66
+                ]
+            },
+            {
+                "key": 33,
+                "value": [
+                    60,
+                    61
+                ]
+            },
+            {
+                "key": 4,
+                "value": [
+                    2,
+                    3
+                ]
+            },
+            {
+                "key": 36,
+                "value": [
+                    64,
+                    65
+                ]
+            }
+        ],
+        "inners": [
+            {
+                "key": 0,
+                "value": {
+                    "children": [
+                        2,
+                        35
+                    ],
+                    "relaxed": false
+                }
+            },
+            {
+                "key": 35,
+                "value": {
+                    "children": [
+                        36, 0
+                    ],
+                    "relaxed": false
+                }
+            },
+            {
+                "key": 2,
+                "value": {
+                    "children": [ 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34 ],
+                    "relaxed": false
+                }
+            }
+        ],
+        "vectors": [
+            {
+                "root": 0,
+                "tail": 1
+            }
+        ]
+    }
+}
+)"};
+    REQUIRE_THROWS_AS(load_flex_vec(json, 0),
+                      immer_archive::archive_has_cycles);
+}
+
+namespace {
+struct big_object
+{
+    double a, b, c, d, e;
+
+    big_object(int val)
+        : a{static_cast<double>(val)}
+        , b{a * 10}
+        , c{a * 100}
+        , d{a * 1000}
+        , e{a * 10000}
+    {
+    }
+
+    auto tie() const { return std::tie(a, b, c, d, e); }
+
+    template <class Archive>
+    void serialize(Archive& ar)
+    {
+        ar(CEREAL_NVP(a),
+           CEREAL_NVP(b),
+           CEREAL_NVP(c),
+           CEREAL_NVP(d),
+           CEREAL_NVP(e));
+    }
+
+    friend bool operator==(const big_object& left, const big_object& right)
+    {
+        return left.tie() == right.tie();
+    }
+
+    friend std::ostream& operator<<(std::ostream& s, const big_object& value)
+    {
+        return s << fmt::format("({}, {}, {}, {}, {})",
+                                value.a,
+                                value.b,
+                                value.c,
+                                value.d,
+                                value.e);
+    }
+};
+
+template <class T>
+class show_type;
+
+template <class T>
+using node_for = typename decltype([] {
+    using rbtree_t = std::decay_t<decltype(test::vector_one<T>{}.impl())>;
+    using node_t   = typename rbtree_t::node_t;
+    return boost::hana::type_c<node_t>;
+}())::type;
+} // namespace
+
+TEST_CASE("Test vector with very big objects")
+{
+    // There are always two branches, two objects in the leaf.
+    static_assert(immer::detail::rbts::branches<1> == 2);
+
+    // Even when the object is big, immer::vector puts up to 2 of them in a
+    // leaf.
+    using big_object_node_t = node_for<big_object>;
+    static_assert(big_object_node_t::bits_leaf == 1);
+    static_assert(sizeof(big_object) == 40);
+    // 96 is in Debug probably because 40 is aligned to 48, times two.
+    // 88 is in Release. The actual number doesn't really matter, it's just here
+    // to have an idea of the sizes we're dealing with.
+    static_assert(big_object_node_t::max_sizeof_leaf == 96 ||
+                  big_object_node_t::max_sizeof_leaf == 88);
+
+    using int_node_t = node_for<int>;
+    static_assert(int_node_t::bits_leaf == 1);
+    static_assert(sizeof(int) == 4);
+    // show_type<boost::hana::size_t<int_node_t::max_sizeof_leaf>> show;
+    static_assert(int_node_t::max_sizeof_leaf == 24 ||
+                  int_node_t::max_sizeof_leaf == 16);
+
+    const auto small_vec = gen(test::vector_one<big_object>{}, 67);
+
+    auto ar = immer_archive::rbts::make_save_archive_for(
+        test::vector_one<big_object>{});
+    auto id1          = immer_archive::container_id{};
+    std::tie(ar, id1) = save_to_archive(small_vec, ar);
+
+    {
+        // Loads correctly
+        auto loader = immer_archive::rbts::make_loader_for(
+            test::vector_one<big_object>{}, fix_leaf_nodes(ar));
+        const auto loaded1 = loader.load(id1);
+        REQUIRE(loaded1 == small_vec);
+    }
+
+    // REQUIRE(to_json(ar) == "");
+}
+
+TEST_CASE("Test modifying vector nodes")
+{
+    json_t data;
+    data["value0"]["leaves"] = {
+        {
+            {"key", 1},
+            {"value", {6}},
+        },
+        {
+            {"key", 2},
+            {"value", {0, 1}},
+        },
+        {
+            {"key", 3},
+            {"value", {2, 3}},
+        },
+        {
+            {"key", 4},
+            {"value", {4, 5}},
+        },
+    };
+    data["value0"]["inners"] = {
+        {
+            {"key", 0},
+            {
+                "value",
+                {
+                    {"children", {2, 3, 4}},
+                    {"relaxed", false},
+                },
+            },
+        },
+    };
+    data["value0"]["vectors"] = {
+        {
+            {"root", 0},
+            {"tail", 1},
+        },
+    };
+    data["value0"]["flex_vectors"] = json_t::array();
+
+    SECTION("Loads correctly")
+    {
+        const auto vec = test::vector_one<int>{0, 1, 2, 3, 4, 5, 6};
+        REQUIRE(load_vec(data.dump(), 0) == vec);
+    }
+
+    SECTION("Load non-existing vector")
+    {
+        REQUIRE_THROWS_AS(load_vec(data.dump(), 99),
+                          immer_archive::archive_exception);
+    }
+
+    SECTION("Invalid root id")
+    {
+        data["value0"]["vectors"][0]["root"] = 1;
+        REQUIRE_THROWS_AS(load_vec(data.dump(), 0),
+                          immer_archive::invalid_node_id);
+    }
+
+    SECTION("Invalid tail id")
+    {
+        data["value0"]["vectors"][0]["tail"] = 999;
+        REQUIRE_THROWS_AS(load_vec(data.dump(), 0),
+                          immer_archive::invalid_node_id);
+    }
+
+    SECTION("A leaf with too few elements")
+    {
+        auto& item = data["value0"]["leaves"][2];
+        REQUIRE(item["key"] == 3);
+        // Leaf #3 should have two elements, but it has only one.
+        item["value"] = {2};
+        REQUIRE_THROWS_AS(load_vec(data.dump(), 0),
+                          immer_archive::rbts::vector_corrupted_exception);
+    }
+
+    SECTION("Mess with the tail")
+    {
+        auto& item = data["value0"]["leaves"][0];
+        REQUIRE(item["key"] == 1);
+        SECTION("Add to the tail")
+        {
+            item["value"]  = {6, 7};
+            const auto vec = test::vector_one<int>{0, 1, 2, 3, 4, 5, 6, 7};
+            REQUIRE(load_vec(data.dump(), 0) == vec);
+        }
+        SECTION("Remove from the tail")
+        {
+            item["value"] = json_t::array();
+            REQUIRE_THROWS_AS(load_vec(data.dump(), 0),
+                              immer_archive::rbts::vector_corrupted_exception);
+        }
+        SECTION("Add too many elements")
+        {
+            // Three elements can't be in a leaf
+            item["value"] = {6, 7, 8};
+            REQUIRE_THROWS_AS(load_vec(data.dump(), 0),
+                              immer_archive::invalid_children_count);
+        }
+    }
+
+    SECTION("Modify children")
+    {
+        auto& item = data["value0"]["inners"][0];
+        REQUIRE(item["key"] == 0);
+        SECTION("Add too many")
+        {
+            item["value"]["children"] = std::vector<int>(33, 2);
+            REQUIRE_THROWS_AS(load_vec(data.dump(), 0),
+                              immer_archive::invalid_children_count);
+        }
+        SECTION("Remove one")
+        {
+            item["value"]["children"] = {2, 4};
+            const auto vec            = test::vector_one<int>{0, 1, 4, 5, 6};
+            REQUIRE(load_vec(data.dump(), 0) == vec);
+        }
+        SECTION("Unknown child")
+        {
+            item["value"]["children"] = {2, 4, 9};
+            REQUIRE_THROWS_AS(load_vec(data.dump(), 0),
+                              immer_archive::invalid_node_id);
+        }
+        SECTION("Node has itself as a child")
+        {
+            item["value"]["children"] = {2, 0, 4};
+            REQUIRE_THROWS_AS(load_vec(data.dump(), 0),
+                              immer_archive::archive_has_cycles);
+        }
+        SECTION("Strict vector can not have relaxed nodes")
+        {
+            item["value"]["relaxed"] = true;
+            REQUIRE_THROWS_AS(
+                load_vec(data.dump(), 0),
+                immer_archive::rbts::relaxed_node_not_allowed_exception);
+        }
+    }
+}
+
+TEST_CASE("Test modifying flex vector nodes")
+{
+    json_t data;
+    data["value0"]["leaves"] = {
+        {
+            {"key", 1},
+            {"value", {6, 99}},
+        },
+        {
+            {"key", 2},
+            {"value", {0, 1}},
+        },
+        {
+            {"key", 3},
+            {"value", {2, 3}},
+        },
+        {
+            {"key", 4},
+            {"value", {4, 5}},
+        },
+        {
+            {"key", 5},
+            {"value", {6}},
+        },
+    };
+    data["value0"]["inners"] = {
+        {
+            {"key", 0},
+            {
+                "value",
+                {
+                    {"children", {2, 3, 4, 5, 2, 3, 4}},
+                    {"relaxed", true},
+                },
+            },
+        },
+        {
+            {"key", 902},
+            {
+                "value",
+                {
+                    {"children", {2, 2, 3, 4}},
+                    {"relaxed", true},
+                },
+            },
+        },
+    };
+    data["value0"]["vectors"] = {
+        {
+            {"root", 0},
+            {"tail", 1},
+        },
+    };
+
+    SECTION("Loads correctly")
+    {
+        const auto small_vec = gen(test::flex_vector_one<int>{}, 7);
+        const auto vec = small_vec + small_vec + test::flex_vector_one<int>{99};
+        REQUIRE(load_flex_vec(data.dump(), 0) == vec);
+    }
+    SECTION("Load non-existing vector")
+    {
+        REQUIRE_THROWS_AS(load_flex_vec(data.dump(), 99),
+                          immer_archive::archive_exception);
+    }
+    SECTION("Non-relaxed vector can not have relaxed nodes")
+    {
+        REQUIRE_THROWS_AS(
+            load_vec(data.dump(), 0),
+            immer_archive::rbts::relaxed_node_not_allowed_exception);
+    }
+    SECTION("Modify starting leaf")
+    {
+        auto& item = data["value0"]["leaves"][1];
+        REQUIRE(item["key"] == 2);
+        SECTION("One element")
+        {
+            item["value"]      = {0};
+            const auto vec_234 = test::flex_vector_one<int>{0, 2, 3, 4, 5};
+            const auto leaf_1  = test::flex_vector_one<int>{6, 99};
+            const auto leaf_5  = test::flex_vector_one<int>{6};
+            const auto vec     = vec_234 + leaf_5 + vec_234 + leaf_1;
+            REQUIRE(load_flex_vec(data.dump(), 0) == vec);
+        }
+
+        // Empty starting leaf triggers a separate branch in the code, actually.
+        SECTION("Empty leaf")
+        {
+            item["value"]      = json_t::array();
+            const auto vec_234 = test::flex_vector_one<int>{2, 3, 4, 5};
+            const auto leaf_1  = test::flex_vector_one<int>{6, 99};
+            const auto leaf_5  = test::flex_vector_one<int>{6};
+            const auto vec     = vec_234 + leaf_5 + vec_234 + leaf_1;
+            REQUIRE(load_flex_vec(data.dump(), 0) == vec);
+        }
+    }
+    SECTION("Modify second leaf")
+    {
+        auto& item = data["value0"]["leaves"][2];
+        REQUIRE(item["key"] == 3);
+        SECTION("One element")
+        {
+            item["value"]      = {2};
+            const auto vec_234 = test::flex_vector_one<int>{0, 1, 2, 4, 5};
+            const auto leaf_1  = test::flex_vector_one<int>{6, 99};
+            const auto leaf_5  = test::flex_vector_one<int>{6};
+            const auto vec     = vec_234 + leaf_5 + vec_234 + leaf_1;
+            REQUIRE(load_flex_vec(data.dump(), 0) == vec);
+        }
+        SECTION("Empty leaf")
+        {
+            item["value"]      = json_t::array();
+            const auto vec_234 = test::flex_vector_one<int>{0, 1, 4, 5};
+            const auto leaf_1  = test::flex_vector_one<int>{6, 99};
+            const auto leaf_5  = test::flex_vector_one<int>{6};
+            const auto vec     = vec_234 + leaf_5 + vec_234 + leaf_1;
+            REQUIRE(load_flex_vec(data.dump(), 0) == vec);
+        }
+    }
+    SECTION("Modify inner node")
+    {
+        auto& item = data["value0"]["inners"][0];
+        REQUIRE(item["key"] == 0);
+        SECTION("Mix leaves and inners as children")
+        {
+            auto& children = item["value"]["children"];
+            REQUIRE(children == json_t::array({2, 3, 4, 5, 2, 3, 4}));
+            children = {2, 3, 4, 902, 4};
+            REQUIRE_THROWS_AS(
+                load_flex_vec(data.dump(), 0),
+                immer_archive::rbts::same_depth_children_exception);
+        }
+        SECTION("No children")
+        {
+            item["value"]["children"] = json_t::array();
+            // There was a problem when an empty relaxed node triggered an
+            // assert, while non-relaxed worked fine.
+            const auto is_relaxed    = GENERATE(false, true);
+            item["value"]["relaxed"] = is_relaxed;
+            const auto leaf_1        = test::flex_vector_one<int>{6, 99};
+            REQUIRE(load_flex_vec(data.dump(), 0) == leaf_1);
+        }
+        SECTION("Too many children")
+        {
+            item["value"]["children"] = std::vector<int>(40, 3);
+            const auto is_relaxed     = GENERATE(false, true);
+            item["value"]["relaxed"]  = is_relaxed;
+            REQUIRE_THROWS_AS(load_flex_vec(data.dump(), 0),
+                              immer_archive::invalid_children_count);
+        }
+        SECTION("Remove a child")
+        {
+            SECTION("All leaves are full, non-relaxed works")
+            {
+                item["value"]["children"] = {2, 3, 4, 2, 3, 4};
+                const auto is_relaxed     = GENERATE(false, true);
+                item["value"]["relaxed"]  = is_relaxed;
+                const auto leaf_1         = test::flex_vector_one<int>{6, 99};
+                const auto vec_234 =
+                    test::flex_vector_one<int>{0, 1, 2, 3, 4, 5};
+                const auto vec = vec_234 + vec_234 + leaf_1;
+                REQUIRE(load_flex_vec(data.dump(), 0) == vec);
+            }
+            SECTION("Relaxed leaf")
+            {
+                item["value"]["children"] = {2, 3, 5, 3};
+                SECTION("Non-relaxed breaks")
+                {
+                    item["value"]["relaxed"] = false;
+                    REQUIRE_THROWS_AS(
+                        load_flex_vec(data.dump(), 0),
+                        immer_archive::rbts::vector_corrupted_exception);
+                }
+                SECTION("Relaxed works")
+                {
+                    const auto leaf_1 = test::flex_vector_one<int>{6, 99};
+                    const auto leaf_2 = test::flex_vector_one<int>{0, 1};
+                    const auto leaf_3 = test::flex_vector_one<int>{2, 3};
+                    const auto leaf_5 = test::flex_vector_one<int>{6};
+
+                    const auto vec = leaf_2 + leaf_3 + leaf_5 + leaf_3 + leaf_1;
+                    REQUIRE(load_flex_vec(data.dump(), 0) == vec);
+                }
+            }
+        }
+    }
+}
+
+TEST_CASE("Print shift calculation", "[.print_shift]")
+{
+    // It starts with BL, which is 1.
+    // Then grows by B, which is 5 by default.
+    // size [0, 66], shift 1
+    // size [67, 2050], shift 6
+    // size [2051, 65538], shift 11
+    auto vec        = example_vector{};
+    auto last_shift = vec.impl().shift;
+    for (auto index = 0; index < 90000; ++index) {
+        vec              = vec.push_back(index);
+        const auto shift = vec.impl().shift;
+        if (shift != last_shift) {
+            SPDLOG_INFO("size {}, shift {}", vec.size(), shift);
+            last_shift = shift;
+        }
+    }
+}
+
+TEST_CASE("Test more inner nodes")
+{
+    json_t data;
+    data["value0"]["leaves"] = {
+        {{"key", 32}, {"value", {58, 59}}}, {{"key", 34}, {"value", {62, 63}}},
+        {{"key", 3}, {"value", {0, 1}}},    {{"key", 5}, {"value", {4, 5}}},
+        {{"key", 6}, {"value", {6, 7}}},    {{"key", 7}, {"value", {8, 9}}},
+        {{"key", 8}, {"value", {10, 11}}},  {{"key", 9}, {"value", {12, 13}}},
+        {{"key", 10}, {"value", {14, 15}}}, {{"key", 11}, {"value", {16, 17}}},
+        {{"key", 12}, {"value", {18, 19}}}, {{"key", 13}, {"value", {20, 21}}},
+        {{"key", 14}, {"value", {22, 23}}}, {{"key", 15}, {"value", {24, 25}}},
+        {{"key", 16}, {"value", {26, 27}}}, {{"key", 17}, {"value", {28, 29}}},
+        {{"key", 18}, {"value", {30, 31}}}, {{"key", 19}, {"value", {32, 33}}},
+        {{"key", 20}, {"value", {34, 35}}}, {{"key", 21}, {"value", {36, 37}}},
+        {{"key", 22}, {"value", {38, 39}}}, {{"key", 23}, {"value", {40, 41}}},
+        {{"key", 24}, {"value", {42, 43}}}, {{"key", 25}, {"value", {44, 45}}},
+        {{"key", 26}, {"value", {46, 47}}}, {{"key", 27}, {"value", {48, 49}}},
+        {{"key", 28}, {"value", {50, 51}}}, {{"key", 29}, {"value", {52, 53}}},
+        {{"key", 30}, {"value", {54, 55}}}, {{"key", 31}, {"value", {56, 57}}},
+        {{"key", 1}, {"value", {66}}},      {{"key", 33}, {"value", {60, 61}}},
+        {{"key", 4}, {"value", {2, 3}}},    {{"key", 36}, {"value", {64, 65}}},
+    };
+    data["value0"]["inners"] = {
+        {{"key", 0}, {"value", {{"children", {2, 35}}, {"relaxed", false}}}},
+        {{"key", 2},
+         {"value",
+          {{"children",
+            {3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16, 17, 18,
+             19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34}},
+           {"relaxed", false}}}},
+        {{"key", 35}, {"value", {{"children", {36}}, {"relaxed", false}}}},
+    };
+    data["value0"]["vectors"] = {
+        {
+            {"root", 0},
+            {"tail", 1},
+        },
+    };
+    data["value0"]["flex_vectors"] = json_t::array();
+
+    SECTION("Loads correctly")
+    {
+        REQUIRE(load_vec(data.dump(), 0) == gen(example_vector{}, 67));
+    }
+    SECTION("Throw in some empty nodes")
+    {
+        // Empty leaf #205
+        data["value0"]["leaves"].push_back(
+            {{"key", 205}, {"value", json_t::array()}});
+        // Inner node #560 referencing the empty leaf
+        data["value0"]["inners"].push_back(
+            {{"key", 560},
+             {"value", {{"children", {205}}, {"relaxed", false}}}});
+        auto& item = data["value0"]["inners"][0];
+        SECTION("Three nodes")
+        {
+            item["value"]["children"] = {2, 560, 35};
+            REQUIRE(load_vec(data.dump(), 0) == gen(example_vector{}, 67));
+        }
+
+        /**
+         * NOTE: These two tests do not work as long as there is a bug in "Test
+         * flex vector with a weird shape strict".
+         */
+        // SECTION("Empty first")
+        // {
+        //     FAIL("Fix this test");
+        //     item["value"]["children"] = {560, 35};
+        //     REQUIRE_NOTHROW(load_vec(data.dump(), 0));
+        //     for (auto i : load_vec(data.dump(), 0)) {
+        //         SPDLOG_INFO(i);
+        //     }
+        //     REQUIRE(1 == 2);
+        //     // REQUIRE(load_vec(data.dump(), 0) == example_vector{64, 65,
+        //     66});
+        // }
+        // SECTION("Empty last")
+        // {
+        //     FAIL("Fix this test");
+        //     item["value"]["children"] = {35, 560};
+        //     REQUIRE(load_vec(data.dump(), 0) == example_vector{64, 65, 66});
+        // }
+    }
+    SECTION("Mix leaves and inners as children")
+    {
+        auto& children = data["value0"]["inners"][0]["value"]["children"];
+        REQUIRE(children == json_t::array({2, 35}));
+        children = {2, 28};
+        REQUIRE_THROWS_AS(load_vec(data.dump(), 0),
+                          immer_archive::rbts::same_depth_children_exception);
+    }
+    SECTION("Strict vector can't contain relaxed nodes at all")
+    {
+        SECTION("Relaxed root, 0")
+        {
+            auto& inners = data["value0"]["inners"];
+            auto& item   = inners[0]["value"];
+            REQUIRE_FALSE(item["relaxed"]);
+            item["relaxed"] = true;
+            REQUIRE_THROWS_AS(
+                load_vec(data.dump(), 0),
+                immer_archive::rbts::relaxed_node_not_allowed_exception);
+        }
+        SECTION("Relaxed non-root")
+        {
+            auto& inners = data["value0"]["inners"];
+            auto& item   = inners[1]["value"];
+            REQUIRE_FALSE(item["relaxed"]);
+            item["relaxed"] = true;
+            REQUIRE_THROWS_AS(
+                load_vec(data.dump(), 0),
+                immer_archive::rbts::relaxed_node_not_allowed_exception);
+        }
+    }
+    SECTION("Flex vector loads as well")
+    {
+        REQUIRE(load_flex_vec(data.dump(), 0) == gen(example_vector{}, 67));
+
+        auto& inners = data["value0"]["inners"];
+        SECTION("Relaxed 0 can contain non-relaxed")
+        {
+            auto& item = inners[0]["value"];
+            REQUIRE_FALSE(item["relaxed"]);
+            item["relaxed"] = true;
+            REQUIRE(load_flex_vec(data.dump(), 0) == gen(example_vector{}, 67));
+
+            SECTION("Relaxed 0 can contain relaxed 2")
+            {
+                inners[1]["value"]["relaxed"] = true;
+                REQUIRE(load_flex_vec(data.dump(), 0) ==
+                        gen(example_vector{}, 67));
+            }
+        }
+        SECTION("Strict 0 can't contain relaxed 2")
+        {
+            inners[1]["value"]["relaxed"]  = true;
+            inners[1]["value"]["children"] = {3, 4, 5};
+            REQUIRE_THROWS_AS(
+                load_flex_vec(data.dump(), 0),
+                immer_archive::rbts::relaxed_node_not_allowed_exception);
+        }
+    }
+}
+
+TEST_CASE("Exception while loading children")
+{
+    // spdlog::set_level(spdlog::level::trace);
+    json_t data;
+    data["value0"]["leaves"] = {
+        {
+            {"key", 1},
+            {"value", {6, 99}},
+        },
+        {
+            {"key", 2},
+            {"value", {0, 1}},
+        },
+        {
+            {"key", 3},
+            {"value", {2, 3}},
+        },
+        {
+            {"key", 4},
+            {"value", {4, 5}},
+        },
+        {
+            {"key", 5},
+            {"value", {6}},
+        },
+    };
+    data["value0"]["inners"] = {
+        {
+            {"key", 0},
+            {
+                "value",
+                {
+                    {"children", {2, 3, 4, 5, 2, 3, 4}},
+                    {"relaxed", true},
+                },
+            },
+        },
+        {
+            {"key", 902},
+            {
+                "value",
+                {
+                    {"children", {5}},
+                    {"relaxed", true},
+                },
+            },
+        },
+    };
+    data["value0"]["vectors"] = {
+        {
+            {"root", 0},
+            {"tail", 1},
+        },
+    };
+
+    auto& children = data["value0"]["inners"][0]["value"]["children"];
+    REQUIRE(children == json_t::array({2, 3, 4, 5, 2, 3, 4}));
+    children = {2, 3, 4, 902, 4};
+    REQUIRE_THROWS_AS(load_flex_vec(data.dump(), 0),
+                      immer_archive::rbts::same_depth_children_exception);
+}
+
+TEST_CASE("Test flex vector with a weird shape relaxed")
+{
+    json_t data;
+    data["value0"]["leaves"] = {
+        {{"key", 1}, {"value", {66}}},
+        {{"key", 36}, {"value", {64, 65}}},
+    };
+    data["value0"]["inners"] = {
+        {{"key", 0}, {"value", {{"children", {35}}, {"relaxed", true}}}},
+        {{"key", 35}, {"value", {{"children", {36}}, {"relaxed", true}}}},
+    };
+    data["value0"]["vectors"] = {
+        {
+            {"root", 0},
+            {"tail", 1},
+        },
+    };
+
+    const auto loaded = load_flex_vec(data.dump(), 0);
+    // {
+    //     auto ar        = immer_archive::rbts::make_save_archive_for(loaded);
+    //     auto vector_id = immer_archive::node_id{};
+    //     std::tie(ar, vector_id) =
+    //         immer_archive::rbts::save_to_archive(loaded, ar);
+    //     SPDLOG_INFO("{}", test::to_json(ar));
+    // }
+
+    const auto expected = example_vector{64, 65, 66};
+
+    // Test iteration over the loaded vector
+    {
+        const auto rebuilt = example_vector{loaded.begin(), loaded.end()};
+        REQUIRE(rebuilt == expected);
+    }
+
+    REQUIRE(loaded == expected);
+}
+
+TEST_CASE("Test flex vector with a weird shape strict", "[.broken]")
+{
+    json_t data;
+    data["value0"]["leaves"] = {
+        {{"key", 1}, {"value", {66}}},
+        {{"key", 36}, {"value", {64, 65}}},
+    };
+    data["value0"]["inners"] = {
+        {{"key", 0}, {"value", {{"children", {35}}, {"relaxed", false}}}},
+        {{"key", 35}, {"value", {{"children", {36}}, {"relaxed", false}}}},
+    };
+    data["value0"]["vectors"] = {
+        {{"root", 0}, {"tail", 1}},
+    };
+
+    const auto loaded = load_flex_vec(data.dump(), 0);
+    // {
+    //     auto ar        = immer_archive::rbts::make_save_archive_for(loaded);
+    //     auto vector_id = immer_archive::node_id{};
+    //     std::tie(ar, vector_id) =
+    //         immer_archive::rbts::save_to_archive(loaded, ar);
+    //     SPDLOG_INFO("{}", test::to_json(ar));
+    // }
+
+    const auto expected = example_vector{64, 65, 66};
+
+    // Test iteration over the loaded vector
+    {
+        const auto rebuilt = example_vector{loaded.begin(), loaded.end()};
+        REQUIRE(rebuilt == expected);
+    }
+
+    REQUIRE(loaded == expected);
+}
+
+TEST_CASE("Flex vector converted from strict")
+{
+    /**
+     * 1. Save a normal vector
+     * 2. Convert into flex and save again. This is no-op and the ID is the same
+     * as before.
+     * 3. Consequently, you can load any normal vector as a flex-vector
+     */
+    const auto small_vec      = gen(test::vector_one<int>{}, 67);
+    const auto small_flex_vec = test::flex_vector_one<int>{small_vec};
+
+    auto ar           = immer_archive::rbts::make_save_archive_for(small_vec);
+    auto small_vec_id = immer_archive::container_id{};
+    auto small_flex_vec_id = immer_archive::container_id{};
+
+    SECTION("First save strict")
+    {
+        std::tie(ar, small_vec_id)      = save_to_archive(small_vec, ar);
+        std::tie(ar, small_flex_vec_id) = save_to_archive(small_flex_vec, ar);
+    }
+    SECTION("First save flex")
+    {
+        std::tie(ar, small_flex_vec_id) = save_to_archive(small_flex_vec, ar);
+        std::tie(ar, small_vec_id)      = save_to_archive(small_vec, ar);
+    }
+
+    // The id is the same
+    REQUIRE(small_flex_vec_id == small_vec_id);
+
+    // Can be loaded either way, as flex or normal
+    {
+        auto loader_flex = make_loader_for(small_flex_vec, fix_leaf_nodes(ar));
+        REQUIRE(small_flex_vec == loader_flex.load(small_flex_vec_id));
+    }
+    {
+        auto loader = make_loader_for(small_vec, fix_leaf_nodes(ar));
+        REQUIRE(small_vec == loader.load(small_vec_id));
+    }
+}
+
+TEST_CASE("Can't load saved flex vector with relaxed nodes as strict")
+{
+    const auto small_vec = gen(test::flex_vector_one<int>{}, 67);
+    const auto vec       = small_vec + small_vec;
+    auto ar              = immer_archive::rbts::make_save_archive_for(vec);
+    auto vec_id          = immer_archive::container_id{};
+
+    std::tie(ar, vec_id) = save_to_archive(vec, ar);
+    SECTION("Flex loads well")
+    {
+        auto loader_flex =
+            make_loader_for(test::flex_vector_one<int>{}, fix_leaf_nodes(ar));
+        REQUIRE(vec == loader_flex.load(vec_id));
+    }
+    SECTION("Strict can't load")
+    {
+        auto loader =
+            make_loader_for(test::vector_one<int>{}, fix_leaf_nodes(ar));
+        REQUIRE_THROWS_AS(
+            loader.load(vec_id),
+            immer_archive::rbts::relaxed_node_not_allowed_exception);
+    }
+}
diff --git a/test/experimental/immer-archive/test_xxhash.cpp b/test/experimental/immer-archive/test_xxhash.cpp
new file mode 100644
index 00000000..3b9120af
--- /dev/null
+++ b/test/experimental/immer-archive/test_xxhash.cpp
@@ -0,0 +1,1331 @@
+#include <catch2/catch_test_macros.hpp>
+
+#include <immer/experimental/immer-archive/xxhash/xxhash.hpp>
+
+#include <fmt/format.h>
+#include <immer/experimental/immer-archive/champ/traits.hpp>
+#include <xxhash.h>
+
+#include "utils.hpp"
+#include <nlohmann/json.hpp>
+
+namespace {
+const auto gen_map = [](auto map, int count) {
+    for (int i = 0; i < count; ++i) {
+        map = std::move(map).set(fmt::format("key_{}_", i),
+                                 fmt::format("value_{}_", i));
+    }
+    return map;
+};
+}
+
+TEST_CASE("Test hash strings")
+{
+    auto str = std::string{};
+    REQUIRE(immer_archive::xx_hash<std::string>{}(str) == 3244421341483603138);
+    REQUIRE(XXH3_64bits(str.c_str(), str.size()) == 3244421341483603138);
+
+    str = "hello";
+    REQUIRE(immer_archive::xx_hash<std::string>{}(str) ==
+            10760762337991515389UL);
+    REQUIRE(XXH3_64bits(str.c_str(), str.size()) == 10760762337991515389UL);
+}
+
+TEST_CASE("Test loading a big map saved on macOS with std::hash", "[.macos]")
+{
+    using Container = immer::map<std::string, std::string>;
+
+    const auto set          = gen_map(Container{}, 200);
+    const auto [ar, set_id] = immer_archive::champ::save_to_archive(set, {});
+    const auto ar_str       = test::to_json(ar);
+    // REQUIRE(ar_str == "");
+    const auto expected_json = R"({
+  "value0": [
+    {
+      "values": [],
+      "children": [
+        1,
+        3,
+        5,
+        7,
+        9,
+        11,
+        12,
+        13,
+        14,
+        15,
+        17,
+        18,
+        19,
+        20,
+        22,
+        24,
+        25,
+        27,
+        30,
+        31,
+        32,
+        35,
+        37,
+        38,
+        39,
+        40,
+        41,
+        42,
+        43,
+        44,
+        45,
+        46
+      ],
+      "nodemap": 4294967295,
+      "datamap": 0,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_7_", "second": "value_7_"},
+        {"first": "key_78_", "second": "value_78_"},
+        {"first": "key_189_", "second": "value_189_"},
+        {"first": "key_76_", "second": "value_76_"}
+      ],
+      "children": [2],
+      "nodemap": 1048576,
+      "datamap": 67842,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_65_", "second": "value_65_"},
+        {"first": "key_8_", "second": "value_8_"}
+      ],
+      "children": [],
+      "nodemap": 0,
+      "datamap": 33,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_49_", "second": "value_49_"},
+        {"first": "key_77_", "second": "value_77_"},
+        {"first": "key_62_", "second": "value_62_"},
+        {"first": "key_119_", "second": "value_119_"},
+        {"first": "key_129_", "second": "value_129_"},
+        {"first": "key_105_", "second": "value_105_"},
+        {"first": "key_151_", "second": "value_151_"},
+        {"first": "key_144_", "second": "value_144_"}
+      ],
+      "children": [4],
+      "nodemap": 256,
+      "datamap": 140947456,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_174_", "second": "value_174_"},
+        {"first": "key_193_", "second": "value_193_"}
+      ],
+      "children": [],
+      "nodemap": 0,
+      "datamap": 1536,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_124_", "second": "value_124_"},
+        {"first": "key_40_", "second": "value_40_"},
+        {"first": "key_118_", "second": "value_118_"},
+        {"first": "key_134_", "second": "value_134_"},
+        {"first": "key_153_", "second": "value_153_"},
+        {"first": "key_194_", "second": "value_194_"},
+        {"first": "key_143_", "second": "value_143_"}
+      ],
+      "children": [6],
+      "nodemap": 33554432,
+      "datamap": 1704368,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_155_", "second": "value_155_"},
+        {"first": "key_9_", "second": "value_9_"},
+        {"first": "key_69_", "second": "value_69_"}
+      ],
+      "children": [],
+      "nodemap": 0,
+      "datamap": 1077938176,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_74_", "second": "value_74_"},
+        {"first": "key_188_", "second": "value_188_"},
+        {"first": "key_52_", "second": "value_52_"},
+        {"first": "key_140_", "second": "value_140_"},
+        {"first": "key_163_", "second": "value_163_"},
+        {"first": "key_166_", "second": "value_166_"}
+      ],
+      "children": [8],
+      "nodemap": 134217728,
+      "datamap": 85985376,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_36_", "second": "value_36_"},
+        {"first": "key_106_", "second": "value_106_"}
+      ],
+      "children": [],
+      "nodemap": 0,
+      "datamap": 1088,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_111_", "second": "value_111_"},
+        {"first": "key_26_", "second": "value_26_"},
+        {"first": "key_192_", "second": "value_192_"},
+        {"first": "key_70_", "second": "value_70_"}
+      ],
+      "children": [10],
+      "nodemap": 134217728,
+      "datamap": 200768,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_45_", "second": "value_45_"},
+        {"first": "key_31_", "second": "value_31_"}
+      ],
+      "children": [],
+      "nodemap": 0,
+      "datamap": 2097160,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_46_", "second": "value_46_"},
+        {"first": "key_115_", "second": "value_115_"},
+        {"first": "key_89_", "second": "value_89_"},
+        {"first": "key_63_", "second": "value_63_"},
+        {"first": "key_91_", "second": "value_91_"}
+      ],
+      "children": [],
+      "nodemap": 0,
+      "datamap": 5263424,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_41_", "second": "value_41_"},
+        {"first": "key_116_", "second": "value_116_"},
+        {"first": "key_16_", "second": "value_16_"},
+        {"first": "key_101_", "second": "value_101_"},
+        {"first": "key_145_", "second": "value_145_"},
+        {"first": "key_110_", "second": "value_110_"},
+        {"first": "key_32_", "second": "value_32_"}
+      ],
+      "children": [],
+      "nodemap": 0,
+      "datamap": 36243840,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_182_", "second": "value_182_"},
+        {"first": "key_73_", "second": "value_73_"},
+        {"first": "key_59_", "second": "value_59_"},
+        {"first": "key_113_", "second": "value_113_"},
+        {"first": "key_43_", "second": "value_43_"},
+        {"first": "key_161_", "second": "value_161_"},
+        {"first": "key_53_", "second": "value_53_"},
+        {"first": "key_94_", "second": "value_94_"},
+        {"first": "key_57_", "second": "value_57_"},
+        {"first": "key_114_", "second": "value_114_"}
+      ],
+      "children": [],
+      "nodemap": 0,
+      "datamap": 2151301236,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_15_", "second": "value_15_"},
+        {"first": "key_177_", "second": "value_177_"},
+        {"first": "key_172_", "second": "value_172_"},
+        {"first": "key_96_", "second": "value_96_"},
+        {"first": "key_139_", "second": "value_139_"},
+        {"first": "key_132_", "second": "value_132_"}
+      ],
+      "children": [],
+      "nodemap": 0,
+      "datamap": 4203153,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_33_", "second": "value_33_"},
+        {"first": "key_183_", "second": "value_183_"},
+        {"first": "key_122_", "second": "value_122_"}
+      ],
+      "children": [16],
+      "nodemap": 32,
+      "datamap": 73984,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_156_", "second": "value_156_"},
+        {"first": "key_37_", "second": "value_37_"}
+      ],
+      "children": [],
+      "nodemap": 0,
+      "datamap": 1088,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_130_", "second": "value_130_"},
+        {"first": "key_79_", "second": "value_79_"},
+        {"first": "key_180_", "second": "value_180_"}
+      ],
+      "children": [],
+      "nodemap": 0,
+      "datamap": 16912384,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_197_", "second": "value_197_"},
+        {"first": "key_157_", "second": "value_157_"},
+        {"first": "key_85_", "second": "value_85_"},
+        {"first": "key_11_", "second": "value_11_"},
+        {"first": "key_0_", "second": "value_0_"},
+        {"first": "key_86_", "second": "value_86_"},
+        {"first": "key_104_", "second": "value_104_"}
+      ],
+      "children": [],
+      "nodemap": 0,
+      "datamap": 1610648610,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_147_", "second": "value_147_"},
+        {"first": "key_125_", "second": "value_125_"},
+        {"first": "key_127_", "second": "value_127_"},
+        {"first": "key_58_", "second": "value_58_"},
+        {"first": "key_39_", "second": "value_39_"},
+        {"first": "key_149_", "second": "value_149_"},
+        {"first": "key_178_", "second": "value_178_"}
+      ],
+      "children": [],
+      "nodemap": 0,
+      "datamap": 1610884,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_103_", "second": "value_103_"},
+        {"first": "key_176_", "second": "value_176_"},
+        {"first": "key_123_", "second": "value_123_"},
+        {"first": "key_199_", "second": "value_199_"},
+        {"first": "key_56_", "second": "value_56_"},
+        {"first": "key_148_", "second": "value_148_"}
+      ],
+      "children": [21],
+      "nodemap": 536870912,
+      "datamap": 92275203,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_169_", "second": "value_169_"},
+        {"first": "key_109_", "second": "value_109_"}
+      ],
+      "children": [],
+      "nodemap": 0,
+      "datamap": 33558528,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_34_", "second": "value_34_"},
+        {"first": "key_2_", "second": "value_2_"},
+        {"first": "key_28_", "second": "value_28_"},
+        {"first": "key_179_", "second": "value_179_"},
+        {"first": "key_171_", "second": "value_171_"},
+        {"first": "key_162_", "second": "value_162_"}
+      ],
+      "children": [23],
+      "nodemap": 32768,
+      "datamap": 68436040,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_88_", "second": "value_88_"},
+        {"first": "key_84_", "second": "value_84_"}
+      ],
+      "children": [],
+      "nodemap": 0,
+      "datamap": 16777220,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_93_", "second": "value_93_"},
+        {"first": "key_186_", "second": "value_186_"},
+        {"first": "key_121_", "second": "value_121_"},
+        {"first": "key_181_", "second": "value_181_"},
+        {"first": "key_175_", "second": "value_175_"}
+      ],
+      "children": [],
+      "nodemap": 0,
+      "datamap": 1610655744,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_13_", "second": "value_13_"},
+        {"first": "key_64_", "second": "value_64_"},
+        {"first": "key_128_", "second": "value_128_"},
+        {"first": "key_5_", "second": "value_5_"},
+        {"first": "key_138_", "second": "value_138_"},
+        {"first": "key_117_", "second": "value_117_"},
+        {"first": "key_54_", "second": "value_54_"},
+        {"first": "key_72_", "second": "value_72_"}
+      ],
+      "children": [26],
+      "nodemap": 65536,
+      "datamap": 378537000,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_154_", "second": "value_154_"},
+        {"first": "key_14_", "second": "value_14_"}
+      ],
+      "children": [],
+      "nodemap": 0,
+      "datamap": 268436480,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_120_", "second": "value_120_"},
+        {"first": "key_20_", "second": "value_20_"},
+        {"first": "key_1_", "second": "value_1_"},
+        {"first": "key_195_", "second": "value_195_"}
+      ],
+      "children": [28, 29],
+      "nodemap": 4202496,
+      "datamap": 25296897,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_4_", "second": "value_4_"},
+        {"first": "key_165_", "second": "value_165_"}
+      ],
+      "children": [],
+      "nodemap": 0,
+      "datamap": 134217984,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_80_", "second": "value_80_"},
+        {"first": "key_87_", "second": "value_87_"}
+      ],
+      "children": [],
+      "nodemap": 0,
+      "datamap": 1074790400,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_185_", "second": "value_185_"},
+        {"first": "key_42_", "second": "value_42_"}
+      ],
+      "children": [],
+      "nodemap": 0,
+      "datamap": 49152,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_136_", "second": "value_136_"},
+        {"first": "key_112_", "second": "value_112_"},
+        {"first": "key_29_", "second": "value_29_"}
+      ],
+      "children": [],
+      "nodemap": 0,
+      "datamap": 1077936256,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_97_", "second": "value_97_"},
+        {"first": "key_17_", "second": "value_17_"},
+        {"first": "key_61_", "second": "value_61_"},
+        {"first": "key_66_", "second": "value_66_"},
+        {"first": "key_19_", "second": "value_19_"},
+        {"first": "key_108_", "second": "value_108_"},
+        {"first": "key_141_", "second": "value_141_"},
+        {"first": "key_184_", "second": "value_184_"},
+        {"first": "key_187_", "second": "value_187_"}
+      ],
+      "children": [33],
+      "nodemap": 512,
+      "datamap": 10285057,
+      "collisions": false
+    },
+    {
+      "values": [],
+      "children": [34],
+      "nodemap": 2,
+      "datamap": 0,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_75_", "second": "value_75_"},
+        {"first": "key_100_", "second": "value_100_"}
+      ],
+      "children": [],
+      "nodemap": 0,
+      "datamap": 2151677952,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_196_", "second": "value_196_"},
+        {"first": "key_167_", "second": "value_167_"},
+        {"first": "key_160_", "second": "value_160_"},
+        {"first": "key_50_", "second": "value_50_"},
+        {"first": "key_164_", "second": "value_164_"},
+        {"first": "key_27_", "second": "value_27_"}
+      ],
+      "children": [36],
+      "nodemap": 4194304,
+      "datamap": 2150105155,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_21_", "second": "value_21_"},
+        {"first": "key_18_", "second": "value_18_"}
+      ],
+      "children": [],
+      "nodemap": 0,
+      "datamap": 8519680,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_95_", "second": "value_95_"},
+        {"first": "key_83_", "second": "value_83_"},
+        {"first": "key_170_", "second": "value_170_"}
+      ],
+      "children": [],
+      "nodemap": 0,
+      "datamap": 2099204,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_92_", "second": "value_92_"},
+        {"first": "key_55_", "second": "value_55_"}
+      ],
+      "children": [],
+      "nodemap": 0,
+      "datamap": 258,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_6_", "second": "value_6_"},
+        {"first": "key_60_", "second": "value_60_"},
+        {"first": "key_99_", "second": "value_99_"},
+        {"first": "key_150_", "second": "value_150_"}
+      ],
+      "children": [],
+      "nodemap": 0,
+      "datamap": 270532737,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_48_", "second": "value_48_"},
+        {"first": "key_98_", "second": "value_98_"},
+        {"first": "key_131_", "second": "value_131_"},
+        {"first": "key_24_", "second": "value_24_"},
+        {"first": "key_68_", "second": "value_68_"},
+        {"first": "key_51_", "second": "value_51_"}
+      ],
+      "children": [],
+      "nodemap": 0,
+      "datamap": 235012624,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_173_", "second": "value_173_"},
+        {"first": "key_135_", "second": "value_135_"},
+        {"first": "key_142_", "second": "value_142_"},
+        {"first": "key_12_", "second": "value_12_"}
+      ],
+      "children": [],
+      "nodemap": 0,
+      "datamap": 270532611,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_44_", "second": "value_44_"},
+        {"first": "key_47_", "second": "value_47_"},
+        {"first": "key_10_", "second": "value_10_"},
+        {"first": "key_30_", "second": "value_30_"},
+        {"first": "key_146_", "second": "value_146_"},
+        {"first": "key_38_", "second": "value_38_"}
+      ],
+      "children": [],
+      "nodemap": 0,
+      "datamap": 109086728,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_82_", "second": "value_82_"},
+        {"first": "key_102_", "second": "value_102_"},
+        {"first": "key_81_", "second": "value_81_"},
+        {"first": "key_190_", "second": "value_190_"}
+      ],
+      "children": [],
+      "nodemap": 0,
+      "datamap": 2164391938,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_133_", "second": "value_133_"},
+        {"first": "key_3_", "second": "value_3_"},
+        {"first": "key_22_", "second": "value_22_"},
+        {"first": "key_25_", "second": "value_25_"},
+        {"first": "key_35_", "second": "value_35_"},
+        {"first": "key_168_", "second": "value_168_"},
+        {"first": "key_126_", "second": "value_126_"},
+        {"first": "key_158_", "second": "value_158_"},
+        {"first": "key_191_", "second": "value_191_"}
+      ],
+      "children": [],
+      "nodemap": 0,
+      "datamap": 564425,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_71_", "second": "value_71_"},
+        {"first": "key_107_", "second": "value_107_"},
+        {"first": "key_90_", "second": "value_90_"},
+        {"first": "key_137_", "second": "value_137_"}
+      ],
+      "children": [],
+      "nodemap": 0,
+      "datamap": 1073774721,
+      "collisions": false
+    },
+    {
+      "values": [
+        {"first": "key_159_", "second": "value_159_"},
+        {"first": "key_152_", "second": "value_152_"},
+        {"first": "key_67_", "second": "value_67_"},
+        {"first": "key_23_", "second": "value_23_"},
+        {"first": "key_198_", "second": "value_198_"}
+      ],
+      "children": [],
+      "nodemap": 0,
+      "datamap": 344208,
+      "collisions": false
+    }
+  ]
+})";
+    const auto expected      = nlohmann::json::parse(expected_json);
+    const auto actual        = nlohmann::json::parse(ar_str);
+    REQUIRE(expected == actual);
+
+    const auto loaded_archive = test::from_json<
+        immer_archive::champ::container_archive_load<Container>>(ar_str);
+
+    auto loader       = immer_archive::champ::container_loader{loaded_archive};
+    const auto loaded = loader.load(set_id);
+    REQUIRE(loaded == set);
+}
+
+TEST_CASE("Test loading a big map with xxHash")
+{
+    using Container = immer::
+        map<std::string, std::string, immer_archive::xx_hash<std::string>>;
+
+    const auto set           = gen_map(Container{}, 200);
+    const auto [ar, set_id]  = immer_archive::champ::save_to_archive(set, {});
+    const auto ar_str        = test::to_json(ar);
+    const auto expected_json = R"({
+  "value0": [
+      {
+        "values": [],
+        "children": [
+          1,
+          2,
+          4,
+          5,
+          7,
+          9,
+          11,
+          13,
+          14,
+          16,
+          17,
+          21,
+          23,
+          27,
+          28,
+          29,
+          31,
+          32,
+          33,
+          35,
+          36,
+          38,
+          39,
+          40,
+          43,
+          44,
+          45,
+          46,
+          47,
+          48,
+          50
+        ],
+        "nodemap": 4294934527,
+        "datamap": 0,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_95_", "second": "value_95_"},
+          {"first": "key_29_", "second": "value_29_"},
+          {"first": "key_41_", "second": "value_41_"},
+          {"first": "key_31_", "second": "value_31_"},
+          {"first": "key_53_", "second": "value_53_"},
+          {"first": "key_116_", "second": "value_116_"}
+        ],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 2153783392,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_4_", "second": "value_4_"},
+          {"first": "key_0_", "second": "value_0_"},
+          {"first": "key_160_", "second": "value_160_"},
+          {"first": "key_190_", "second": "value_190_"},
+          {"first": "key_98_", "second": "value_98_"},
+          {"first": "key_117_", "second": "value_117_"},
+          {"first": "key_17_", "second": "value_17_"}
+        ],
+        "children": [3],
+        "nodemap": 16384,
+        "datamap": 17957728,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_83_", "second": "value_83_"},
+          {"first": "key_128_", "second": "value_128_"},
+          {"first": "key_66_", "second": "value_66_"}
+        ],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 805830656,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_155_", "second": "value_155_"},
+          {"first": "key_14_", "second": "value_14_"},
+          {"first": "key_132_", "second": "value_132_"},
+          {"first": "key_86_", "second": "value_86_"},
+          {"first": "key_19_", "second": "value_19_"},
+          {"first": "key_119_", "second": "value_119_"}
+        ],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 203686401,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_69_", "second": "value_69_"},
+          {"first": "key_104_", "second": "value_104_"},
+          {"first": "key_193_", "second": "value_193_"},
+          {"first": "key_101_", "second": "value_101_"},
+          {"first": "key_65_", "second": "value_65_"},
+          {"first": "key_189_", "second": "value_189_"}
+        ],
+        "children": [6],
+        "nodemap": 131072,
+        "datamap": 557858976,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_167_", "second": "value_167_"},
+          {"first": "key_145_", "second": "value_145_"}
+        ],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 320,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_44_", "second": "value_44_"},
+          {"first": "key_184_", "second": "value_184_"},
+          {"first": "key_72_", "second": "value_72_"},
+          {"first": "key_2_", "second": "value_2_"},
+          {"first": "key_27_", "second": "value_27_"},
+          {"first": "key_196_", "second": "value_196_"},
+          {"first": "key_179_", "second": "value_179_"}
+        ],
+        "children": [8],
+        "nodemap": 16,
+        "datamap": 272996,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_118_", "second": "value_118_"},
+          {"first": "key_78_", "second": "value_78_"}
+        ],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 528,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_105_", "second": "value_105_"},
+          {"first": "key_158_", "second": "value_158_"},
+          {"first": "key_168_", "second": "value_168_"},
+          {"first": "key_87_", "second": "value_87_"},
+          {"first": "key_180_", "second": "value_180_"},
+          {"first": "key_24_", "second": "value_24_"}
+        ],
+        "children": [10],
+        "nodemap": 16,
+        "datamap": 1074930180,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_20_", "second": "value_20_"},
+          {"first": "key_174_", "second": "value_174_"}
+        ],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 33554688,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_131_", "second": "value_131_"},
+          {"first": "key_114_", "second": "value_114_"},
+          {"first": "key_8_", "second": "value_8_"},
+          {"first": "key_18_", "second": "value_18_"},
+          {"first": "key_134_", "second": "value_134_"},
+          {"first": "key_7_", "second": "value_7_"},
+          {"first": "key_135_", "second": "value_135_"},
+          {"first": "key_46_", "second": "value_46_"},
+          {"first": "key_150_", "second": "value_150_"}
+        ],
+        "children": [12],
+        "nodemap": 4096,
+        "datamap": 92852,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_185_", "second": "value_185_"},
+          {"first": "key_99_", "second": "value_99_"}
+        ],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 2101248,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_13_", "second": "value_13_"},
+          {"first": "key_154_", "second": "value_154_"},
+          {"first": "key_151_", "second": "value_151_"},
+          {"first": "key_93_", "second": "value_93_"},
+          {"first": "key_175_", "second": "value_175_"},
+          {"first": "key_9_", "second": "value_9_"},
+          {"first": "key_74_", "second": "value_74_"}
+        ],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 18057224,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_25_", "second": "value_25_"},
+          {"first": "key_52_", "second": "value_52_"},
+          {"first": "key_26_", "second": "value_26_"},
+          {"first": "key_166_", "second": "value_166_"},
+          {"first": "key_109_", "second": "value_109_"},
+          {"first": "key_81_", "second": "value_81_"}
+        ],
+        "children": [15],
+        "nodemap": 512,
+        "datamap": 2751864832,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_103_", "second": "value_103_"},
+          {"first": "key_115_", "second": "value_115_"}
+        ],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 262148,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_39_", "second": "value_39_"},
+          {"first": "key_177_", "second": "value_177_"},
+          {"first": "key_30_", "second": "value_30_"}
+        ],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 68157696,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_136_", "second": "value_136_"},
+          {"first": "key_126_", "second": "value_126_"},
+          {"first": "key_76_", "second": "value_76_"},
+          {"first": "key_169_", "second": "value_169_"},
+          {"first": "key_1_", "second": "value_1_"}
+        ],
+        "children": [18, 20],
+        "nodemap": 96,
+        "datamap": 67191304,
+        "collisions": false
+      },
+      {
+        "values": [],
+        "children": [19],
+        "nodemap": 33554432,
+        "datamap": 0,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_57_", "second": "value_57_"},
+          {"first": "key_48_", "second": "value_48_"}
+        ],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 3221225472,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_5_", "second": "value_5_"},
+          {"first": "key_171_", "second": "value_171_"}
+        ],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 2164260864,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_23_", "second": "value_23_"},
+          {"first": "key_97_", "second": "value_97_"},
+          {"first": "key_125_", "second": "value_125_"},
+          {"first": "key_182_", "second": "value_182_"},
+          {"first": "key_55_", "second": "value_55_"},
+          {"first": "key_121_", "second": "value_121_"},
+          {"first": "key_34_", "second": "value_34_"}
+        ],
+        "children": [22],
+        "nodemap": 65536,
+        "datamap": 1413515268,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_170_", "second": "value_170_"},
+          {"first": "key_73_", "second": "value_73_"}
+        ],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 536887296,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_198_", "second": "value_198_"},
+          {"first": "key_197_", "second": "value_197_"},
+          {"first": "key_172_", "second": "value_172_"},
+          {"first": "key_140_", "second": "value_140_"},
+          {"first": "key_162_", "second": "value_162_"}
+        ],
+        "children": [24, 25],
+        "nodemap": 67108872,
+        "datamap": 17039427,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_32_", "second": "value_32_"},
+          {"first": "key_111_", "second": "value_111_"}
+        ],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 33554688,
+        "collisions": false
+      },
+      {
+        "values": [],
+        "children": [26],
+        "nodemap": 1048576,
+        "datamap": 0,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_127_", "second": "value_127_"},
+          {"first": "key_181_", "second": "value_181_"}
+        ],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 131074,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_100_", "second": "value_100_"},
+          {"first": "key_149_", "second": "value_149_"},
+          {"first": "key_94_", "second": "value_94_"}
+        ],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 268501000,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_75_", "second": "value_75_"},
+          {"first": "key_164_", "second": "value_164_"},
+          {"first": "key_37_", "second": "value_37_"}
+        ],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 134479874,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_28_", "second": "value_28_"},
+          {"first": "key_148_", "second": "value_148_"},
+          {"first": "key_89_", "second": "value_89_"}
+        ],
+        "children": [30],
+        "nodemap": 67108864,
+        "datamap": 1082138624,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_143_", "second": "value_143_"},
+          {"first": "key_42_", "second": "value_42_"}
+        ],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 536871424,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_152_", "second": "value_152_"},
+          {"first": "key_33_", "second": "value_33_"},
+          {"first": "key_67_", "second": "value_67_"},
+          {"first": "key_153_", "second": "value_153_"}
+        ],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 1441800,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_102_", "second": "value_102_"},
+          {"first": "key_120_", "second": "value_120_"},
+          {"first": "key_59_", "second": "value_59_"},
+          {"first": "key_51_", "second": "value_51_"},
+          {"first": "key_137_", "second": "value_137_"},
+          {"first": "key_54_", "second": "value_54_"}
+        ],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 1881276420,
+        "collisions": false
+      },
+      {
+        "values": [{"first": "key_91_", "second": "value_91_"}],
+        "children": [34],
+        "nodemap": 32768,
+        "datamap": 32,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_10_", "second": "value_10_"},
+          {"first": "key_141_", "second": "value_141_"}
+        ],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 33554496,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_77_", "second": "value_77_"},
+          {"first": "key_68_", "second": "value_68_"},
+          {"first": "key_38_", "second": "value_38_"},
+          {"first": "key_156_", "second": "value_156_"},
+          {"first": "key_85_", "second": "value_85_"},
+          {"first": "key_133_", "second": "value_133_"},
+          {"first": "key_61_", "second": "value_61_"}
+        ],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 637599906,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_6_", "second": "value_6_"},
+          {"first": "key_3_", "second": "value_3_"},
+          {"first": "key_112_", "second": "value_112_"},
+          {"first": "key_110_", "second": "value_110_"},
+          {"first": "key_62_", "second": "value_62_"},
+          {"first": "key_195_", "second": "value_195_"},
+          {"first": "key_92_", "second": "value_92_"},
+          {"first": "key_107_", "second": "value_107_"},
+          {"first": "key_50_", "second": "value_50_"}
+        ],
+        "children": [37],
+        "nodemap": 524288,
+        "datamap": 1636838404,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_199_", "second": "value_199_"},
+          {"first": "key_58_", "second": "value_58_"}
+        ],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 8388736,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_70_", "second": "value_70_"},
+          {"first": "key_191_", "second": "value_191_"}
+        ],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 2105344,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_113_", "second": "value_113_"},
+          {"first": "key_21_", "second": "value_21_"},
+          {"first": "key_146_", "second": "value_146_"},
+          {"first": "key_22_", "second": "value_22_"},
+          {"first": "key_16_", "second": "value_16_"}
+        ],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 67117201,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_15_", "second": "value_15_"},
+          {"first": "key_108_", "second": "value_108_"},
+          {"first": "key_84_", "second": "value_84_"}
+        ],
+        "children": [41, 42],
+        "nodemap": 2097184,
+        "datamap": 12582920,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_188_", "second": "value_188_"},
+          {"first": "key_130_", "second": "value_130_"}
+        ],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 276824064,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_64_", "second": "value_64_"},
+          {"first": "key_165_", "second": "value_165_"}
+        ],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 1081344,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_139_", "second": "value_139_"},
+          {"first": "key_96_", "second": "value_96_"},
+          {"first": "key_43_", "second": "value_43_"}
+        ],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 2147483968,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_178_", "second": "value_178_"},
+          {"first": "key_106_", "second": "value_106_"},
+          {"first": "key_88_", "second": "value_88_"},
+          {"first": "key_144_", "second": "value_144_"},
+          {"first": "key_138_", "second": "value_138_"},
+          {"first": "key_124_", "second": "value_124_"}
+        ],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 3759145488,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_40_", "second": "value_40_"},
+          {"first": "key_192_", "second": "value_192_"},
+          {"first": "key_56_", "second": "value_56_"},
+          {"first": "key_187_", "second": "value_187_"},
+          {"first": "key_35_", "second": "value_35_"}
+        ],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 16795392,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_159_", "second": "value_159_"},
+          {"first": "key_71_", "second": "value_71_"},
+          {"first": "key_161_", "second": "value_161_"}
+        ],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 2701131776,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_12_", "second": "value_12_"},
+          {"first": "key_183_", "second": "value_183_"},
+          {"first": "key_82_", "second": "value_82_"},
+          {"first": "key_49_", "second": "value_49_"},
+          {"first": "key_80_", "second": "value_80_"},
+          {"first": "key_45_", "second": "value_45_"}
+        ],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 136478768,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_186_", "second": "value_186_"},
+          {"first": "key_90_", "second": "value_90_"},
+          {"first": "key_122_", "second": "value_122_"},
+          {"first": "key_176_", "second": "value_176_"},
+          {"first": "key_129_", "second": "value_129_"},
+          {"first": "key_142_", "second": "value_142_"},
+          {"first": "key_123_", "second": "value_123_"},
+          {"first": "key_11_", "second": "value_11_"},
+          {"first": "key_63_", "second": "value_63_"},
+          {"first": "key_163_", "second": "value_163_"}
+        ],
+        "children": [49],
+        "nodemap": 64,
+        "datamap": 1092362778,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_36_", "second": "value_36_"},
+          {"first": "key_79_", "second": "value_79_"}
+        ],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 268468224,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_60_", "second": "value_60_"},
+          {"first": "key_157_", "second": "value_157_"},
+          {"first": "key_47_", "second": "value_47_"},
+          {"first": "key_173_", "second": "value_173_"}
+        ],
+        "children": [51],
+        "nodemap": 64,
+        "datamap": 268962048,
+        "collisions": false
+      },
+      {
+        "values": [
+          {"first": "key_194_", "second": "value_194_"},
+          {"first": "key_147_", "second": "value_147_"}
+        ],
+        "children": [],
+        "nodemap": 0,
+        "datamap": 33562624,
+        "collisions": false
+      }
+    ]
+})";
+    // REQUIRE(ar_str == "");
+    const auto expected = nlohmann::json::parse(expected_json);
+    const auto actual   = nlohmann::json::parse(ar_str);
+    REQUIRE(expected == actual);
+
+    const auto loaded_archive = test::from_json<
+        immer_archive::champ::container_archive_load<Container>>(ar_str);
+
+    auto loader       = immer_archive::champ::container_loader{loaded_archive};
+    const auto loaded = loader.load(set_id);
+    REQUIRE(loaded == set);
+}
diff --git a/test/experimental/immer-archive/utils.hpp b/test/experimental/immer-archive/utils.hpp
new file mode 100644
index 00000000..1a1ec54a
--- /dev/null
+++ b/test/experimental/immer-archive/utils.hpp
@@ -0,0 +1,90 @@
+#pragma once
+
+#include <immer/experimental/immer-archive/rbts/archive.hpp>
+#include <immer/experimental/immer-archive/rbts/load.hpp>
+
+#include <sstream>
+
+#include <cereal/archives/json.hpp>
+#include <cereal/cereal.hpp>
+#include <cereal/types/vector.hpp>
+
+#include <fmt/format.h>
+#include <fmt/ostream.h>
+
+namespace test {
+
+template <class T>
+using vector_one =
+    immer::vector<T, immer::default_memory_policy, immer::default_bits, 1>;
+
+template <class T>
+using flex_vector_one =
+    immer::flex_vector<T, immer::default_memory_policy, immer::default_bits, 1>;
+
+using example_vector      = vector_one<int>;
+using example_flex_vector = flex_vector_one<int>;
+
+using example_archive_save =
+    decltype(immer_archive::rbts::make_save_archive_for(example_vector{}));
+using example_loader = immer_archive::rbts::
+    loader<int, immer::default_memory_policy, immer::default_bits, 1>;
+
+inline auto gen(auto init, int count)
+{
+    for (int i = 0; i < count; ++i) {
+        init = std::move(init).push_back(i);
+    }
+    return init;
+}
+
+template <typename T>
+std::string to_json(const T& serializable)
+{
+    auto os = std::ostringstream{};
+    {
+        auto ar = cereal::JSONOutputArchive{os};
+        ar(serializable);
+    }
+    return os.str();
+}
+
+template <typename T>
+T from_json(std::string input)
+{
+    auto is = std::istringstream{input};
+    auto ar = cereal::JSONInputArchive{is};
+    auto r  = T{};
+    ar(r);
+    return r;
+}
+
+struct test_value
+{
+    std::size_t id;
+    std::string value;
+
+    auto tie() const { return std::tie(id, value); }
+
+    template <class Archive>
+    void serialize(Archive& ar)
+    {
+        ar(CEREAL_NVP(id), CEREAL_NVP(value));
+    }
+
+    friend bool operator==(const test_value& left, const test_value& right)
+    {
+        return left.tie() == right.tie();
+    }
+
+    friend std::ostream& operator<<(std::ostream& s, const test_value& value)
+    {
+        return s << fmt::format("({}, {})", value.id, value.value);
+    }
+};
+
+} // namespace test
+
+template <>
+struct fmt::formatter<test::test_value> : ostream_formatter
+{};
diff --git a/test/experimental/immer-archive/valgrind.supp b/test/experimental/immer-archive/valgrind.supp
new file mode 100644
index 00000000..56067fbe
--- /dev/null
+++ b/test/experimental/immer-archive/valgrind.supp
@@ -0,0 +1,48 @@
+{
+   empty_make_inner_n
+   Memcheck:Leak
+   match-leak-kinds: possible
+   ...
+   fun:make_inner_n
+   fun:empty
+}
+{
+   empty_vector_tail
+   Memcheck:Leak
+   match-leak-kinds: possible
+   ...
+   fun:make_leaf_n
+   fun:empty_tail
+   ...
+   fun:vector
+}
+{
+   empty_vector_root
+   Memcheck:Leak
+   match-leak-kinds: possible
+   ...
+   fun:make_inner_n
+   fun:empty_root
+   ...
+   fun:vector
+}
+{
+   empty_tail_from_initializer_list
+   Memcheck:Leak
+   match-leak-kinds: possible
+   ...
+   fun:make_leaf_n
+   fun:empty_tail
+   ...
+   fun:from_initializer_list*
+}
+{
+   empty_root_from_initializer_list
+   Memcheck:Leak
+   match-leak-kinds: possible
+   ...
+   fun:make_inner_n
+   fun:empty_root
+   ...
+   fun:from_initializer_list*
+}
diff --git a/test/oss-fuzz/data/crash-6698cd314d474bc6d857cf84e4c68d5965dae9e3 b/test/oss-fuzz/data/crash-6698cd314d474bc6d857cf84e4c68d5965dae9e3
new file mode 100644
index 00000000..976b5040
Binary files /dev/null and b/test/oss-fuzz/data/crash-6698cd314d474bc6d857cf84e4c68d5965dae9e3 differ
diff --git a/test/oss-fuzz/flex-vector-st-0.cpp b/test/oss-fuzz/flex-vector-st-0.cpp
new file mode 100644
index 00000000..bd706a8a
--- /dev/null
+++ b/test/oss-fuzz/flex-vector-st-0.cpp
@@ -0,0 +1,271 @@
+//
+// immer: immutable data structures for C++
+// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente
+//
+// This software is distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt
+//
+
+#include "input.hpp"
+
+#include <immer/box.hpp>
+#include <immer/flex_vector.hpp>
+#include <immer/refcount/no_refcount_policy.hpp>
+
+#include <catch2/catch_test_macros.hpp>
+
+#define IMMER_FUZZED_TRACE_ENABLE 0
+
+#if IMMER_FUZZED_TRACE_ENABLE
+#include <fmt/ostream.h>
+#define IMMER_FUZZED_TRACE(...) fmt::print(std::cerr, __VA_ARGS__)
+#else
+#define IMMER_FUZZED_TRACE(...)
+#endif
+
+namespace {
+
+using st_memory = immer::memory_policy<immer::heap_policy<immer::cpp_heap>,
+                                       immer::unsafe_refcount_policy,
+                                       immer::no_lock_policy,
+                                       immer::no_transience_policy,
+                                       false>;
+
+int run_input(const std::uint8_t* data, std::size_t size)
+{
+    constexpr auto var_count = 8;
+    constexpr auto bits      = 3;
+
+    using vector_t = immer::flex_vector<int, st_memory, bits, bits>;
+    using size_t   = std::uint8_t;
+
+    auto vars = std::array<vector_t, var_count>{};
+
+#if IMMER_FUZZED_TRACE_ENABLE
+    IMMER_FUZZED_TRACE("/// new test run\n");
+    IMMER_FUZZED_TRACE(
+        "using vector_t = immer::flex_vector<int, st_memory, {}, {}>;\n",
+        bits,
+        bits);
+    for (auto i = 0u; i < var_count; ++i)
+        IMMER_FUZZED_TRACE("auto v{} = vector_t{{}};\n", i);
+#endif
+
+    auto is_valid_var = [&](auto idx) { return idx >= 0 && idx < var_count; };
+    auto is_valid_var_neq = [](auto other) {
+        return [=](auto idx) {
+            return idx >= 0 && idx < var_count && idx != other;
+        };
+    };
+    auto is_valid_index = [](auto& v) {
+        return [&](auto idx) { return idx >= 0 && idx < v.size(); };
+    };
+    auto is_valid_size = [](auto& v) {
+        return [&](auto idx) { return idx >= 0 && idx <= v.size(); };
+    };
+    auto can_concat = [](const auto& v1, const auto& v2) {
+        // First, check max_size
+        if (v1.size() + v2.size() > vector_t::max_size()) {
+            return false;
+        }
+
+        // But just checking max_size is not sufficient, because there are other
+        // conditions for the validity of the tree, like shift constraints, for
+        // example.
+        try {
+            // Try to concat and catch an exception if it fails
+            const auto v3 = v1 + v2;
+            if (v3.size()) {
+                return true;
+            }
+        } catch (const immer::detail::rbts::invalid_tree&) {
+            return false;
+        }
+        return true;
+    };
+    auto can_compare = [](auto&& v) {
+        // avoid comparing vectors that are too big, and hence, slow to compare
+        return v.size() < (1 << 15);
+    };
+    return fuzzer_input{data, size}.run([&](auto& in) {
+        enum ops
+        {
+            op_push_back,
+            op_update,
+            op_take,
+            op_drop,
+            op_concat,
+            op_push_back_move,
+            op_update_move,
+            op_take_move,
+            op_drop_move,
+            op_concat_move_l,
+            op_concat_move_r,
+            op_concat_move_lr,
+            op_insert,
+            op_erase,
+            op_compare,
+        };
+        auto src = read<char>(in, is_valid_var);
+        auto dst = read<char>(in, is_valid_var);
+        switch (read<char>(in)) {
+        case op_push_back: {
+            IMMER_FUZZED_TRACE("v{} = v{}.push_back(42);\n", +dst, +src);
+            vars[dst] = vars[src].push_back(42);
+            break;
+        }
+        case op_update: {
+            auto idx = read<size_t>(in, is_valid_index(vars[src]));
+            IMMER_FUZZED_TRACE(
+                "v{} = v{}.update({}, [] (auto x) {{ return x + 1; }});\n",
+                +dst,
+                +src,
+                idx);
+            vars[dst] = vars[src].update(idx, [](auto x) { return x + 1; });
+            break;
+        }
+        case op_take: {
+            auto idx = read<size_t>(in, is_valid_size(vars[src]));
+            IMMER_FUZZED_TRACE("v{} = v{}.take({});\n", +dst, +src, idx);
+            vars[dst] = vars[src].take(idx);
+            break;
+        }
+        case op_drop: {
+            auto idx = read<size_t>(in, is_valid_size(vars[src]));
+            IMMER_FUZZED_TRACE("v{} = v{}.drop({});\n", +dst, +src, idx);
+            vars[dst] = vars[src].drop(idx);
+            break;
+        }
+        case op_concat: {
+            auto src2 = read<char>(in, is_valid_var);
+            if (can_concat(vars[src], vars[src2])) {
+                IMMER_FUZZED_TRACE("v{} = v{} + v{};\n", +dst, +src, +src2);
+                vars[dst] = vars[src] + vars[src2];
+            }
+            break;
+        }
+        case op_push_back_move: {
+            IMMER_FUZZED_TRACE(
+                "v{} = std::move(v{}).push_back(21);\n", +dst, +src);
+            vars[dst] = std::move(vars[src]).push_back(21);
+            break;
+        }
+        case op_update_move: {
+            auto idx = read<size_t>(in, is_valid_index(vars[src]));
+            IMMER_FUZZED_TRACE("v{} = std::move(v{}).update({}, [] (auto x) {{ "
+                               "return x + 1; }});\n",
+                               +dst,
+                               +src,
+                               idx);
+            vars[dst] =
+                std::move(vars[src]).update(idx, [](auto x) { return x + 1; });
+            break;
+        }
+        case op_take_move: {
+            auto idx = read<size_t>(in, is_valid_size(vars[src]));
+            IMMER_FUZZED_TRACE(
+                "v{} = std::move(v{}).take({});\n", +dst, +src, idx);
+            vars[dst] = std::move(vars[src]).take(idx);
+            break;
+        }
+        case op_drop_move: {
+            auto idx = read<size_t>(in, is_valid_size(vars[src]));
+            IMMER_FUZZED_TRACE(
+                "v{} = std::move(v{}).drop({});\n", +dst, +src, idx);
+            vars[dst] = std::move(vars[src]).drop(idx);
+            break;
+        }
+        case op_concat_move_l: {
+            auto src2 = read<char>(in, is_valid_var_neq(src));
+            if (can_concat(vars[src], vars[src2])) {
+                IMMER_FUZZED_TRACE(
+                    "v{} = std::move(v{}) + v{};\n", +dst, +src, +src2);
+                vars[dst] = std::move(vars[src]) + vars[src2];
+            }
+            break;
+        }
+        case op_concat_move_r: {
+            auto src2 = read<char>(in, is_valid_var_neq(src));
+            if (can_concat(vars[src], vars[src2])) {
+                IMMER_FUZZED_TRACE(
+                    "v{} = v{} + std::move(v{});\n", +dst, +src, +src2);
+                vars[dst] = vars[src] + std::move(vars[src2]);
+            }
+            break;
+        }
+        case op_concat_move_lr: {
+            auto src2 = read<char>(in, is_valid_var_neq(src));
+            if (can_concat(vars[src], vars[src2])) {
+                IMMER_FUZZED_TRACE("v{} = std::move(v{}) + std::move(v{});\n",
+                                   +dst,
+                                   +src,
+                                   +src2);
+                vars[dst] = std::move(vars[src]) + std::move(vars[src2]);
+            }
+            break;
+        }
+        case op_compare: {
+            using std::swap;
+            if (can_compare(vars[src])) {
+                IMMER_FUZZED_TRACE("if (v{} == v{}) swap(v{}, v{});\n",
+                                   +src,
+                                   +dst,
+                                   +src,
+                                   +dst);
+                if (vars[src] == vars[dst])
+                    swap(vars[src], vars[dst]);
+            }
+            break;
+        }
+        case op_erase: {
+            auto idx = read<size_t>(in, is_valid_index(vars[src]));
+            IMMER_FUZZED_TRACE("v{} = v{}.erase({});\n", +dst, +src, idx);
+            vars[dst] = vars[src].erase(idx);
+            break;
+        }
+        case op_insert: {
+            auto idx = read<size_t>(in, is_valid_size(vars[src]));
+            IMMER_FUZZED_TRACE("v{} = v{}.insert({}, immer::box<int>{{42}});\n",
+                               +dst,
+                               +src,
+                               idx);
+            vars[dst] = vars[src].insert(idx, immer::box<int>{42});
+            break;
+        }
+        default:
+            break;
+        };
+        return true;
+    });
+}
+
+} // namespace
+
+TEST_CASE("some fuzzer crash I don't have a link for")
+{
+    SECTION("fuzzer")
+    {
+        auto input =
+            load_input("crash-6698cd314d474bc6d857cf84e4c68d5965dae9e3");
+        CHECK(run_input(input.data(), input.size()) == 0);
+    }
+}
+
+TEST_CASE("Creating rrbtree with invalid parameters shouldn't terminate but "
+          "should throw")
+{
+    SECTION("Invalid shift")
+    {
+        // assert(shift <= sizeof(size_t) * 8 - BL);
+        // assert(shift >= BL);
+        const auto create = [] {
+            const auto shift = immer::detail::rbts::shift_t{999};
+            return immer::detail::rbts::
+                rrbtree<int, st_memory, immer::default_bits, 1>{
+                    0, shift, nullptr, nullptr};
+        };
+
+        REQUIRE(IMMER_THROW_ON_INVALID_STATE == 1);
+        REQUIRE_THROWS_AS(create(), immer::detail::rbts::invalid_tree);
+    }
+}
diff --git a/test/valgrind_suppress.txt b/test/valgrind_suppress.txt
new file mode 100644
index 00000000..be7394f2
--- /dev/null
+++ b/test/valgrind_suppress.txt
@@ -0,0 +1,28 @@
+{
+  <gc1>
+  Memcheck:Cond
+  fun:GC_*
+}
+{
+  <gc2>
+  Memcheck:Value8
+  fun:GC_*
+}
+{
+  <gc3>
+  Memcheck:Value4
+  fun:GC_*
+}
+{
+  <gc4>
+  Memcheck:Addr4
+  fun:memset
+  fun:GC_stopped_mark
+  fun:GC_try_to_collect_inner
+  fun:GC_init
+}
+{
+   <gc5>
+   Memcheck:Addr4
+   fun:GC_*
+}