diff --git a/CMakeLists.txt b/CMakeLists.txt
index dba77d38be..30c533a346 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -400,6 +400,7 @@ set(CORE_SOURCE
         src/Format.cpp
         src/Iteration.cpp
         src/IterationEncoding.cpp
+        src/LoadStoreChunk.cpp
         src/Mesh.cpp
         src/ParticlePatches.cpp
         src/ParticleSpecies.cpp
@@ -411,6 +412,7 @@ set(CORE_SOURCE
         src/version.cpp
         src/auxiliary/Date.cpp
         src/auxiliary/Filesystem.cpp
+        src/auxiliary/Future.cpp
         src/auxiliary/JSON.cpp
         src/auxiliary/JSONMatcher.cpp
         src/auxiliary/Memory.cpp
diff --git a/include/openPMD/Dataset.hpp b/include/openPMD/Dataset.hpp
index e1f0058885..27195abb4d 100644
--- a/include/openPMD/Dataset.hpp
+++ b/include/openPMD/Dataset.hpp
@@ -34,6 +34,12 @@ namespace openPMD
 using Extent = std::vector<std::uint64_t>;
 using Offset = std::vector<std::uint64_t>;
 
+struct MemorySelection
+{
+    Offset offset;
+    Extent extent;
+};
+
 class Dataset
 {
     friend class RecordComponent;
diff --git a/include/openPMD/Datatype.hpp b/include/openPMD/Datatype.hpp
index a11d3db75f..579c7c665d 100644
--- a/include/openPMD/Datatype.hpp
+++ b/include/openPMD/Datatype.hpp
@@ -294,7 +294,8 @@ template <typename T>
 inline constexpr Datatype determineDatatype(T &&val)
 {
     (void)val; // don't need this, it only has a name for Doxygen
-    using T_stripped = std::remove_cv_t<std::remove_reference_t<T>>;
+    using T_stripped =
+        std::remove_extent_t<std::remove_cv_t<std::remove_reference_t<T>>>;
     if constexpr (auxiliary::IsPointer_v<T_stripped>)
     {
         return determineDatatype<auxiliary::IsPointer_t<T_stripped>>();
diff --git a/include/openPMD/IO/ADIOS/ADIOS2File.hpp b/include/openPMD/IO/ADIOS/ADIOS2File.hpp
index d34cc8ebe5..0b7aa6f314 100644
--- a/include/openPMD/IO/ADIOS/ADIOS2File.hpp
+++ b/include/openPMD/IO/ADIOS/ADIOS2File.hpp
@@ -20,6 +20,7 @@
  */
 #pragma once
 
+#include "openPMD/Dataset.hpp"
 #include "openPMD/IO/ADIOS/ADIOS2Auxiliary.hpp"
 #include "openPMD/IO/ADIOS/ADIOS2PreloadAttributes.hpp"
 #include "openPMD/IO/ADIOS/ADIOS2PreloadVariables.hpp"
@@ -112,6 +113,7 @@ struct BufferedUniquePtrPut
     std::string name;
     Offset offset;
     Extent extent;
+    std::optional<MemorySelection> memorySelection;
     UniquePtrWithLambda<void> data;
     Datatype dtype = Datatype::UNDEFINED;
 
diff --git a/include/openPMD/IO/ADIOS/ADIOS2IOHandler.hpp b/include/openPMD/IO/ADIOS/ADIOS2IOHandler.hpp
index 4316f5181f..656f249b6b 100644
--- a/include/openPMD/IO/ADIOS/ADIOS2IOHandler.hpp
+++ b/include/openPMD/IO/ADIOS/ADIOS2IOHandler.hpp
@@ -21,6 +21,7 @@
  */
 #pragma once
 
+#include "openPMD/Dataset.hpp"
 #include "openPMD/Error.hpp"
 #include "openPMD/IO/ADIOS/ADIOS2Auxiliary.hpp"
 #include "openPMD/IO/ADIOS/ADIOS2FilePosition.hpp"
@@ -509,6 +510,7 @@ class ADIOS2IOHandlerImpl
     adios2::Variable<T> verifyDataset(
         Offset const &offset,
         Extent const &extent,
+        std::optional<MemorySelection> const &memorySelection,
         adios2::IO &IO,
         adios2::Engine &engine,
         std::string const &varName,
@@ -622,6 +624,18 @@ class ADIOS2IOHandlerImpl
         var.SetSelection(
             {adios2::Dims(offset.begin(), offset.end()),
              adios2::Dims(extent.begin(), extent.end())});
+
+        if (memorySelection.has_value())
+        {
+            var.SetMemorySelection(
+                {adios2::Dims(
+                     memorySelection->offset.begin(),
+                     memorySelection->offset.end()),
+                 adios2::Dims(
+                     memorySelection->extent.begin(),
+                     memorySelection->extent.end())});
+        }
+
         return var;
     }
 
@@ -629,6 +643,7 @@ class ADIOS2IOHandlerImpl
     {
         bool noGroupBased = false;
         bool blosc2bp5 = false;
+        bool memorySelection = false;
     } printedWarningsAlready;
 }; // ADIOS2IOHandlerImpl
 
@@ -942,7 +957,7 @@ class ADIOS2IOHandler : public AbstractIOHandler
         try
         {
             auto params = internal::defaultParsedFlushParams;
-            this->flush(params);
+            this->flush_impl(params);
         }
         catch (std::exception const &ex)
         {
@@ -990,6 +1005,6 @@ class ADIOS2IOHandler : public AbstractIOHandler
         return true;
     }
 
-    std::future<void> flush(internal::ParsedFlushParams &) override;
+    std::future<void> flush_impl(internal::ParsedFlushParams &) override;
 }; // ADIOS2IOHandler
 } // namespace openPMD
diff --git a/include/openPMD/IO/ADIOS/macros.hpp b/include/openPMD/IO/ADIOS/macros.hpp
index 8e57d9191d..47b38912cc 100644
--- a/include/openPMD/IO/ADIOS/macros.hpp
+++ b/include/openPMD/IO/ADIOS/macros.hpp
@@ -41,6 +41,29 @@
 #define openPMD_HAVE_ADIOS2_BP5 0
 #endif
 
+namespace openPMD
+{
+namespace detail
+{
+    template <typename Variable, typename SFINAE = void>
+    struct CanTheMemorySelectionBeReset
+    {
+        static constexpr bool value = false;
+    };
+
+    template <typename Variable>
+    struct CanTheMemorySelectionBeReset<
+        Variable,
+        decltype(std::declval<Variable>().SetMemorySelection())>
+    {
+        static constexpr bool value = true;
+    };
+} // namespace detail
+
+constexpr bool CanTheMemorySelectionBeReset =
+    detail::CanTheMemorySelectionBeReset<adios2::Variable<int>>::value;
+} // namespace openPMD
+
 #else
 
 #define openPMD_HAS_ADIOS_2_8 0
diff --git a/include/openPMD/IO/AbstractIOHandler.hpp b/include/openPMD/IO/AbstractIOHandler.hpp
index 9b7735b5ba..6429328c22 100644
--- a/include/openPMD/IO/AbstractIOHandler.hpp
+++ b/include/openPMD/IO/AbstractIOHandler.hpp
@@ -265,13 +265,15 @@ class AbstractIOHandler
      * backends that decide to implement this operation asynchronously.
      */
     std::future<void> flush(internal::FlushParams const &);
+    std::shared_ptr<unsigned long long> m_flushCounter =
+        std::make_shared<unsigned long long>(0);
 
     /** Process operations in queue according to FIFO.
      *
      * @return  Future indicating the completion state of the operation for
      * backends that decide to implement this operation asynchronously.
      */
-    virtual std::future<void> flush(internal::ParsedFlushParams &) = 0;
+    std::future<void> flush(internal::ParsedFlushParams &);
 
     /** The currently used backend */
     virtual std::string backendName() const = 0;
@@ -315,6 +317,9 @@ class AbstractIOHandler
     IterationEncoding m_encoding = IterationEncoding::groupBased;
     OpenpmdStandard m_standard = auxiliary::parseStandard(getStandardDefault());
     bool m_verify_homogeneous_extents = true;
+
+protected:
+    virtual std::future<void> flush_impl(internal::ParsedFlushParams &) = 0;
 }; // AbstractIOHandler
 
 } // namespace openPMD
diff --git a/include/openPMD/IO/DummyIOHandler.hpp b/include/openPMD/IO/DummyIOHandler.hpp
index 8abcf20990..100711c944 100644
--- a/include/openPMD/IO/DummyIOHandler.hpp
+++ b/include/openPMD/IO/DummyIOHandler.hpp
@@ -44,7 +44,7 @@ class DummyIOHandler : public AbstractIOHandler
     /** No-op consistent with the IOHandler interface to enable library use
      * without IO.
      */
-    std::future<void> flush(internal::ParsedFlushParams &) override;
+    std::future<void> flush_impl(internal::ParsedFlushParams &) override;
     std::string backendName() const override;
 }; // DummyIOHandler
 } // namespace openPMD
diff --git a/include/openPMD/IO/HDF5/HDF5IOHandler.hpp b/include/openPMD/IO/HDF5/HDF5IOHandler.hpp
index 07b3978b87..5e2ddfd526 100644
--- a/include/openPMD/IO/HDF5/HDF5IOHandler.hpp
+++ b/include/openPMD/IO/HDF5/HDF5IOHandler.hpp
@@ -46,7 +46,7 @@ class HDF5IOHandler : public AbstractIOHandler
         return "HDF5";
     }
 
-    std::future<void> flush(internal::ParsedFlushParams &) override;
+    std::future<void> flush_impl(internal::ParsedFlushParams &) override;
 
 private:
     std::unique_ptr<HDF5IOHandlerImpl> m_impl;
diff --git a/include/openPMD/IO/HDF5/ParallelHDF5IOHandler.hpp b/include/openPMD/IO/HDF5/ParallelHDF5IOHandler.hpp
index abeb196b11..7b0c43129d 100644
--- a/include/openPMD/IO/HDF5/ParallelHDF5IOHandler.hpp
+++ b/include/openPMD/IO/HDF5/ParallelHDF5IOHandler.hpp
@@ -56,7 +56,7 @@ class ParallelHDF5IOHandler : public AbstractIOHandler
         return "MPI_HDF5";
     }
 
-    std::future<void> flush(internal::ParsedFlushParams &) override;
+    std::future<void> flush_impl(internal::ParsedFlushParams &) override;
 
 private:
     std::unique_ptr<ParallelHDF5IOHandlerImpl> m_impl;
diff --git a/include/openPMD/IO/IOTask.hpp b/include/openPMD/IO/IOTask.hpp
index 1ee7248b32..f25fc389f8 100644
--- a/include/openPMD/IO/IOTask.hpp
+++ b/include/openPMD/IO/IOTask.hpp
@@ -495,6 +495,7 @@ struct OPENPMDAPI_EXPORT
 
     Extent extent = {};
     Offset offset = {};
+    std::optional<MemorySelection> memorySelection = std::nullopt;
     Datatype dtype = Datatype::UNDEFINED;
     auxiliary::WriteBuffer data;
 };
diff --git a/include/openPMD/IO/JSON/JSONIOHandler.hpp b/include/openPMD/IO/JSON/JSONIOHandler.hpp
index 07e797d4b3..db8b687ed9 100644
--- a/include/openPMD/IO/JSON/JSONIOHandler.hpp
+++ b/include/openPMD/IO/JSON/JSONIOHandler.hpp
@@ -59,7 +59,7 @@ class JSONIOHandler : public AbstractIOHandler
         return "JSON";
     }
 
-    std::future<void> flush(internal::ParsedFlushParams &) override;
+    std::future<void> flush_impl(internal::ParsedFlushParams &) override;
 
 private:
     JSONIOHandlerImpl m_impl;
