diff --git a/include/llama/View.hpp b/include/llama/View.hpp
index cfb73f5d39..9b765f94ca 100644
--- a/include/llama/View.hpp
+++ b/include/llama/View.hpp
@@ -236,6 +236,67 @@ namespace llama
             return std::tuple_cat(
                 asFlatTupleImpl(vd(GetDatumElementTag<Elements>{}), GetDatumElementType<Elements>{})...);
         }
+
+        template <typename T, typename = void>
+        constexpr inline auto isTupleLike = false;
+
+        // get<I>(t) and std::tuple_size<T> must be available
+        using std::get; // make sure a get<0>() can be found, so the compiler can compile the trait
+        template <typename T>
+        constexpr inline auto
+            isTupleLike<T, std::void_t<decltype(get<0>(std::declval<T>())), std::tuple_size<T>>> = true;
+
+        template <typename... Ts>
+        constexpr inline auto dependentFalse = false;
+
+        template <typename Tuple1, typename Tuple2, std::size_t... Is>
+        LLAMA_FN_HOST_ACC_INLINE void assignTuples(Tuple1&& dst, Tuple2&& src, std::index_sequence<Is...>);
+
+        template <typename T1, typename T2>
+        LLAMA_FN_HOST_ACC_INLINE void assignTupleElement(T1&& dst, T2&& src)
+        {
+            if constexpr (isTupleLike<T1> && isTupleLike<T2>)
+            {
+                static_assert(std::tuple_size_v<T1> == std::tuple_size_v<T2>);
+                assignTuples(dst, src, std::make_index_sequence<std::tuple_size_v<T1>>{});
+            }
+            else if constexpr (!isTupleLike<T1> && !isTupleLike<T2>)
+                std::forward<T1>(dst) = std::forward<T2>(src);
+            else
+                static_assert(dependentFalse<T1, T2>, "Elements to assign are not tuple/tuple or non-tuple/non-tuple.");
+        }
+
+        template <typename Tuple1, typename Tuple2, std::size_t... Is>
+        LLAMA_FN_HOST_ACC_INLINE void assignTuples(Tuple1&& dst, Tuple2&& src, std::index_sequence<Is...>)
+        {
+            static_assert(std::tuple_size_v<std::decay_t<Tuple1>> == std::tuple_size_v<std::decay_t<Tuple2>>);
+            using std::get;
+            (assignTupleElement(get<Is>(std::forward<Tuple1>(dst)), get<Is>(std::forward<Tuple2>(src))), ...);
+        }
+
+        template <typename T, typename Tuple, std::size_t... Is>
+        LLAMA_FN_HOST_ACC_INLINE auto makeFromTuple(Tuple&& src, std::index_sequence<Is...>)
+        {
+            using std::get;
+            return T{get<Is>(std::forward<Tuple>(src))...};
+        }
+
+        template <typename T, typename SFINAE, typename... Args>
+        constexpr inline auto isDirectListInitializableImpl = false;
+
+        template <typename T, typename... Args>
+        constexpr inline auto
+            isDirectListInitializableImpl<T, std::void_t<decltype(T{std::declval<Args>()...})>, Args...> = true;
+
+        template <typename T, typename... Args>
+        constexpr inline auto isDirectListInitializable = isDirectListInitializableImpl<T, void, Args...>;
+
+        template <typename T, typename Tuple>
+        constexpr inline auto isDirectListInitializableFromTuple = false;
+
+        template <typename T, template <typename...> typename Tuple, typename... Args>
+        constexpr inline auto
+            isDirectListInitializableFromTuple<T, Tuple<Args...>> = isDirectListInitializable<T, Args...>;
     } // namespace internal
 
     /// Virtual data type returned by \ref View after resolving a user domain
@@ -528,6 +589,68 @@ namespace llama
         {
             return operator()(DatumCoord<I>{});
         }
+
+        template <typename TupleLike>
+        auto loadAs() -> TupleLike
+        {
+            static_assert(
+                internal::isDirectListInitializableFromTuple<TupleLike, decltype(asFlatTuple())>,
+                "TupleLike must be constructible from as many values as this VirtualDatum recursively represents like "
+                "this: TupleLike{values...}");
+            return internal::makeFromTuple<TupleLike>(
+                asFlatTuple(),
+                std::make_index_sequence<std::tuple_size_v<decltype(asFlatTuple())>>{});
+        }
+
+        template <typename TupleLike>
+        auto loadAs() const -> TupleLike
+        {
+            static_assert(
+                internal::isDirectListInitializableFromTuple<TupleLike, decltype(asFlatTuple())>,
+                "TupleLike must be constructible from as many values as this VirtualDatum recursively represents like "
+                "this: TupleLike{values...}");
+            return internal::makeFromTuple<TupleLike>(
+                asFlatTuple(),
+                std::make_index_sequence<std::tuple_size_v<decltype(asFlatTuple())>>{});
+        }
+
+        struct Loader
+        {
+            VirtualDatum& vd;
+
+            template <typename T>
+            operator T()
+            {
+                return vd.loadAs<T>();
+            }
+        };
+
+        struct LoaderConst
+        {
+            const VirtualDatum& vd;
+
+            template <typename T>
+            operator T() const
+            {
+                return vd.loadAs<T>();
+            }
+        };
+
+        auto load() -> Loader
+        {
+            return {*this};
+        }
+
+        auto load() const -> LoaderConst
+        {
+            return {*this};
+        }
+
+        template <typename TupleLike>
+        void store(const TupleLike& t)
+        {
+            internal::assignTuples(asTuple(), t, std::make_index_sequence<std::tuple_size_v<TupleLike>>{});
+        }
     };
 } // namespace llama
 