diff --git a/include/openPMD/LoadStoreChunk.hpp b/include/openPMD/LoadStoreChunk.hpp
new file mode 100644
index 0000000000..e579c54ae2
--- /dev/null
+++ b/include/openPMD/LoadStoreChunk.hpp
@@ -0,0 +1,305 @@
+#pragma once
+
+#include "openPMD/Dataset.hpp"
+#include "openPMD/auxiliary/Future.hpp"
+#include "openPMD/auxiliary/ShareRawInternal.hpp"
+#include "openPMD/auxiliary/UniquePtr.hpp"
+
+// comment to prevent this include from being moved by clang-format
+#include "openPMD/DatatypeMacros.hpp"
+
+#include <future>
+#include <optional>
+#include <stdexcept>
+#include <type_traits>
+
+namespace openPMD
+{
+class RecordComponent;
+template <typename Ptr_Type>
+class ConfigureStoreChunkFromBuffer;
+template <typename Ptr_Type>
+class ConfigureLoadStoreFromBuffer;
+template <typename T>
+class DynamicMemoryView;
+class Attributable;
+
+namespace internal
+{
+    struct LoadStoreConfig
+    {
+        Offset offset;
+        Extent extent;
+    };
+    struct LoadStoreConfigWithBuffer
+    {
+        Offset offset;
+        Extent extent;
+        std::optional<MemorySelection> memorySelection;
+    };
+
+} // namespace internal
+
+namespace auxiliary::detail
+{
+#define OPENPMD_ENUMERATE_TYPES(type) , std::shared_ptr<type>
+    using shared_ptr_dataset_types = auxiliary::detail::variant_tail_t<
+        auxiliary::detail::bottom OPENPMD_FOREACH_DATASET_DATATYPE(
+            OPENPMD_ENUMERATE_TYPES)>;
+#undef OPENPMD_ENUMERATE_TYPES
+} // namespace auxiliary::detail
+
+namespace compose
+{
+    template <typename ChildClass>
+    class ConfigureLoadStore;
+    template <typename ChildClass>
+    class ConfigureLoadStoreFromBuffer;
+} // namespace compose
+
+enum class EnqueuePolicy
+{
+    Defer,
+    Immediate
+};
+
+namespace core
+{
+    /*
+     * Actual data members of `ConfigureLoadStore<>` and methods that don't
+     * depend on the ChildClass template parameter. By extracting the members to
+     * this struct, we can pass them around between different instances of the
+     * class template. Numbers of method instantiations can be reduced.
+     */
+    class ConfigureLoadStore
+    {
+        template <typename ChildClass>
+        friend class compose::ConfigureLoadStore;
+        template <typename ChildClass>
+        friend class compose::ConfigureLoadStoreFromBuffer;
+
+    protected:
+        ConfigureLoadStore(RecordComponent &);
+        RecordComponent &m_rc;
+
+        std::optional<Offset> m_offset;
+        std::optional<Extent> m_extent;
+
+        [[nodiscard]] auto dim() const -> uint8_t;
+        auto storeChunkConfig() -> internal::LoadStoreConfig;
+
+        auto deferFlush(Attributable &);
+
+    public:
+        auto getOffset() -> Offset const &;
+        auto getExtent() -> Extent const &;
+        /*
+         * If the type is non-const, then the return type should be
+         * ConfigureLoadStoreFromBuffer<>, ...
+         */
+        template <typename T>
+        struct shared_ptr_return_type_impl
+        {
+            using type = ConfigureLoadStoreFromBuffer<
+                std::shared_ptr<std::remove_extent_t<T>>>;
+        };
+        /*
+         * ..., but if it is a const type, Load operations make no sense, so the
+         * return type should be ConfigureStoreChunkFromBuffer<>.
+         */
+        template <typename T>
+        struct shared_ptr_return_type_impl<T const>
+        {
+            using type = ConfigureStoreChunkFromBuffer<
+                std::shared_ptr<std::remove_extent_t<T> const>>;
+        };
+
+        template <typename T>
+        using shared_ptr_return_type =
+            typename shared_ptr_return_type_impl<std::remove_extent_t<T>>::type;
+
+        /*
+         * As loading into unique pointer types makes no sense, the case is
+         * simpler for unique pointers. Just remove the array extents here.
+         */
+        template <typename T>
+        using unique_ptr_return_type = ConfigureStoreChunkFromBuffer<
+            UniquePtrWithLambda<std::remove_extent_t<T>>>;
+
+        // @todo rvalue references..?
+        template <typename T>
+        auto withSharedPtr(std::shared_ptr<T>) -> shared_ptr_return_type<T>;
+        template <typename T>
+        auto withUniquePtr(UniquePtrWithLambda<T>) -> unique_ptr_return_type<T>;
+        template <typename T, typename Del>
+        auto withUniquePtr(std::unique_ptr<T, Del>)
+            -> unique_ptr_return_type<T>;
+        template <typename T>
+        auto withRawPtr(T *data) -> shared_ptr_return_type<T>;
+        template <typename T_ContiguousContainer>
+        auto withContiguousContainer(T_ContiguousContainer &data)
+            -> std::enable_if_t<
+                auxiliary::IsContiguousContainer_v<T_ContiguousContainer>,
+                shared_ptr_return_type<
+                    typename T_ContiguousContainer::value_type>>;
+
+        template <typename T>
+        [[nodiscard]] auto enqueueStore() -> DynamicMemoryView<T>;
+        // definition for this one is in RecordComponent.tpp since it needs the
+        // definition of class RecordComponent.
+        template <typename T, typename F>
+        [[nodiscard]] auto enqueueStore(F &&createBuffer)
+            -> DynamicMemoryView<T>;
+
+        template <typename T>
+        [[nodiscard]] auto enqueueLoad()
+            -> auxiliary::DeferredComputation<std::shared_ptr<T>>;
+
+        template <typename T>
+        [[nodiscard]] auto load(EnqueuePolicy) -> std::shared_ptr<T>;
+
+        [[nodiscard]] auto enqueueLoadVariant()
+            -> auxiliary::DeferredComputation<
+                auxiliary::detail::shared_ptr_dataset_types>;
+
+        [[nodiscard]] auto loadVariant(EnqueuePolicy)
+            -> auxiliary::detail::shared_ptr_dataset_types;
+    };
+
+    template <typename Ptr_Type>
+    class ConfigureStoreChunkFromBuffer : public ConfigureLoadStore
+    {
+    public:
+        Ptr_Type m_buffer;
+        std::optional<MemorySelection> m_mem_select;
+
+        ConfigureStoreChunkFromBuffer(Ptr_Type buffer, ConfigureLoadStore &&);
+
+        auto storeChunkConfig() -> internal::LoadStoreConfigWithBuffer;
+
+        auto enqueueStore() -> auxiliary::DeferredComputation<void>;
+
+        auto store(EnqueuePolicy) -> void;
+
+        /** This intentionally shadows the parent class's enqueueLoad methods in
+         * order to show a compile error when using enqueueLoad() on an object
+         * of this class. The parent method can still be accessed through
+         * as_parent() if needed.
+         */
+        template <typename X = void>
+        auto enqueueLoad()
+        {
+            static_assert(
+                auxiliary::dependent_false_v<X>,
+                "Cannot load chunk data into a buffer that is const or a "
+                "unique_ptr.");
+        }
+
+        template <typename X = void>
+        auto load(EnqueuePolicy)
+        {
+            static_assert(
+                auxiliary::dependent_false_v<X>,
+                "Cannot load chunk data into a buffer that is const or a "
+                "unique_ptr.");
+        }
+    };
+
+    template <typename Ptr_Type>
+    class ConfigureLoadStoreFromBuffer
+        : public ConfigureStoreChunkFromBuffer<Ptr_Type>
+    {
+    public:
+        using ConfigureStoreChunkFromBuffer<
+            Ptr_Type>::ConfigureStoreChunkFromBuffer;
+
+        auto enqueueLoad() -> auxiliary::DeferredComputation<void>;
+
+        auto load(EnqueuePolicy) -> void;
+    };
+} // namespace core
+
+namespace compose
+{
+    /** Basic configuration for a Load/Store operation.
+     *
+     * @tparam ChildClass CRT pattern.
+     *         The purpose is that in child classes `return *this` should return
+     *         an instance of the child class, not of ConfigureLoadStore.
+     *         Instantiate with void when using without subclass.
+     */
+    template <typename ChildClass>
+    class ConfigureLoadStore
+    {
+        ConfigureLoadStore() = default;
+
+    public:
+        auto offset(Offset) -> ChildClass &;
+        auto extent(Extent) -> ChildClass &;
+        friend ChildClass;
+    };
+
+    /** Configuration for a Store operation with a buffer type.
+     *
+     * This class does intentionally not support Load operations since there are
+     * pointer types (const pointers, unique pointers) where Load operations
+     * make no sense. See the \ref ConfigureLoadStoreFromBuffer class template
+     * for both Load/Store operations.
+     *
+     * @tparam Ptr_Type The type of pointer used internally.
+     * @tparam ChildClass CRT pattern.
+     *         The purpose is that in child classes `return *this` should return
+     *         an instance of the child class, not of
+     * ConfigureStoreChunkFromBuffer. Instantiate with void when using without
+     * subclass.
+     */
+    template <typename ChildClass = void>
+    class ConfigureStoreChunkFromBuffer
+    {
+    public:
+        auto memorySelection(MemorySelection) -> ChildClass &;
+    };
+} // namespace compose
+
+class ConfigureLoadStore
+    : public core::ConfigureLoadStore
+    , public compose::ConfigureLoadStore<ConfigureLoadStore>
+{
+    friend class RecordComponent;
+    friend class core::ConfigureLoadStore;
+
+    ConfigureLoadStore(RecordComponent &rc);
+    ConfigureLoadStore(core::ConfigureLoadStore &&);
+};
+
+template <typename Ptr_Type>
+class ConfigureStoreChunkFromBuffer
+    : public core::ConfigureStoreChunkFromBuffer<Ptr_Type>
+    , public compose::ConfigureLoadStore<
+          ConfigureStoreChunkFromBuffer<Ptr_Type>>
+    , public compose::ConfigureStoreChunkFromBuffer<
+          ConfigureStoreChunkFromBuffer<Ptr_Type>>
+{
+    friend class core::ConfigureLoadStore;
+
+    using core::ConfigureStoreChunkFromBuffer<
+        Ptr_Type>::ConfigureStoreChunkFromBuffer;
+};
+
+template <typename Ptr_Type>
+class ConfigureLoadStoreFromBuffer
+    : public core::ConfigureLoadStoreFromBuffer<Ptr_Type>
+    , public compose::ConfigureLoadStore<ConfigureLoadStoreFromBuffer<Ptr_Type>>
+    , public compose::ConfigureStoreChunkFromBuffer<
+          ConfigureLoadStoreFromBuffer<Ptr_Type>>
+{
+    friend class ConfigureLoadStoreCore;
+
+    using core::ConfigureLoadStoreFromBuffer<
+        Ptr_Type>::ConfigureLoadStoreFromBuffer;
+};
+} // namespace openPMD
+
+#include "openPMD/UndefDatatypeMacros.hpp"
+// comment to prevent these includes from being moved by clang-format
+#include "openPMD/LoadStoreChunk.tpp"
diff --git a/include/openPMD/LoadStoreChunk.tpp b/include/openPMD/LoadStoreChunk.tpp
new file mode 100644
index 0000000000..c3c104cebd
--- /dev/null
+++ b/include/openPMD/LoadStoreChunk.tpp
@@ -0,0 +1,64 @@
+#pragma once
+
+#include "openPMD/LoadStoreChunk.hpp"
+
+namespace openPMD::core
+{
+template <typename T>
+auto ConfigureLoadStore::withSharedPtr(std::shared_ptr<T> data)
+    -> shared_ptr_return_type<T>
+{
+    if (!data)
+    {
+        throw std::runtime_error(
+            "Unallocated pointer passed during chunk store.");
+    }
+    return shared_ptr_return_type<T>(
+        std::static_pointer_cast<std::remove_extent_t<T>>(std::move(data)),
+        {std::move(*this)});
+}
+template <typename T>
+auto ConfigureLoadStore::withUniquePtr(UniquePtrWithLambda<T> data)
+    -> unique_ptr_return_type<T>
+
+{
+    if (!data)
+    {
+        throw std::runtime_error(
+            "Unallocated pointer passed during chunk store.");
+    }
+    return unique_ptr_return_type<T>(
+        std::move(data).template static_cast_<std::remove_extent_t<T>>(),
+        {std::move(*this)});
+}
+template <typename T>
+auto ConfigureLoadStore::withRawPtr(T *data) -> shared_ptr_return_type<T>
+{
+    if (!data)
+    {
+        throw std::runtime_error(
+            "Unallocated pointer passed during chunk store.");
+    }
+    return shared_ptr_return_type<T>(
+        auxiliary::shareRaw(data), {std::move(*this)});
+}
+
+template <typename T, typename Del>
+auto ConfigureLoadStore::withUniquePtr(std::unique_ptr<T, Del> data)
+    -> unique_ptr_return_type<T>
+{
+    return withUniquePtr(UniquePtrWithLambda<T>(std::move(data)));
+}
+template <typename T_ContiguousContainer>
+auto ConfigureLoadStore::withContiguousContainer(T_ContiguousContainer &data)
+    -> std::enable_if_t<
+        auxiliary::IsContiguousContainer_v<T_ContiguousContainer>,
+        shared_ptr_return_type<typename T_ContiguousContainer::value_type>>
+{
+    if (!m_extent.has_value() && dim() == 1)
+    {
+        m_extent = Extent{data.size()};
+    }
+    return withRawPtr(data.data());
+}
+} // namespace openPMD::core
diff --git a/include/openPMD/RecordComponent.hpp b/include/openPMD/RecordComponent.hpp
index d06b4213f4..644e7acd2b 100644
--- a/include/openPMD/RecordComponent.hpp
+++ b/include/openPMD/RecordComponent.hpp
@@ -22,15 +22,13 @@
 
 #include "openPMD/Dataset.hpp"
 #include "openPMD/Datatype.hpp"
+#include "openPMD/LoadStoreChunk.hpp"
 #include "openPMD/auxiliary/ShareRaw.hpp"
 #include "openPMD/auxiliary/TypeTraits.hpp"
 #include "openPMD/auxiliary/UniquePtr.hpp"
 #include "openPMD/backend/Attributable.hpp"
 #include "openPMD/backend/BaseRecordComponent.hpp"
 
-// comment to prevent this include from being moved by clang-format
-#include "openPMD/DatatypeMacros.hpp"
-
 #include <array>
 #include <cmath>
 #include <limits>
@@ -107,6 +105,17 @@ namespace internal
     class BaseRecordData;
 } // namespace internal
 
+namespace core
+{
+    class ConfigureLoadStore;
+    template <typename>
+    class ConfigureLoadStoreFromBuffer;
+    template <typename>
+    class ConfigureStoreChunkFromBuffer;
+    struct VisitorEnqueueLoadVariant;
+    struct VisitorLoadVariant;
+} // namespace core
+
 template <typename>
 class BaseRecord;
 
@@ -128,6 +137,13 @@ class RecordComponent : public BaseRecordComponent
     friend class MeshRecordComponent;
     template <typename T>
     friend T &internal::makeOwning(T &self, Series);
+    friend class core::ConfigureLoadStore;
+    template <typename>
+    friend class core::ConfigureLoadStoreFromBuffer;
+    template <typename>
+    friend class core::ConfigureStoreChunkFromBuffer;
+    friend struct core::VisitorEnqueueLoadVariant;
+    friend struct core::VisitorLoadVariant;
 
 public:
     enum class Allocation
@@ -214,6 +230,8 @@ class RecordComponent : public BaseRecordComponent
      */
     bool empty() const;
 
+    ConfigureLoadStore prepareLoadStore();
+
     /** Load and allocate a chunk of data
      *
      * Set offset to {0u} and extent to {-1u} for full selection.
@@ -224,11 +242,8 @@ class RecordComponent : public BaseRecordComponent
     template <typename T>
     std::shared_ptr<T> loadChunk(Offset = {0u}, Extent = {-1u});
 
-#define OPENPMD_ENUMERATE_TYPES(type) , std::shared_ptr<type>
-    using shared_ptr_dataset_types = auxiliary::detail::variant_tail_t<
-        auxiliary::detail::bottom OPENPMD_FOREACH_DATASET_DATATYPE(
-            OPENPMD_ENUMERATE_TYPES)>;
-#undef OPENPMD_ENUMERATE_TYPES
+    using shared_ptr_dataset_types =
+        auxiliary::detail::shared_ptr_dataset_types;
 
     /** std::variant-based version of allocating loadChunk<T>(Offset, Extent)
      *
@@ -266,25 +281,6 @@ class RecordComponent : public BaseRecordComponent
     template <typename T>
     void loadChunk(std::shared_ptr<T> data, Offset offset, Extent extent);
 
-    /** Load a chunk of data into pre-allocated memory, array version.
-     *
-     * @param data   Preallocated, contiguous buffer, large enough to load the
-     *               the requested data into it.
-     *               The shared pointer must own and manage the buffer.
-     *               Optimizations might be implemented based on this
-     *               assumption (e.g. skipping the operation if the backend
-     *               is the unique owner).
-     *               The array-based overload helps avoid having to manually
-     *               specify the delete[] destructor (C++17 feature).
-     * @param offset Offset within the dataset. Set to {0u} for full selection.
-     * @param extent Extent within the dataset, counted from the offset.
-     *               Set to {-1u} for full selection.
-     *               If offset is non-zero and extent is {-1u} the leftover
-     *               extent in the record component will be selected.
-     */
-    template <typename T>
-    void loadChunk(std::shared_ptr<T[]> data, Offset offset, Extent extent);
-
     /** Load a chunk of data into pre-allocated memory, raw pointer version.
      *
      * @param data   Preallocated, contiguous buffer, large enough to load the
@@ -324,18 +320,6 @@ class RecordComponent : public BaseRecordComponent
     template <typename T>
     void storeChunk(std::shared_ptr<T> data, Offset offset, Extent extent);
 
-    /** Store a chunk of data from a chunk of memory, array version.
-     *
-     * @param data   Preallocated, contiguous buffer, large enough to read the
-     *               the specified data from it.
-     *               The array-based overload helps avoid having to manually
-     *               specify the delete[] destructor (C++17 feature).
-     * @param offset Offset within the dataset.
-     * @param extent Extent within the dataset, counted from the offset.
-     */
-    template <typename T>
-    void storeChunk(std::shared_ptr<T[]> data, Offset offset, Extent extent);
-
     /** Store a chunk of data from a chunk of memory, unique pointer version.
      *
      * @param data   Preallocated, contiguous buffer, large enough to read the
@@ -497,8 +481,22 @@ class RecordComponent : public BaseRecordComponent
      */
     RecordComponent &makeEmpty(Dataset d);
 
-    void storeChunk(
-        auxiliary::WriteBuffer buffer, Datatype datatype, Offset o, Extent e);
+    void storeChunk_impl(
+        auxiliary::WriteBuffer buffer,
+        Datatype datatype,
+        internal::LoadStoreConfigWithBuffer);
+
+    template <typename T>
+    DynamicMemoryView<T> storeChunkSpan_impl(internal::LoadStoreConfig);
+    template <typename T, typename F>
+    DynamicMemoryView<T> storeChunkSpanCreateBuffer_impl(
+        internal::LoadStoreConfig, F &&createBuffer);
+
+    template <typename T>
+    void
+        loadChunk_impl(std::shared_ptr<T>, internal::LoadStoreConfigWithBuffer);
+    template <typename T>
+    std::shared_ptr<T> loadChunkAllocate_impl(internal::LoadStoreConfig);
 
     // clang-format off
 OPENPMD_protected
@@ -564,6 +562,4 @@ namespace internal
 
 } // namespace openPMD
 
-#include "openPMD/UndefDatatypeMacros.hpp"
-// comment to prevent these includes from being moved by clang-format
 #include "RecordComponent.tpp"
diff --git a/include/openPMD/RecordComponent.tpp b/include/openPMD/RecordComponent.tpp
index 9d1d8332b4..bcc32381dd 100644
--- a/include/openPMD/RecordComponent.tpp
+++ b/include/openPMD/RecordComponent.tpp
@@ -23,6 +23,7 @@
 
 #include "openPMD/Datatype.hpp"
 #include "openPMD/Error.hpp"
+#include "openPMD/LoadStoreChunk.hpp"
 #include "openPMD/RecordComponent.hpp"
 #include "openPMD/Span.hpp"
 #include "openPMD/auxiliary/Memory.hpp"
@@ -32,6 +33,7 @@
 #include "openPMD/backend/Attributable.hpp"
 
 #include <memory>
+#include <optional>
 #include <type_traits>
 
 namespace openPMD
@@ -41,8 +43,11 @@ template <typename T, typename Del>
 inline void
 RecordComponent::storeChunk(std::unique_ptr<T, Del> data, Offset o, Extent e)
 {
-    storeChunk(
-        UniquePtrWithLambda<T>(std::move(data)), std::move(o), std::move(e));
+    prepareLoadStore()
+        .offset(std::move(o))
+        .extent(std::move(e))
+        .withUniquePtr(std::move(data))
+        .store(EnqueuePolicy::Defer);
 }
 
 template <typename T_ContiguousContainer>