diff --git a/tests/virtualdatum.cpp b/tests/virtualdatum.cpp
index 460ae00195..2bfe6c0f75 100644
--- a/tests/virtualdatum.cpp
+++ b/tests/virtualdatum.cpp
@@ -617,3 +617,264 @@ TEST_CASE("VirtualDatum.structuredBindings")
         CHECK(datum(tag::Weight{}) == 60);
     }
 }
+
+namespace
+{
+    template <typename T>
+    struct MyPos
+    {
+        T a;
+        T y;
+    };
+
+    template <typename T>
+    struct MyVel
+    {
+        T x;
+        T y;
+        T z;
+    };
+
+    template <typename T>
+    struct MyDatum
+    {
+        MyPos<T> pos;
+        MyVel<T> vel;
+        T weight;
+    };
+
+    template <std::size_t I, typename T>
+    auto get(const MyPos<T>& p)
+    {
+        if constexpr (I == 0)
+            return p.a;
+        if constexpr (I == 1)
+            return p.y;
+    }
+
+    template <std::size_t I, typename T>
+    auto get(const MyVel<T>& p)
+    {
+        if constexpr (I == 0)
+            return p.x;
+        if constexpr (I == 1)
+            return p.y;
+        if constexpr (I == 2)
+            return p.z;
+    }
+
+    template <std::size_t I, typename T>
+    auto get(const MyDatum<T>& p)
+    {
+        if constexpr (I == 0)
+            return p.pos;
+        if constexpr (I == 1)
+            return p.vel;
+        if constexpr (I == 2)
+            return p.weight;
+    }
+} // namespace
+
+template <typename T>
+struct std::tuple_size<MyPos<T>>
+{
+    static constexpr std::size_t value = 2;
+};
+
+template <typename T>
+struct std::tuple_size<MyVel<T>>
+{
+    static constexpr std::size_t value = 3;
+};
+
+template <typename T>
+struct std::tuple_size<MyDatum<T>>
+{
+    static constexpr std::size_t value = 3;
+};
+
+TEST_CASE("VirtualDatum.load.value")
+{
+    llama::One<Name> datum;
+    datum = 1;
+
+    {
+        MyPos<int> pos = datum(tag::Pos{}).load();
+        CHECK(pos.a == 1);
+        CHECK(pos.y == 1);
+    }
+    {
+        MyPos<int> pos = std::as_const(datum)(tag::Pos{}).load();
+        CHECK(pos.a == 1);
+        CHECK(pos.y == 1);
+    }
+
+    {
+        MyDatum<int> d = datum.load();
+        CHECK(d.pos.a == 1);
+        CHECK(d.pos.y == 1);
+        CHECK(d.vel.x == 1);
+        CHECK(d.vel.y == 1);
+        CHECK(d.vel.z == 1);
+        CHECK(d.weight == 1);
+    }
+    {
+        MyDatum<int> d = std::as_const(datum).load();
+        CHECK(d.pos.a == 1);
+        CHECK(d.pos.y == 1);
+        CHECK(d.vel.x == 1);
+        CHECK(d.vel.y == 1);
+        CHECK(d.vel.z == 1);
+        CHECK(d.weight == 1);
+    }
+}
+
+TEST_CASE("VirtualDatum.load.ref")
+{
+    llama::One<Name> datum;
+
+    datum = 1;
+    {
+        MyPos<int&> pos = datum(tag::Pos{}).load();
+        CHECK(pos.a == 1);
+        CHECK(pos.y == 1);
+
+        pos.a = 2;
+        pos.y = 3;
+        CHECK(datum(tag::Pos{}, tag::A{}) == 2);
+        CHECK(datum(tag::Pos{}, tag::Y{}) == 3);
+        CHECK(datum(tag::Vel{}, tag::X{}) == 1);
+        CHECK(datum(tag::Vel{}, tag::Y{}) == 1);
+        CHECK(datum(tag::Vel{}, tag::Z{}) == 1);
+        CHECK(datum(tag::Weight{}) == 1);
+    }
+
+    datum = 1;
+    {
+        MyDatum<int&> d = datum.load();
+        CHECK(d.pos.a == 1);
+        CHECK(d.pos.y == 1);
+
+        d.pos.a = 2;
+        d.pos.y = 3;
+        d.vel.x = 4;
+        d.vel.y = 5;
+        d.vel.z = 6;
+        d.weight = 7;
+        CHECK(datum(tag::Pos{}, tag::A{}) == 2);
+        CHECK(datum(tag::Pos{}, tag::Y{}) == 3);
+        CHECK(datum(tag::Vel{}, tag::X{}) == 4);
+        CHECK(datum(tag::Vel{}, tag::Y{}) == 5);
+        CHECK(datum(tag::Vel{}, tag::Z{}) == 6);
+        CHECK(datum(tag::Weight{}) == 7);
+    }
+}
+
+TEST_CASE("VirtualDatum.load.constref")
+{
+    llama::One<Name> datum;
+    datum = 1;
+
+    {
+        MyPos<const int&> pos = datum(tag::Pos{}).load();
+        CHECK(pos.a == 1);
+        CHECK(pos.y == 1);
+    }
+    {
+        MyPos<const int&> pos = std::as_const(datum)(tag::Pos{}).load();
+        CHECK(pos.a == 1);
+        CHECK(pos.y == 1);
+    }
+    {
+        MyDatum<const int&> d = datum.load();
+        CHECK(d.pos.a == 1);
+        CHECK(d.pos.y == 1);
+    }
+    {
+        MyDatum<const int&> d = std::as_const(datum).load();
+        CHECK(d.pos.a == 1);
+        CHECK(d.pos.y == 1);
+    }
+}
+
+TEST_CASE("VirtualDatum.store")
+{
+    llama::One<Name> datum;
+
+    datum = 1;
+    {
+        MyPos<int> pos{2, 3};
+        datum(tag::Pos{}).store(pos);
+        CHECK(datum(tag::Pos{}, tag::A{}) == 2);
+        CHECK(datum(tag::Pos{}, tag::Y{}) == 3);
+        CHECK(datum(tag::Vel{}, tag::X{}) == 1);
+        CHECK(datum(tag::Vel{}, tag::Y{}) == 1);
+        CHECK(datum(tag::Vel{}, tag::Z{}) == 1);
+        CHECK(datum(tag::Weight{}) == 1);
+    }
+
+    datum = 1;
+    {
+        MyDatum<int> d{{2, 3}, {4, 5, 6}, 7};
+        datum.store(d);
+        CHECK(datum(tag::Pos{}, tag::A{}) == 2);
+        CHECK(datum(tag::Pos{}, tag::Y{}) == 3);
+        CHECK(datum(tag::Vel{}, tag::X{}) == 4);
+        CHECK(datum(tag::Vel{}, tag::Y{}) == 5);
+        CHECK(datum(tag::Vel{}, tag::Z{}) == 6);
+        CHECK(datum(tag::Weight{}) == 7);
+    }
+}
+
+TEST_CASE("VirtualDatum.loadAs.value")
+{
+    llama::One<Name> datum;
+    datum = 1;
+
+    {
+        auto pos = datum(tag::Pos{}).loadAs<MyPos<int>>();
+        CHECK(pos.a == 1);
+        CHECK(pos.y == 1);
+    }
+    {
+        auto pos = std::as_const(datum)(tag::Pos{}).loadAs<MyPos<int>>();
+        CHECK(pos.a == 1);
+        CHECK(pos.y == 1);
+    }
+}
+
+TEST_CASE("VirtualDatum.loadAs.ref")
+{
+    llama::One<Name> datum;
+    datum = 1;
+
+    auto pos = datum(tag::Pos{}).loadAs<MyPos<int&>>();
+    CHECK(pos.a == 1);
+    CHECK(pos.y == 1);
+
+    pos.a = 2;
+    pos.y = 3;
+    CHECK(datum(tag::Pos{}, tag::A{}) == 2);
+    CHECK(datum(tag::Pos{}, tag::Y{}) == 3);
+    CHECK(datum(tag::Vel{}, tag::X{}) == 1);
+    CHECK(datum(tag::Vel{}, tag::Y{}) == 1);
+    CHECK(datum(tag::Vel{}, tag::Z{}) == 1);
+    CHECK(datum(tag::Weight{}) == 1);
+}
+
+TEST_CASE("VirtualDatum.loadAs.constref")
+{
+    llama::One<Name> datum;
+    datum = 1;
+
+    {
+        auto pos = datum(tag::Pos{}).loadAs<MyPos<const int&>>();
+        CHECK(pos.a == 1);
+        CHECK(pos.y == 1);
+    }
+    {
+        auto pos = std::as_const(datum)(tag::Pos{}).loadAs<MyPos<const int&>>();
+        CHECK(pos.a == 1);
+        CHECK(pos.y == 1);
+    }
+}