@@ -50,39 +55,38 @@ inline typename std::enable_if_t<
     auxiliary::IsContiguousContainer_v<T_ContiguousContainer>>
 RecordComponent::storeChunk(T_ContiguousContainer &data, Offset o, Extent e)
 {
-    uint8_t dim = getDimensionality();
+    auto storeChunkConfig = prepareLoadStore();
 
-    // default arguments
-    //   offset = {0u}: expand to right dim {0u, 0u, ...}
-    Offset offset = o;
-    if (o.size() == 1u && o.at(0) == 0u)
+    auto joined_dim = joinedDimension();
+    if (!joined_dim.has_value() && (o.size() != 1 || o.at(0) != 0u))
     {
-        if (joinedDimension().has_value())
-        {
-            offset.clear();
-        }
-        else if (dim > 1u)
-        {
-            offset = Offset(dim, 0u);
-        }
+        storeChunkConfig.offset(std::move(o));
+    }
+    if (e.size() != 1 || e.at(0) != -1u)
+    {
+        storeChunkConfig.extent(std::move(e));
     }
 
-    //   extent = {-1u}: take full size
-    Extent extent(dim, 1u);
-    //   avoid outsmarting the user:
-    //   - stdlib data container implement 1D -> 1D chunk to write
-    if (e.size() == 1u && e.at(0) == -1u && dim == 1u)
-        extent.at(0) = data.size();
-    else
-        extent = e;
-
-    storeChunk(auxiliary::shareRaw(data.data()), offset, extent);
+    std::move(storeChunkConfig)
+        .withContiguousContainer(data)
+        .store(EnqueuePolicy::Defer);
 }
 
 template <typename T, typename F>
 inline DynamicMemoryView<T>
 RecordComponent::storeChunk(Offset o, Extent e, F &&createBuffer)
 {
+    return prepareLoadStore()
+        .offset(std::move(o))
+        .extent(std::move(e))
+        .enqueueStore<T>(std::forward<F>(createBuffer));
+}
+
+template <typename T, typename F>
+inline DynamicMemoryView<T> RecordComponent::storeChunkSpanCreateBuffer_impl(
+    internal::LoadStoreConfig cfg, F &&createBuffer)
+{
+    auto [o, e] = std::move(cfg);
     verifyChunk<T>(o, e);
 
     /*
@@ -112,10 +116,9 @@ RecordComponent::storeChunk(Offset o, Extent e, F &&createBuffer)
                 "using storeChunk() (see RecordComponent::resetDataset()).");
         }
         Parameter<Operation::CREATE_DATASET> dCreate(rc.m_dataset.value());
-        dCreate.name = Attributable::get().m_writable.ownKeyWithinParent;
+        dCreate.name = rc->m_writable.ownKeyWithinParent;
         IOHandler()->enqueue(IOTask(this, dCreate));
     }
-
     Parameter<Operation::GET_BUFFER_VIEW> getBufferView;
     getBufferView.offset = o;
     getBufferView.extent = e;
@@ -129,10 +132,7 @@ RecordComponent::storeChunk(Offset o, Extent e, F &&createBuffer)
         // type shared_ptr<T> or shared_ptr<T[]>
         auto data = std::forward<F>(createBuffer)(size);
         out.ptr = static_cast<void *>(data.get());
-        if (size > 0)
-        {
-            storeChunk(std::move(data), std::move(o), std::move(e));
-        }
+        storeChunk(std::move(data), std::move(o), std::move(e));
     }
     setDirtyRecursive(true);
     return DynamicMemoryView<T>{std::move(getBufferView), size, *this};
@@ -169,4 +169,13 @@ inline auto RecordComponent::visit(Args &&...args)
     return switchDatasetType<detail::VisitRecordComponent<Visitor, Res>>(
         getDatatype(), *this, std::forward<Args>(args)...);
 }
+
+// definitions for LoadStoreChunk.hpp
+template <typename T, typename F>
+auto core::ConfigureLoadStore::enqueueStore(F &&createBuffer)
+    -> DynamicMemoryView<T>
+{
+    return m_rc.storeChunkSpanCreateBuffer_impl<T>(
+        storeChunkConfig(), std::forward<F>(createBuffer));
+}
 } // namespace openPMD
diff --git a/include/openPMD/auxiliary/Future.hpp b/include/openPMD/auxiliary/Future.hpp
new file mode 100644
index 0000000000..8a4b2a516c
--- /dev/null
+++ b/include/openPMD/auxiliary/Future.hpp
@@ -0,0 +1,24 @@
+#pragma once
+
+#include "openPMD/auxiliary/TypeTraits.hpp"
+
+#include <functional>
+
+namespace openPMD::auxiliary
+{
+template <typename T>
+class DeferredComputation
+{
+    using task_type = std::function<T()>;
+    task_type m_task;
+    bool m_valid = false;
+
+public:
+    DeferredComputation(task_type);
+    ~DeferredComputation();
+
+    auto get() -> T;
+
+    [[nodiscard]] auto valid() const noexcept -> bool;
+};
+} // namespace openPMD::auxiliary
diff --git a/include/openPMD/auxiliary/UniquePtr.hpp b/include/openPMD/auxiliary/UniquePtr.hpp
index 87f3261b45..ee17794d3e 100644
--- a/include/openPMD/auxiliary/UniquePtr.hpp
+++ b/include/openPMD/auxiliary/UniquePtr.hpp
@@ -176,10 +176,11 @@ template <typename U>
 UniquePtrWithLambda<U> UniquePtrWithLambda<T>::static_cast_() &&
 {
     using other_type = std::remove_extent_t<U>;
+    auto original_ptr = this->release();
     return UniquePtrWithLambda<U>{
-        static_cast<other_type *>(this->release()),
-        [deleter = std::move(this->get_deleter())](other_type *ptr) {
-            deleter(static_cast<T_decayed *>(ptr));
+        static_cast<other_type *>(original_ptr),
+        [deleter = std::move(this->get_deleter()), original_ptr](other_type *) {
+            deleter(original_ptr);
         }};
 }
 } // namespace openPMD
diff --git a/include/openPMD/backend/Attributable.hpp b/include/openPMD/backend/Attributable.hpp
index 1c1d3db4a5..3318d37e5d 100644
--- a/include/openPMD/backend/Attributable.hpp
+++ b/include/openPMD/backend/Attributable.hpp
@@ -213,6 +213,11 @@ namespace debug
     void printDirty(Series const &);
 }
 
+namespace core
+{
+    class ConfigureLoadStore;
+}
+
 /** @brief Layer to manage storage of attributes associated with file objects.
  *
  * Mandatory and user-defined Attributes and their data for every object in the
@@ -244,6 +249,7 @@ class Attributable
     friend class internal::AttributableData;
     friend class Snapshots;
     friend struct internal::HomogenizeExtents;
+    friend class core::ConfigureLoadStore;
 
 protected:
     // tag for internal constructor
diff --git a/src/IO/ADIOS/ADIOS2File.cpp b/src/IO/ADIOS/ADIOS2File.cpp
index 1d20aeb04d..72010496ed 100644
--- a/src/IO/ADIOS/ADIOS2File.cpp
+++ b/src/IO/ADIOS/ADIOS2File.cpp
@@ -23,6 +23,7 @@
 #include "openPMD/Error.hpp"
 #include "openPMD/IO/ADIOS/ADIOS2Auxiliary.hpp"
 #include "openPMD/IO/ADIOS/ADIOS2IOHandler.hpp"
+#include "openPMD/IO/ADIOS/macros.hpp"
 #include "openPMD/IO/AbstractIOHandler.hpp"
 #include "openPMD/IterationEncoding.hpp"
 #include "openPMD/auxiliary/Environment.hpp"
@@ -70,6 +71,7 @@ void DatasetReader::call(
     adios2::Variable<T> var = impl->verifyDataset<T>(
         bp.param.offset,
         bp.param.extent,
+        std::nullopt,
         IO,
         engine,
         bp.name,
@@ -88,6 +90,12 @@ void DatasetReader::call(
 template <class>
 inline constexpr bool always_false_v = false;
 
+static constexpr char const *warningMemorySelection =
+    "[Warning] Using a version of ADIOS2 that cannot reset memory selections "
+    "on a variable, once specified. When using memory selections, then please "
+    "specify it explicitly on all storeChunk() calls. Further info: "
+    "https://github.com/ornladios/ADIOS2/pull/4169.";
+
 template <typename T>
 void WriteDataset::call(ADIOS2File &ba, detail::BufferedPut &bp)
 {
@@ -106,6 +114,7 @@ void WriteDataset::call(ADIOS2File &ba, detail::BufferedPut &bp)
                 adios2::Variable<T> var = ba.m_impl->verifyDataset<T>(
                     bp.param.offset,
                     bp.param.extent,
+                    bp.param.memorySelection,
                     ba.m_IO,
                     engine,
                     bp.name,
@@ -113,6 +122,19 @@ void WriteDataset::call(ADIOS2File &ba, detail::BufferedPut &bp)
                     ba.variables());
 
                 engine.Put(var, ptr);
+                if (bp.param.memorySelection.has_value())
+                {
+                    if constexpr (openPMD::CanTheMemorySelectionBeReset)
+                    {
+                        var.SetMemorySelection();
+                    }
+                    else if (!ba.m_impl->printedWarningsAlready.memorySelection)
+                    {
+                        std::cerr << warningMemorySelection << std::endl;
+                        ba.m_impl->printedWarningsAlready.memorySelection =
+                            true;
+                    }
+                }
             }
             else if constexpr (std::is_same_v<
                                    ptr_type,
@@ -122,6 +144,14 @@ void WriteDataset::call(ADIOS2File &ba, detail::BufferedPut &bp)
                 bput.name = std::move(bp.name);
                 bput.offset = std::move(bp.param.offset);
                 bput.extent = std::move(bp.param.extent);
+                bput.memorySelection = std::move(bp.param.memorySelection);
+                /*
+                 * Note: Moving is required here since it's a unique_ptr.
+                 * std::forward<>() would theoretically work, but it
+                 * requires the type parameter and we don't have that
+                 * inside the lambda.
+                 * (ptr_type does not work for this case).
+                 */
                 bput.data = arg.release();
                 bput.dtype = bp.param.dtype;
                 ba.m_uniquePtrPuts.push_back(std::move(bput));
@@ -169,12 +199,25 @@ struct RunUniquePtrPut
         adios2::Variable<T> var = ba.m_impl->verifyDataset<T>(
             bufferedPut.offset,
             bufferedPut.extent,
+            bufferedPut.memorySelection,
             ba.m_IO,
             engine,
             bufferedPut.name,
             std::nullopt,
             ba.variables());
         engine.Put(var, ptr);
+        if (bufferedPut.memorySelection.has_value())
+        {
+            if constexpr (openPMD::CanTheMemorySelectionBeReset)
+            {
+                var.SetMemorySelection();
+            }
+            else if (!ba.m_impl->printedWarningsAlready.memorySelection)
+            {
+                std::cerr << warningMemorySelection << std::endl;
+                ba.m_impl->printedWarningsAlready.memorySelection = true;
+            }
+        }
     }
 
     static constexpr char const *errorMsg = "RunUniquePtrPut";
diff --git a/src/IO/ADIOS/ADIOS2IOHandler.cpp b/src/IO/ADIOS/ADIOS2IOHandler.cpp
index 0ee10a77c4..b307db779a 100644
--- a/src/IO/ADIOS/ADIOS2IOHandler.cpp
+++ b/src/IO/ADIOS/ADIOS2IOHandler.cpp
@@ -51,6 +51,7 @@
 #include <iterator>
 #include <memory>
 #include <numeric>
+#include <optional>
 #include <set>
 #include <sstream>
 #include <stdexcept>
@@ -1231,6 +1232,7 @@ namespace detail
             adios2::Variable<T> variable = impl->verifyDataset<T>(
                 params.offset,
                 params.extent,
+                std::nullopt,
                 IO,
                 engine,
                 varName,
@@ -2612,7 +2614,7 @@ ADIOS2IOHandler::ADIOS2IOHandler(
 {}
 
 std::future<void>
-ADIOS2IOHandler::flush(internal::ParsedFlushParams &flushParams)
+ADIOS2IOHandler::flush_impl(internal::ParsedFlushParams &flushParams)
 {
     return m_impl.flush(flushParams);
 }
diff --git a/src/IO/AbstractIOHandler.cpp b/src/IO/AbstractIOHandler.cpp
index 5f2bdeb2f5..0614f26292 100644
--- a/src/IO/AbstractIOHandler.cpp
+++ b/src/IO/AbstractIOHandler.cpp
@@ -122,6 +122,22 @@ std::future<void> AbstractIOHandler::flush(internal::FlushParams const &params)
     return future;
 }
 
+std::future<void> AbstractIOHandler::flush(internal::ParsedFlushParams &params)
+{
+    // The flush counter indicates the number of times that m_work has been
+    // emptied. Only increment it if m_work was full before operation and is
+    // empty after operation.
+    // Enqueuers can use this counter to check if the enqueued operation has
+    // been flushed already.
+    bool increase_flush_counter = !m_work.empty();
+    auto res = this->flush_impl(params);
+    if (increase_flush_counter && m_work.empty())
+    {
+        ++*m_flushCounter;
+    }
+    return res;
+}
+
 bool AbstractIOHandler::fullSupportForVariableBasedEncoding() const
 {
     return false;
diff --git a/src/IO/AbstractIOHandlerImpl.cpp b/src/IO/AbstractIOHandlerImpl.cpp
index ec16ae4c1b..0496474044 100644
--- a/src/IO/AbstractIOHandlerImpl.cpp
+++ b/src/IO/AbstractIOHandlerImpl.cpp
@@ -269,10 +269,26 @@ std::future<void> AbstractIOHandlerImpl::flush()
                     i.writable->parent,
                     "->",
                     i.writable,
-                    "] WRITE_DATASET, offset=",
-                    [&parameter]() { return vec_as_string(parameter.offset); },
-                    ", extent=",
-                    [&parameter]() { return vec_as_string(parameter.extent); });
+                    "] WRITE_DATASET: ",
+                    [&]() {
+                        std::stringstream stream;
+                        stream << "offset: " << vec_as_string(parameter.offset)
+                               << " extent: " << vec_as_string(parameter.extent)
+                               << " mem-selection: ";
+                        if (parameter.memorySelection.has_value())
+                        {
+                            stream << vec_as_string(
+                                          parameter.memorySelection->offset)
+                                   << "--"
+                                   << vec_as_string(
+                                          parameter.memorySelection->extent);
+                        }
+                        else
+                        {
+                            stream << "NONE";
+                        }
+                        return stream.str();
+                    });
                 writeDataset(i.writable, parameter);
                 break;
             }
diff --git a/src/IO/DummyIOHandler.cpp b/src/IO/DummyIOHandler.cpp
index f3b4e155d2..52c83bb624 100644
--- a/src/IO/DummyIOHandler.cpp
+++ b/src/IO/DummyIOHandler.cpp
@@ -39,7 +39,7 @@ DummyIOHandler::DummyIOHandler(std::string path, Access at)
 void DummyIOHandler::enqueue(IOTask const &)
 {}
 
-std::future<void> DummyIOHandler::flush(internal::ParsedFlushParams &)
+std::future<void> DummyIOHandler::flush_impl(internal::ParsedFlushParams &)
 {
     return std::future<void>();
 }
diff --git a/src/IO/HDF5/HDF5IOHandler.cpp b/src/IO/HDF5/HDF5IOHandler.cpp
index ee02020983..2153ef56a6 100644
--- a/src/IO/HDF5/HDF5IOHandler.cpp
+++ b/src/IO/HDF5/HDF5IOHandler.cpp
@@ -1837,6 +1837,12 @@ void HDF5IOHandlerImpl::writeDataset(
             "[HDF5] Writing into a dataset in a file opened as read only is "
             "not possible.");
 
+    if (parameters.memorySelection.has_value())
+    {
+        throw error::OperationUnsupportedInBackend(
+            "HDF5",
+            "Non-contiguous memory selections not supported in HDF5 backend.");
+    }
     File file = requireFile("writeDataset", writable, /* checkParent = */ true);
 
     hid_t dataset_id, filespace, memspace;
@@ -3425,7 +3431,7 @@ HDF5IOHandler::HDF5IOHandler(
 
 HDF5IOHandler::~HDF5IOHandler() = default;
 
-std::future<void> HDF5IOHandler::flush(internal::ParsedFlushParams &params)
+std::future<void> HDF5IOHandler::flush_impl(internal::ParsedFlushParams &params)
 {
     return m_impl->flush(params);
 }
diff --git a/src/IO/HDF5/ParallelHDF5IOHandler.cpp b/src/IO/HDF5/ParallelHDF5IOHandler.cpp
index 7de4960feb..dad31620b6 100644
--- a/src/IO/HDF5/ParallelHDF5IOHandler.cpp
+++ b/src/IO/HDF5/ParallelHDF5IOHandler.cpp
@@ -76,7 +76,7 @@ ParallelHDF5IOHandler::ParallelHDF5IOHandler(
 ParallelHDF5IOHandler::~ParallelHDF5IOHandler() = default;
 
 std::future<void>
-ParallelHDF5IOHandler::flush(internal::ParsedFlushParams &params)
+ParallelHDF5IOHandler::flush_impl(internal::ParsedFlushParams &params)
 {
     if (auto hdf5_config_it = params.backendConfig.json().find("hdf5");
         hdf5_config_it != params.backendConfig.json().end())
diff --git a/src/IO/JSON/JSONIOHandler.cpp b/src/IO/JSON/JSONIOHandler.cpp
index 03cef438d3..6583386d15 100644
--- a/src/IO/JSON/JSONIOHandler.cpp
+++ b/src/IO/JSON/JSONIOHandler.cpp
@@ -51,7 +51,7 @@ JSONIOHandler::JSONIOHandler(
 {}
 #endif
 
-std::future<void> JSONIOHandler::flush(internal::ParsedFlushParams &)
+std::future<void> JSONIOHandler::flush_impl(internal::ParsedFlushParams &)
 {
     return m_impl.flush();
 }
diff --git a/src/IO/JSON/JSONIOHandlerImpl.cpp b/src/IO/JSON/JSONIOHandlerImpl.cpp
index 59541c1e30..b93f78e490 100644
--- a/src/IO/JSON/JSONIOHandlerImpl.cpp
+++ b/src/IO/JSON/JSONIOHandlerImpl.cpp
@@ -1146,6 +1146,13 @@ void JSONIOHandlerImpl::writeDataset(
         access::write(m_handler->m_backendAccess),
         "[JSON] Cannot write data in read-only mode.");
 
+    if (parameters.memorySelection.has_value())
+    {
+        throw error::OperationUnsupportedInBackend(
+            "JSON",
+            "Non-contiguous memory selections not supported in JSON backend.");
+    }
+
     auto pos = setAndGetFilePosition(writable);
     auto file = refreshFileFromParent(writable);
     auto &j = obtainJsonContents(writable);
diff --git a/src/LoadStoreChunk.cpp b/src/LoadStoreChunk.cpp
new file mode 100644
index 0000000000..1ee646948b
--- /dev/null
+++ b/src/LoadStoreChunk.cpp
@@ -0,0 +1,386 @@
+
+
+#include "openPMD/LoadStoreChunk.hpp"
+#include "openPMD/Datatype.hpp"
+#include "openPMD/RecordComponent.hpp"
+#include "openPMD/Span.hpp"
+#include "openPMD/auxiliary/Memory.hpp"
+#include "openPMD/auxiliary/ShareRawInternal.hpp"
+#include "openPMD/auxiliary/TypeTraits.hpp"
+#include "openPMD/auxiliary/UniquePtr.hpp"
+
+// comment to keep clang-format from reordering
+#include "openPMD/DatatypeMacros.hpp"
+#include "openPMD/backend/Attributable.hpp"
+
+#include <future>
+#include <memory>
+#include <optional>
+#include <stdexcept>
+
+namespace openPMD
+{
+namespace
+{
+    template <typename T>
+    auto asWriteBuffer(std::shared_ptr<T> &&ptr) -> auxiliary::WriteBuffer
+    {
+        /* std::static_pointer_cast correctly reference-counts the pointer */
+        return auxiliary::WriteBuffer(
+            std::static_pointer_cast<void const>(std::move(ptr)));
+    }
+    template <typename T>
+    auto asWriteBuffer(UniquePtrWithLambda<T> &&ptr) -> auxiliary::WriteBuffer
+    {
+        return auxiliary::WriteBuffer(
+            std::move(ptr).template static_cast_<void>());
+    }
+
+    /*
+     * There is no backend support currently for const unique pointers.
+     * We support these mostly for providing a clean API to users that have such
+     * pointers and want to store from them, but there will be no
+     * backend-specific optimizations for such buffers as there are for
+     * non-const unique pointers.
+     */
+    template <typename T>
+    auto asWriteBuffer(UniquePtrWithLambda<T const> &&ptr)
+        -> auxiliary::WriteBuffer
+    {
+        auto raw_ptr = ptr.release();
+        return asWriteBuffer(
+            std::shared_ptr<T const>{
+                raw_ptr,
+                [deleter = std::move(ptr.get_deleter())](
+                    auto const *delete_me) { deleter(delete_me); }});
+    }
+} // namespace
+
+namespace core
+{
+    ConfigureLoadStore::ConfigureLoadStore(RecordComponent &rc) : m_rc(rc)
+    {}
+
+    auto ConfigureLoadStore::dim() const -> uint8_t
+    {
+        return m_rc.getDimensionality();
+    }
+
+    auto ConfigureLoadStore::storeChunkConfig() -> internal::LoadStoreConfig
+    {
+        return internal::LoadStoreConfig{getOffset(), getExtent()};
+    }
+
+    auto ConfigureLoadStore::deferFlush(Attributable &attr)
+    {
+        auto index = attr.IOHandler()->m_flushCounter;
+        return [attr,
+                old_index = *index,
+                current_index = std::weak_ptr(index)]() mutable {
+            auto lock_current_index = current_index.lock();
+            if (!lock_current_index || *lock_current_index >= old_index)
+            {
+                return;
+            }
+            attr.seriesFlush();
+        };
+    }
+
+    auto ConfigureLoadStore::getOffset() -> Offset const &
+    {
+        if (!m_offset.has_value())
+        {
+            if (m_rc.joinedDimension().has_value())
+            {
+                m_offset = std::make_optional<Offset>();
+            }
+            else
+            {
+                m_offset = std::make_optional<Offset>(dim(), 0);
+            }
+        }
+        return *m_offset;
+    }
+
+    auto ConfigureLoadStore::getExtent() -> Extent const &
+    {
+        if (!m_extent.has_value())
+        {
+            m_extent = std::make_optional<Extent>(m_rc.getExtent());
+            if (m_offset.has_value())
+            {
+                auto it_o = m_offset->begin();
+                auto end_o = m_offset->end();
+                auto it_e = m_extent->begin();
+                auto end_e = m_extent->end();
+                for (; it_o != end_o && it_e != end_e; ++it_e, ++it_o)
+                {
+                    *it_e -= *it_o;
+                }
+            }
+        }
+        return *m_extent;
+    }
+
+    template <typename T>
+    auto ConfigureLoadStore::enqueueStore() -> DynamicMemoryView<T>
+    {
+        return m_rc.storeChunkSpan_impl<T>(storeChunkConfig());
+    }
+
+    template <typename T>
+    auto ConfigureLoadStore::enqueueLoad()
+        -> auxiliary::DeferredComputation<std::shared_ptr<T>>
+    {
+        auto res = m_rc.loadChunkAllocate_impl<T>(storeChunkConfig());
+        return auxiliary::DeferredComputation<std::shared_ptr<T>>(
+            [res_lambda = std::move(res), dflush = deferFlush(m_rc)]() mutable {
+                dflush();
+                return res_lambda;
+            });
+    }
+
+    template <typename T>
+    auto ConfigureLoadStore::load(EnqueuePolicy ep) -> std::shared_ptr<T>
+    {
+        auto res = m_rc.loadChunkAllocate_impl<T>(storeChunkConfig());
+        switch (ep)
+        {
+        case EnqueuePolicy::Defer:
+            break;
+        case EnqueuePolicy::Immediate:
+            m_rc.seriesFlush();
+            break;
+        }
+        return res;
+    }
+
+    struct VisitorEnqueueLoadVariant
+    {
+        template <typename T, typename F>
+        static auto
+        call(RecordComponent &rc, internal::LoadStoreConfig cfg, F &&dflush)
+            -> auxiliary::DeferredComputation<
+                auxiliary::detail::shared_ptr_dataset_types>
+        {
+            auto res = rc.loadChunkAllocate_impl<T>(std::move(cfg));
+            return auxiliary::DeferredComputation<
+                auxiliary::detail::shared_ptr_dataset_types>(
+                [res_lambda = std::move(res),
+                 dflush_lambda = std::forward<F>(dflush)]() mutable
+                    -> auxiliary::detail::shared_ptr_dataset_types {
+                    dflush_lambda();
+                    return res_lambda;
+                });
+        }
+    };
+
+    auto ConfigureLoadStore::enqueueLoadVariant()
+        -> auxiliary::DeferredComputation<
+            auxiliary::detail::shared_ptr_dataset_types>
+    {
+        return m_rc.visit<VisitorEnqueueLoadVariant>(
+            this->storeChunkConfig(), deferFlush(m_rc));
+    }
+
+    struct VisitorLoadVariant
+    {
+        template <typename T>
+        static auto call(RecordComponent &rc, internal::LoadStoreConfig cfg)
+            -> auxiliary::detail::shared_ptr_dataset_types
+        {
+            return rc.loadChunkAllocate_impl<T>(std::move(cfg));
+        }
+    };
+
+    auto ConfigureLoadStore::loadVariant(EnqueuePolicy ep)
+        -> auxiliary::detail::shared_ptr_dataset_types
+    {
+        auto res = m_rc.visit<VisitorLoadVariant>(this->storeChunkConfig());
+        switch (ep)
+        {
+        case EnqueuePolicy::Defer:
+            break;
+        case EnqueuePolicy::Immediate:
+            m_rc.seriesFlush();
+            break;
+        }
+        return res;
+    }
+
+    template <typename Ptr_Type>
+    ConfigureStoreChunkFromBuffer<Ptr_Type>::ConfigureStoreChunkFromBuffer(
+        Ptr_Type buffer, ConfigureLoadStore &&core)
+        : ConfigureLoadStore(std::move(core)), m_buffer(std::move(buffer))
+    {}
+
+    template <typename Ptr_Type>
+    auto ConfigureStoreChunkFromBuffer<Ptr_Type>::storeChunkConfig()
+        -> internal::LoadStoreConfigWithBuffer
+    {
+        return internal::LoadStoreConfigWithBuffer{
+            this->getOffset(), this->getExtent(), m_mem_select};
+    }
+
+    template <typename Ptr_Type>
+    auto ConfigureStoreChunkFromBuffer<Ptr_Type>::enqueueStore()
+        -> auxiliary::DeferredComputation<void>
+    {
+        this->m_rc.storeChunk_impl(
+            asWriteBuffer(std::move(m_buffer)),
+            determineDatatype<auxiliary::IsPointer_t<Ptr_Type>>(),
+            storeChunkConfig());
+        return auxiliary::DeferredComputation<void>(
+            [dflush = deferFlush(m_rc)]() mutable -> void { dflush(); });
+    }
+
+    template <typename Ptr_Type>
+    auto ConfigureStoreChunkFromBuffer<Ptr_Type>::store(EnqueuePolicy ep)
+        -> void
+    {
+        this->m_rc.storeChunk_impl(
+            asWriteBuffer(std::move(m_buffer)),
+            determineDatatype<auxiliary::IsPointer_t<Ptr_Type>>(),
+            storeChunkConfig());
+        switch (ep)
+        {
+        case EnqueuePolicy::Defer:
+            break;
+        case EnqueuePolicy::Immediate:
+            m_rc.seriesFlush();
+            break;
+        }
+    }
+
+    template <typename Ptr_Type>
+    auto ConfigureLoadStoreFromBuffer<Ptr_Type>::enqueueLoad()
+        -> auxiliary::DeferredComputation<void>
+    {
+        static_assert(
+            std::is_same_v<
+                Ptr_Type,
+                std::shared_ptr<
+                    std::remove_cv_t<typename Ptr_Type::element_type>>>,
+            "ConfigureLoadStoreFromBuffer must be instantiated with a "
+            "non-const "
+            "shared_ptr type.");
+        this->m_rc.loadChunk_impl(
+            std::move(this->m_buffer), this->storeChunkConfig());
+        return auxiliary::DeferredComputation<void>(
+            [dflush = this->deferFlush(this->m_rc)]() mutable -> void {
+                dflush();
+            });
+    }
+
+    template <typename Ptr_Type>
+    auto ConfigureLoadStoreFromBuffer<Ptr_Type>::load(EnqueuePolicy ep) -> void
+    {
+        this->m_rc.loadChunk_impl(
+            std::move(this->m_buffer), this->storeChunkConfig());
+        switch (ep)
+        {
+
+        case EnqueuePolicy::Defer:
+            break;
+        case EnqueuePolicy::Immediate:
+            this->m_rc.seriesFlush();
+            break;
+        }
+    }
+} // namespace core
+
+namespace compose
+{
+    template <typename ChildClass>
+    auto ConfigureLoadStore<ChildClass>::extent(Extent extent) -> ChildClass &
+    {
+        static_cast<ChildClass *>(this)->m_extent =
+            std::make_optional<Extent>(std::move(extent));
+        return *static_cast<ChildClass *>(this);
+    }
+
+    template <typename ChildClass>
+    auto ConfigureLoadStore<ChildClass>::offset(Offset offset) -> ChildClass &
+    {
+        static_cast<ChildClass *>(this)->m_offset =
+            std::make_optional<Offset>(std::move(offset));
+        return *static_cast<ChildClass *>(this);
+    }
+
+    template <typename ChildClass>
+    auto ConfigureStoreChunkFromBuffer<ChildClass>::memorySelection(
+        MemorySelection sel) -> ChildClass &
+    {
+        static_cast<ChildClass *>(this)->m_mem_select =
+            std::make_optional<MemorySelection>(std::move(sel));
+        return *static_cast<ChildClass *>(this);
+    }
+} // namespace compose
+
+template class compose::ConfigureLoadStore<ConfigureLoadStore>;
+
+// need this for clang-tidy
+#define OPENPMD_ARRAY(type) type[]
+#define OPENPMD_APPLY_TEMPLATE(template_, type) template_<type>
+
+#define INSTANTIATE_METHOD_TEMPLATES(dtype)                                    \
+    template auto core::ConfigureLoadStore::enqueueLoad()                      \
+        -> auxiliary::DeferredComputation<OPENPMD_APPLY_TEMPLATE(              \
+            std::shared_ptr, dtype)>;                                          \
+    template auto core::ConfigureLoadStore::load(EnqueuePolicy)                \
+        ->std::shared_ptr<dtype>;
+#define INSTANTIATE_METHOD_TEMPLATES_WITH_AND_WITHOUT_EXTENT(type)             \
+    INSTANTIATE_METHOD_TEMPLATES(type)                                         \
+    INSTANTIATE_METHOD_TEMPLATES(OPENPMD_ARRAY(type))                          \
+    template auto core::ConfigureLoadStore::enqueueStore()                     \
+        -> DynamicMemoryView<type>;
+
+OPENPMD_FOREACH_DATASET_DATATYPE(
+    INSTANTIATE_METHOD_TEMPLATES_WITH_AND_WITHOUT_EXTENT)
+
+#undef INSTANTIATE_METHOD_TEMPLATES
+#undef INSTANTIATE_METHOD_TEMPLATES_WITH_AND_WITHOUT_EXTENT
+
+#define INSTANTIATE_HALF(pointer_type)                                         \
+    template class OPENPMD_APPLY_TEMPLATE(                                     \
+        ConfigureStoreChunkFromBuffer, pointer_type);                          \
+    template class core::OPENPMD_APPLY_TEMPLATE(                               \
+        ConfigureStoreChunkFromBuffer, pointer_type);                          \
+    template class compose::ConfigureLoadStore<OPENPMD_APPLY_TEMPLATE(         \
+        ConfigureStoreChunkFromBuffer, pointer_type)>;                         \
+    template class compose::ConfigureStoreChunkFromBuffer<                     \
+        OPENPMD_APPLY_TEMPLATE(ConfigureStoreChunkFromBuffer, pointer_type)>;
+
+#define INSTANTIATE_FULL(pointer_type)                                         \
+    INSTANTIATE_HALF(pointer_type)                                             \
+    template class OPENPMD_APPLY_TEMPLATE(                                     \
+        ConfigureLoadStoreFromBuffer, pointer_type);                           \
+    template class core::OPENPMD_APPLY_TEMPLATE(                               \
+        ConfigureLoadStoreFromBuffer, pointer_type);                           \
+    template class compose::ConfigureLoadStore<OPENPMD_APPLY_TEMPLATE(         \
+        ConfigureLoadStoreFromBuffer, pointer_type)>;                          \
+    template class compose::ConfigureStoreChunkFromBuffer<                     \
+        OPENPMD_APPLY_TEMPLATE(ConfigureLoadStoreFromBuffer, pointer_type)>;
+
+#define INSTANTIATE_STORE_CHUNK_FROM_BUFFER(dtype)                             \
+    INSTANTIATE_FULL(std::shared_ptr<dtype>)                                   \
+    INSTANTIATE_HALF(std::shared_ptr<dtype const>)                             \
+    INSTANTIATE_HALF(UniquePtrWithLambda<dtype>)                               \
+    INSTANTIATE_HALF(UniquePtrWithLambda<dtype const>)
+
+OPENPMD_FOREACH_DATASET_DATATYPE(INSTANTIATE_STORE_CHUNK_FROM_BUFFER)
+
+#undef INSTANTIATE_STORE_CHUNK_FROM_BUFFER
+#undef INSTANTIATE_METHOD_TEMPLATES
+#undef INSTANTIATE_FULL
+#undef INSTANTIATE_HALF
+#undef OPENPMD_ARRAY
+#undef OPENPMD_APPLY_TEMPLATE
+
+ConfigureLoadStore::ConfigureLoadStore(RecordComponent &rc)
+    : core::ConfigureLoadStore{rc}
+{}
+ConfigureLoadStore::ConfigureLoadStore(core::ConfigureLoadStore &&core)
+    : core::ConfigureLoadStore{std::move(core)}
+{}
+} // namespace openPMD
diff --git a/src/RecordComponent.cpp b/src/RecordComponent.cpp
index eb41dddd19..6d2297c4f5 100644
--- a/src/RecordComponent.cpp
+++ b/src/RecordComponent.cpp
@@ -23,6 +23,7 @@
 #include "openPMD/DatatypeHelpers.hpp"
 #include "openPMD/Error.hpp"
 #include "openPMD/IO/Format.hpp"
+#include "openPMD/LoadStoreChunk.hpp"
 #include "openPMD/Series.hpp"
 #include "openPMD/auxiliary/Environment.hpp"
 #include "openPMD/auxiliary/Memory.hpp"
@@ -34,6 +35,9 @@
 // comment so clang-format does not move this
 #include "openPMD/DatatypeMacros.hpp"
 
+// comment
+#include "openPMD/DatatypeMacros.hpp"
+
 #include <algorithm>
 #include <climits>
 #include <complex>
@@ -179,6 +183,73 @@ auto resource(T &t) -> attribute_types &
     return t.template resource<attribute_types>();
 }
 
+ConfigureLoadStore RecordComponent::prepareLoadStore()
+{
+    return ConfigureLoadStore{*this};
+}
+
+namespace
+{
+#if (defined(_LIBCPP_VERSION) && _LIBCPP_VERSION < 11000) ||                   \
+    (defined(__apple_build_version__) && __clang_major__ < 14)
+    template <typename T>
+    auto createSpanBufferFallback(size_t size) -> UniquePtrWithLambda<T>
+    {
+        return UniquePtrWithLambda<T>{
+            new T[size], [](auto *ptr) { delete[] ptr; }};
+    }
+#else
+    template <typename T>
+    auto createSpanBufferFallback(size_t size) -> std::unique_ptr<T[]>
+    {
+        return std::unique_ptr<T[]>{new T[size]};
+    }
+#endif
+} // namespace
+
+template <typename T>
+DynamicMemoryView<T>
+RecordComponent::storeChunkSpan_impl(internal::LoadStoreConfig cfg)
+{
+    return storeChunkSpanCreateBuffer_impl<T>(
+        std::move(cfg), &createSpanBufferFallback<T>);
+}
+
+template <typename T_with_extent>
+std::shared_ptr<T_with_extent>
+RecordComponent::loadChunkAllocate_impl(internal::LoadStoreConfig cfg)
+{
+    using T = std::remove_extent_t<T_with_extent>;
+    // static_assert(!std::is_same_v<T, std::string>, "EVIL");
+    auto [o, e] = std::move(cfg);
+
+    size_t numPoints = 1;
+    for (auto val : e)
+    {
+        numPoints *= val;
+    }
+
+#if (defined(_LIBCPP_VERSION) && _LIBCPP_VERSION < 11000) ||                   \
+    (defined(__apple_build_version__) && __clang_major__ < 14)
+    auto newData = std::shared_ptr<T_with_extent>(
+        new T[numPoints], [](T *p) { delete[] p; });
+    prepareLoadStore()
+        .offset(std::move(o))
+        .extent(std::move(e))
+        .withSharedPtr(newData)
+        .load(EnqueuePolicy::Defer);
+    return newData;
+#else
+    auto newData = std::shared_ptr<T[]>(new T[numPoints]);
+    prepareLoadStore()
+        .offset(std::move(o))
+        .extent(std::move(e))
+        .withSharedPtr(newData)
+        .load(EnqueuePolicy::Defer);
+    return std::static_pointer_cast<T_with_extent>(std::move(newData));
+#endif
+}
+
 RecordComponent::RecordComponent() : BaseRecordComponent(NoInit())
 {
     setData(std::make_shared<Data_t>());
@@ -623,14 +694,18 @@ void RecordComponent::readBase(bool require_unit_si)
     }
 }
 
-void RecordComponent::storeChunk(
-    auxiliary::WriteBuffer buffer, Datatype dtype, Offset o, Extent e)
+void RecordComponent::storeChunk_impl(
+    auxiliary::WriteBuffer buffer,
+    Datatype dtype,
+    internal::LoadStoreConfigWithBuffer cfg)
 {
+    auto [o, e, memorySelection] = std::move(cfg);
     verifyChunk(dtype, o, e);
 
     Parameter<Operation::WRITE_DATASET> dWrite;
     dWrite.offset = std::move(o);
     dWrite.extent = std::move(e);
+    dWrite.memorySelection = memorySelection;
     dWrite.dtype = dtype;
     /* std::static_pointer_cast correctly reference-counts the pointer */
     dWrite.data = std::move(buffer);
@@ -754,40 +829,22 @@ template <typename T>
 std::shared_ptr<T> RecordComponent::loadChunk(Offset o, Extent e)
 {
     uint8_t dim = getDimensionality();
+    auto operation = prepareLoadStore();
 
     // default arguments
     //   offset = {0u}: expand to right dim {0u, 0u, ...}
-    Offset offset = o;
-    if (o.size() == 1u && o.at(0) == 0u && dim > 1u)
-        offset = Offset(dim, 0u);
+    if (o.size() != 1u || o.at(0) != 0u || dim <= 1u)
+    {
+        operation.offset(std::move(o));
+    }
 
     //   extent = {-1u}: take full size
-    Extent extent(dim, 1u);
-    if (e.size() == 1u && e.at(0) == -1u)
+    if (e.size() != 1u || e.at(0) != -1u)
     {
-        extent = getExtent();
-        for (uint8_t i = 0u; i < dim; ++i)
-            extent[i] -= offset[i];
+        operation.extent(std::move(e));
     }
-    else
-        extent = e;
 
-    uint64_t numPoints = 1u;
-    for (auto const &dimensionSize : extent)
-        numPoints *= dimensionSize;
-
-#if (defined(_LIBCPP_VERSION) && _LIBCPP_VERSION < 11000) ||                   \
-    (defined(__apple_build_version__) && __clang_major__ < 14)
-    auto newData =
-        std::shared_ptr<T>(new T[numPoints], [](T *p) { delete[] p; });
-    loadChunk(newData, offset, extent);
-    return newData;
-#else
-    auto newData = std::shared_ptr<std::remove_extent_t<T>[]>(
-        new std::remove_extent_t<T>[numPoints]);
-    loadChunk(newData, offset, extent);
-    return std::static_pointer_cast<T>(std::move(newData));
-#endif
+    return operation.load<T>(EnqueuePolicy::Defer);
 }
 
 namespace detail
@@ -812,9 +869,17 @@ namespace detail
     };
 } // namespace detail
 
-template <typename T>
-void RecordComponent::loadChunk(std::shared_ptr<T> data, Offset o, Extent e)
+template <typename T_with_extent>
+void RecordComponent::loadChunk_impl(
+    std::shared_ptr<T_with_extent> data,
+    internal::LoadStoreConfigWithBuffer cfg)
 {
+    if (cfg.memorySelection.has_value())
+    {
+        throw error::WrongAPIUsage(
+            "Unsupported: Memory selections in chunk loading.");
+    }
+    using T = std::remove_cv_t<std::remove_extent_t<T_with_extent>>;
     Datatype dtype = determineDatatype(data);
     /*
      * For constant components, we implement type conversion, so there is
@@ -839,24 +904,8 @@ void RecordComponent::loadChunk(std::shared_ptr<T> data, Offset o, Extent e)
             throw std::runtime_error(err_msg);
         }
 
-    uint8_t dim = getDimensionality();
-
-    // default arguments
-    //   offset = {0u}: expand to right dim {0u, 0u, ...}
-    Offset offset = o;
-    if (o.size() == 1u && o.at(0) == 0u && dim > 1u)
-        offset = Offset(dim, 0u);
-
-    //   extent = {-1u}: take full size
-    Extent extent(dim, 1u);
-    if (e.size() == 1u && e.at(0) == -1u)
-    {
-        extent = getExtent();
-        for (uint8_t i = 0u; i < dim; ++i)
-            extent[i] -= offset[i];
-    }
-    else
-        extent = e;
+    auto dim = getDimensionality();
+    auto [offset, extent, memorySelection] = std::move(cfg);
 
     if (extent.size() != dim || offset.size() != dim)
     {
@@ -875,9 +924,6 @@ void RecordComponent::loadChunk(std::shared_ptr<T> data, Offset o, Extent e)
                 "Chunk does not reside inside dataset (Dimension on index " +
                 std::to_string(i) + ". DS: " + std::to_string(dse[i]) +
                 " - Chunk: " + std::to_string(offset[i] + extent[i]) + ")");
-    if (!data)
-        throw std::runtime_error(
-            "Unallocated pointer passed during chunk loading.");
 
     auto &rc = get();
     if (constant())
@@ -892,7 +938,7 @@ void RecordComponent::loadChunk(std::shared_ptr<T> data, Offset o, Extent e)
 
         if (val.has_value())
         {
-            T *raw_ptr = data.get();
+            auto raw_ptr = static_cast<T *>(data.get());
             std::fill(raw_ptr, raw_ptr + numPoints, *val);
         }
         else
@@ -918,80 +964,76 @@ void RecordComponent::loadChunk(std::shared_ptr<T> data, Offset o, Extent e)
 }
 
 template <typename T>
-void RecordComponent::loadChunk(
-    std::shared_ptr<T[]> ptr, Offset offset, Extent extent)
+void RecordComponent::loadChunk(std::shared_ptr<T> data, Offset o, Extent e)
 {
-    loadChunk(
-        std::static_pointer_cast<T>(std::move(ptr)),
-        std::move(offset),
-        std::move(extent));
+    // static_assert(!std::is_same_v<T_with_extent, std::string>, "EVIL");
+    uint8_t dim = getDimensionality();
+    auto operation = prepareLoadStore();
+
+    // default arguments
+    //   offset = {0u}: expand to right dim {0u, 0u, ...}
+    if (o.size() != 1u || o.at(0) != 0u || dim <= 1u)
+    {
+        operation.offset(std::move(o));
+    }
+
+    //   extent = {-1u}: take full size
+    if (e.size() != 1u || e.at(0) != -1u)
+    {
+        operation.extent(std::move(e));
+    }
+
+    operation.withSharedPtr(std::move(data)).load(EnqueuePolicy::Defer);
 }
 
 template <typename T>
 void RecordComponent::loadChunkRaw(T *ptr, Offset offset, Extent extent)
 {
-    loadChunk(auxiliary::shareRaw(ptr), std::move(offset), std::move(extent));
+    prepareLoadStore()
+        .offset(std::move(offset))
+        .extent(std::move(extent))
+        .withRawPtr(ptr)
+        .load(EnqueuePolicy::Defer);
 }
 
 template <typename T>
 void RecordComponent::storeChunk(std::shared_ptr<T> data, Offset o, Extent e)
 {
-    if (!data)
-        throw std::runtime_error(
-            "Unallocated pointer passed during chunk store.");
-    Datatype dtype = determineDatatype(data);
-
-    /* std::static_pointer_cast correctly reference-counts the pointer */
-    storeChunk(
-        auxiliary::WriteBuffer(std::static_pointer_cast<void const>(data)),
-        dtype,
-        std::move(o),
-        std::move(e));
+    prepareLoadStore()
+        .offset(std::move(o))
+        .extent(std::move(e))
+        .withSharedPtr(std::move(data))
+        .store(EnqueuePolicy::Defer);
 }
 
 template <typename T>
 void RecordComponent::storeChunk(
     UniquePtrWithLambda<T> data, Offset o, Extent e)
 {
-    if (!data)
-        throw std::runtime_error(
-            "Unallocated pointer passed during chunk store.");
-    Datatype dtype = determineDatatype<>(data);
-
-    storeChunk(
-        auxiliary::WriteBuffer{std::move(data).template static_cast_<void>()},
-        dtype,
-        std::move(o),
-        std::move(e));
-}
-
-template <typename T>
-void RecordComponent::storeChunk(std::shared_ptr<T[]> data, Offset o, Extent e)
-{
-    storeChunk(
-        std::static_pointer_cast<T const>(std::move(data)),
-        std::move(o),
-        std::move(e));
+    prepareLoadStore()
+        .offset(std::move(o))
+        .extent(std::move(e))
+        .withUniquePtr(std::move(data))
+        .store(EnqueuePolicy::Defer);
 }
 
 template <typename T>
 void RecordComponent::storeChunkRaw(T const *ptr, Offset offset, Extent extent)
 {
-    storeChunk(auxiliary::shareRaw(ptr), std::move(offset), std::move(extent));
+    prepareLoadStore()
+        .offset(std::move(offset))
+        .extent(std::move(extent))
+        .withRawPtr(ptr)
+        .store(EnqueuePolicy::Defer);
 }
 
 template <typename T>
 DynamicMemoryView<T> RecordComponent::storeChunk(Offset offset, Extent extent)
 {
-    return storeChunk<T>(std::move(offset), std::move(extent), [](size_t size) {
-#if (defined(_LIBCPP_VERSION) && _LIBCPP_VERSION < 11000) ||                   \
-    (defined(__apple_build_version__) && __clang_major__ < 14)
-        return UniquePtrWithLambda<T>{
-            new T[size], [](auto *ptr) { delete[] ptr; }};
-#else
-        return std::unique_ptr<T[]>{new T[size]};
-#endif
-    });
+    return prepareLoadStore()
+        .offset(std::move(offset))
+        .extent(std::move(extent))
+        .enqueueStore<T>();
 }
 
 template <typename T>
@@ -1005,10 +1047,6 @@ void RecordComponent::verifyChunk(Offset const &o, Extent const &e) const
 #define OPENPMD_ARRAY(type) type[]
 
 #define OPENPMD_INSTANTIATE_BASIC(type)                                        \
-    template void RecordComponent::loadChunk<type>(                            \
-        std::shared_ptr<type> data, Offset o, Extent e);                       \
-    template void RecordComponent::loadChunk<type>(                            \
-        std::shared_ptr<OPENPMD_ARRAY(type)> data, Offset o, Extent e);        \
     template void RecordComponent::loadChunkRaw<type>(                         \
         OPENPMD_PTR(type) ptr, Offset offset, Extent extent);                  \
     template void RecordComponent::verifyChunk<type>(                          \
@@ -1016,21 +1054,27 @@ void RecordComponent::verifyChunk(Offset const &o, Extent const &e) const
     template DynamicMemoryView<type> RecordComponent::storeChunk<type>(        \
         Offset offset, Extent extent);                                         \
     template void RecordComponent::storeChunkRaw<type>(                        \
-        OPENPMD_PTR(type const) ptr, Offset offset, Extent extent);
+        OPENPMD_PTR(type const) ptr, Offset offset, Extent extent);            \
+    template DynamicMemoryView<type> RecordComponent::storeChunkSpan_impl(     \
+        internal::LoadStoreConfig cfg);
 
-#define OPENPMD_INSTANTIATE_CONST_AND_NONCONST(type)                           \
-    template void RecordComponent::storeChunk<type>(                           \
-        std::shared_ptr<type> data, Offset o, Extent e);                       \
-    template void RecordComponent::storeChunk<type>(                           \
-        std::shared_ptr<OPENPMD_ARRAY(type)> data, Offset o, Extent e);
+#define OPENPMD_INSTANTIATE_CONST_AND_NONCONST(type)
 
 #define OPENPMD_INSTANTIATE_WITH_AND_WITHOUT_EXTENT(type)                      \
+    template void RecordComponent::loadChunk<type>(                            \
+        std::shared_ptr<type> data, Offset o, Extent e);                       \
     template std::shared_ptr<type> RecordComponent::loadChunk<type>(           \
         Offset o, Extent e);                                                   \
     template void RecordComponent::storeChunk<type>(                           \
-        UniquePtrWithLambda<type> data, Offset o, Extent e);
+        UniquePtrWithLambda<type> data, Offset o, Extent e);                   \
+    template void RecordComponent::loadChunk_impl(                             \
+        std::shared_ptr<type> data, internal::LoadStoreConfigWithBuffer cfg);  \
+    template std::shared_ptr<type> RecordComponent::loadChunkAllocate_impl(    \
+        internal::LoadStoreConfig cfg);
 
 #define OPENPMD_INSTANTIATE_FULLMATRIX(type)                                   \
+    template void RecordComponent::storeChunk<type>(                           \
+        std::shared_ptr<type> data, Offset o, Extent e);                       \
     template RecordComponent &RecordComponent::makeConstant<type>(type);       \
     template RecordComponent &RecordComponent::makeEmpty<type>(                \
         uint8_t dimensions);
diff --git a/src/auxiliary/Future.cpp b/src/auxiliary/Future.cpp
new file mode 100644
index 0000000000..6e91fb7119
--- /dev/null
+++ b/src/auxiliary/Future.cpp
@@ -0,0 +1,83 @@
+#include "openPMD/auxiliary/Future.hpp"
+#include "openPMD/RecordComponent.hpp"
+
+#include <iostream>
+#include <memory>
+#include <stdexcept>
+
+// comment
+
+#include "openPMD/DatatypeMacros.hpp"
+
+namespace openPMD::auxiliary
+{
+
+template <typename T>
+DeferredComputation<T>::DeferredComputation(task_type task)
+    : m_task([wrapped_task = std::move(task), this]() {
+        if (!this->m_valid)
+        {
+            throw std::runtime_error(
+                "[DeferredComputation] No valid state. Probably already "
+                "computed.");
+        }
+        this->m_valid = false;
+        return std::move(wrapped_task)();
+    })
+    , m_valid(true)
+{}
+
+template <typename T>
+DeferredComputation<T>::~DeferredComputation()
+{
+    if (m_valid)
+    {
+        try
+        {
+            get();
+        }
+        catch (std::exception const &e)
+        {
+            std::cerr << "[DeferredComputation] Error in destructor: '"
+                      << e.what() << "'." << std::endl;
+        }
+        catch (...)
+        {
+            std::cerr << "[DeferredComputation] Unknown error in destructor."
+                      << std::endl;
+        }
+    }
+}
+
+template <typename T>
+auto DeferredComputation<T>::get() -> T
+{
+    return m_task();
+}
+
+template <typename T>
+auto DeferredComputation<T>::valid() const noexcept -> bool
+{
+    return m_valid;
+}
+
+template class DeferredComputation<void>;
+template class DeferredComputation<RecordComponent::shared_ptr_dataset_types>;
+
+// need this for clang-tidy
+#define OPENPMD_ARRAY(type) type[]
+#define OPENPMD_APPLY_TEMPLATE(template_, type) template_<type>
+
+#define INSTANTIATE_FUTURE(dtype)                                              \
+    template class DeferredComputation<OPENPMD_APPLY_TEMPLATE(                 \
+        std::shared_ptr, dtype)>;
+#define INSTANTIATE_FUTURE_WITH_AND_WITHOUT_EXTENT(type)                       \
+    INSTANTIATE_FUTURE(type) INSTANTIATE_FUTURE(OPENPMD_ARRAY(type))
+OPENPMD_FOREACH_NONVECTOR_DATATYPE(INSTANTIATE_FUTURE_WITH_AND_WITHOUT_EXTENT)
+#undef INSTANTIATE_FUTURE
+#undef INSTANTIATE_FUTURE_WITH_AND_WITHOUT_EXTENT
+#undef OPENPMD_ARRAY
+#undef OPENPMD_APPLY_TEMPLATE
+} // namespace openPMD::auxiliary
+
+#include "openPMD/UndefDatatypeMacros.hpp"
diff --git a/src/auxiliary/UniquePtr.cpp b/src/auxiliary/UniquePtr.cpp
index 6625ca3a47..474441fdd3 100644
--- a/src/auxiliary/UniquePtr.cpp
+++ b/src/auxiliary/UniquePtr.cpp
@@ -99,9 +99,12 @@ UniquePtrWithLambda<T>::UniquePtrWithLambda(
         std::unique_ptr<type>);
 
 #define OPENPMD_INSTANTIATE_WITH_AND_WITHOUT_EXTENT(type)                      \
-    OPENPMD_INSTANTIATE(type) OPENPMD_INSTANTIATE(OPENPMD_ARRAY(type))
+    OPENPMD_INSTANTIATE(type)                                                  \
+    OPENPMD_INSTANTIATE(OPENPMD_ARRAY(type))                                   \
+    OPENPMD_INSTANTIATE(type const)                                            \
+    OPENPMD_INSTANTIATE(OPENPMD_ARRAY(type const))
 
-OPENPMD_FOREACH_DATASET_DATATYPE(OPENPMD_INSTANTIATE_WITH_AND_WITHOUT_EXTENT)
+OPENPMD_FOREACH_NONVECTOR_DATATYPE(OPENPMD_INSTANTIATE_WITH_AND_WITHOUT_EXTENT)
 // Instantiate this directly, do not instantiate the
 // `std::unique_ptr<void>`-based constructor.
 template class UniquePtrWithLambda<void>;
diff --git a/test/ParallelIOTest.cpp b/test/ParallelIOTest.cpp
index b05c778244..fdd1f26f74 100644
--- a/test/ParallelIOTest.cpp
+++ b/test/ParallelIOTest.cpp
@@ -453,18 +453,51 @@ void available_chunks_test(std::string const &file_ending)
 }
 )END";
 
-    std::vector<int> data{2, 4, 6, 8};
+    std::vector<int> xdata{2, 4, 6, 8};
+    std::vector<int> ydata{0, 0, 0, 0, 0, //
+                           0, 1, 2, 3, 0, //
+                           0, 4, 5, 6, 0, //
+                           0, 7, 8, 9, 0, //
+                           0, 0, 0, 0, 0};
+    std::vector<int> ydata_firstandlastrow{-1, -1, -1};
     {
         Series write(name, Access::CREATE, MPI_COMM_WORLD, parameters.str());
         Iteration it0 = write.iterations[0];
         auto E_x = it0.meshes["E"]["x"];
         E_x.resetDataset({Datatype::INT, {mpi_size, 4}});
-        E_x.storeChunk(data, {mpi_rank, 0}, {1, 4});
+        E_x.storeChunk(xdata, {mpi_rank, 0}, {1, 4});
+        auto E_y = it0.meshes["E"]["y"];
+        E_y.resetDataset({Datatype::INT, {5, 3ul * mpi_size}});
+        E_y.prepareLoadStore()
+            .withContiguousContainer(ydata_firstandlastrow)
+            .offset({0, 3ul * mpi_rank})
+            .extent({1, 3})
+            .enqueueStore();
+        E_y.prepareLoadStore()
+            .offset({1, 3ul * mpi_rank})
+            .extent({3, 3})
+            .withContiguousContainer(ydata)
+            .memorySelection({{1, 1}, {5, 5}})
+            .enqueueStore();
+        // if condition checks if this PR is available in ADIOS2:
+        // https://github.com/ornladios/ADIOS2/pull/4169
+        if constexpr (CanTheMemorySelectionBeReset)
+        {
+            E_y.prepareLoadStore()
+                .withContiguousContainer(ydata_firstandlastrow)
+                .offset({4, 3ul * mpi_rank})
+                .extent({1, 3})
+                .enqueueStore();
+        }
         it0.close();
     }
 
     {
-        Series read(name, Access::READ_ONLY, MPI_COMM_WORLD);
+        Series read(
+            name,
+            Access::READ_ONLY,
+            MPI_COMM_WORLD,
+            R"({"verify_homogeneous_extents": false})");
         Iteration it0 = read.iterations[0];
         auto E_x = it0.meshes["E"]["x"];
         ChunkTable table = E_x.availableChunks();
@@ -491,6 +524,42 @@ void available_chunks_test(std::string const &file_ending)
         {
             REQUIRE(ranks[i] == i);
         }
+
+        auto E_y = it0.meshes["E"]["y"];
+        auto width = E_y.getExtent()[1];
+        auto first_row =
+            E_y.prepareLoadStore().extent({1, width}).enqueueLoad<int>().get();
+        auto middle_rows = E_y.prepareLoadStore()
+                               .offset({1, 0})
+                               .extent({3, width})
+                               .enqueueLoad<int>()
+                               .get();
+        auto last_row =
+            E_y.prepareLoadStore().offset({4, 0}).enqueueLoad<int>().get();
+        read.flush();
+
+        for (auto row : [&]() -> std::vector<std::shared_ptr<int> *> {
+                 if constexpr (CanTheMemorySelectionBeReset)
+                 {
+                     return {&first_row, &last_row};
+                 }
+                 else
+                 {
+                     return {&first_row};
+                 }
+             }())
+        {
+            for (size_t i = 0; i < width; ++i)
+            {
+                REQUIRE(row->get()[i] == -1);
+            }
+        }
+        for (size_t i = 0; i < width * 3; ++i)
+        {
+            size_t row = i / width;
+            int required_value = row * 3 + (i % 3) + 1;
+            REQUIRE(middle_rows.get()[i] == required_value);
+        }
     }
 }
 
diff --git a/test/SerialIOTest.cpp b/test/SerialIOTest.cpp
index 7fd13822f3..3ec568b5ad 100644
--- a/test/SerialIOTest.cpp
+++ b/test/SerialIOTest.cpp
@@ -941,7 +941,11 @@ inline void constant_scalar(std::string const &file_ending)
             new unsigned int[6], [](unsigned int const *p) { delete[] p; });
         unsigned int e{0};
         std::generate(E.get(), E.get() + 6, [&e] { return e++; });
-        E_y.storeChunk(std::move(E), {0, 0, 0}, {1, 2, 3});
+        // check that const-type unique pointers work in the builder pattern
+        E_y.prepareLoadStore()
+            .extent({1, 2, 3})
+            .withUniquePtr(std::move(E).static_cast_<unsigned int const>())
+            .enqueueStore();
 
         // store a number of predefined attributes in E
         Mesh &E_mesh = s.snapshots()[1].meshes["E"];
@@ -1752,13 +1756,17 @@ inline void write_test(
     auto opaqueTypeDataset = rc.visit<ReadFromAnyType>();
 
     auto variantTypeDataset = rc.loadChunkVariant();
+    auto variantTypeDataset2 = rc.prepareLoadStore().enqueueLoadVariant().get();
     rc.seriesFlush();
-    std::visit(
-        [](auto &&shared_ptr) {
-            std::cout << "First value in loaded chunk: '" << shared_ptr.get()[0]
-                      << '\'' << std::endl;
-        },
-        variantTypeDataset);
+    for (auto ptr : {&variantTypeDataset, &variantTypeDataset2})
+    {
+        std::visit(
+            [](auto &&shared_ptr) {
+                std::cout << "First value in loaded chunk: '"
+                          << shared_ptr.get()[0] << '\'' << std::endl;
+            },
+            *ptr);
+    }
 
 #ifndef _WIN32
     if (test_rank_table)