diff --git a/CMakeLists.txt b/CMakeLists.txt
index 5fa5b1a0ca..587a2455a2 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
@@ -426,6 +428,7 @@ set(CORE_SOURCE
         src/backend/PatchRecord.cpp
         src/backend/PatchRecordComponent.cpp
         src/backend/Writable.cpp
+        src/backend/ScientificDefaults.cpp
         src/auxiliary/OneDimensionalBlockSlicer.cpp
         src/helper/list_series.cpp
         src/snapshots/ContainerImpls.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..e20c256a67 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"
@@ -30,6 +31,7 @@
 #include "openPMD/IO/AbstractIOHandler.hpp"
 #include "openPMD/IO/AbstractIOHandlerImpl.hpp"
 #include "openPMD/IO/AbstractIOHandlerImplCommon.hpp"
+#include "openPMD/IO/AbstractIOHandler_internal.hpp"
 #include "openPMD/IO/FlushParametersInternal.hpp"
 #include "openPMD/IO/IOTask.hpp"
 #include "openPMD/IO/InvalidatableFile.hpp"
@@ -509,6 +511,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 +625,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 +644,7 @@ class ADIOS2IOHandlerImpl
     {
         bool noGroupBased = false;
         bool blosc2bp5 = false;
+        bool memorySelection = false;
     } printedWarningsAlready;
 }; // ADIOS2IOHandlerImpl
 
@@ -942,7 +958,7 @@ class ADIOS2IOHandler : public AbstractIOHandler
         try
         {
             auto params = internal::defaultParsedFlushParams;
-            this->flush(params);
+            this->flush_impl(params);
         }
         catch (std::exception const &ex)
         {
@@ -962,9 +978,7 @@ class ADIOS2IOHandler : public AbstractIOHandler
 #if openPMD_HAVE_MPI
 
     ADIOS2IOHandler(
-        std::optional<std::unique_ptr<AbstractIOHandler>> initialize_from,
-        std::string path,
-        Access,
+        internal::AbstractIOHandlerInitFrom &&initialize_from,
         MPI_Comm,
         json::TracingJSON options,
         std::string engineType,
@@ -973,9 +987,7 @@ class ADIOS2IOHandler : public AbstractIOHandler
 #endif
 
     ADIOS2IOHandler(
-        std::optional<std::unique_ptr<AbstractIOHandler>> initialize_from,
-        std::string path,
-        Access,
+        internal::AbstractIOHandlerInitFrom &&initialize_from,
         json::TracingJSON options,
         std::string engineType,
         std::string specifiedExtension);
@@ -990,6 +1002,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..ae4078ec94 100644
--- a/include/openPMD/IO/AbstractIOHandler.hpp
+++ b/include/openPMD/IO/AbstractIOHandler.hpp
@@ -59,6 +59,11 @@ enum class FlushLevel
      * This mode defines a flush point (see docs/source/usage/workflow.rst.rst).
      */
     UserFlush,
+    /**
+     * Flush triggered by storeChunk in immediate flush mode.
+     * Must not perform operations enqueued in m_chunks.
+     */
+    ImmediateFlush,
     /**
      * Default mode, used when flushes are triggered internally, e.g. during
      * parsing to read attributes. Does not trigger a flush point.
@@ -81,6 +86,66 @@ enum class FlushLevel
     CreateOrOpenFiles
 };
 
+namespace flush_level
+{
+    inline constexpr auto global_flushpoint(FlushLevel fl)
+    {
+        switch (fl)
+        {
+        case FlushLevel::UserFlush:
+            return true;
+        case FlushLevel::ImmediateFlush:
+        case FlushLevel::InternalFlush:
+        case FlushLevel::SkeletonOnly:
+        case FlushLevel::CreateOrOpenFiles:
+            return false;
+        }
+        return false; // unreachable
+    }
+    inline constexpr auto write_datasets(FlushLevel fl)
+    {
+        switch (fl)
+        {
+        case FlushLevel::UserFlush:
+        case FlushLevel::ImmediateFlush:
+            return true;
+        case FlushLevel::InternalFlush:
+        case FlushLevel::SkeletonOnly:
+        case FlushLevel::CreateOrOpenFiles:
+            return false;
+        }
+        return false; // unreachable
+    }
+    inline constexpr auto write_attributes(FlushLevel fl)
+    {
+        switch (fl)
+        {
+        case FlushLevel::UserFlush:
+        case FlushLevel::ImmediateFlush:
+        case FlushLevel::InternalFlush:
+            return true;
+        case FlushLevel::SkeletonOnly:
+        case FlushLevel::CreateOrOpenFiles:
+            return false;
+        }
+        return false; // unreachable
+    }
+    inline constexpr auto flush_hierarchy(FlushLevel fl)
+    {
+        switch (fl)
+        {
+        case FlushLevel::UserFlush:
+        case FlushLevel::ImmediateFlush:
+        case FlushLevel::InternalFlush:
+        case FlushLevel::SkeletonOnly:
+            return true;
+        case FlushLevel::CreateOrOpenFiles:
+            return false;
+        }
+        return false; // unreachable
+    }
+} // namespace flush_level
+
 enum class OpenpmdStandard
 {
     v_1_0_0,
@@ -187,12 +252,64 @@ namespace internal
             return res;
         }
     }
+
+    /**************************************************************************
+     * Since the AbstractIOHandler is linked to every object of the
+     * frontend, it stores a number of members that are needed by methods
+     * traversing the object hierarchy. Those members are found in this struct
+     * from which AbstractIOHandler derives.
+     **************************************************************************/
+    struct GlobalParameters
+    {
+        GlobalParameters(Access at);
+
+        std::string directory;
+        /*
+         * Originally, the reason for distinguishing these two was that during
+         * parsing in reading access modes, the access type would be temporarily
+         * const_cast'ed to an access type that would support modifying
+         * the openPMD object model. Then, it would be const_cast'ed back to
+         * READ_ONLY, to disable further modifications.
+         * Due to this approach's tendency to cause subtle bugs, and due to its
+         * difficult debugging properties, this was replaced by the SeriesStatus
+         * enum, defined in this file.
+         * The distinction of backendAccess and frontendAccess stays relevant,
+         * since the frontend can use it in order to pretend to the backend that
+         * another access type is being used. This is used by the file-based
+         * append mode, which is entirely implemented by the frontend, which
+         * internally uses the backend in CREATE mode.
+         */
+        Access m_backendAccess;
+        Access m_frontendAccess;
+
+        /**
+         * This is to avoid that the destructor tries flushing again if an error
+         * happened. Otherwise, this would lead to confusing error messages.
+         * Initialized as false, set to true after successful construction.
+         * If flushing results in an error, set this back to false.
+         * The destructor will only attempt flushing again if this is true.
+         */
+        bool m_lastFlushSuccessful = false;
+        internal::SeriesStatus m_seriesStatus = internal::SeriesStatus::Default;
+        IterationEncoding m_encoding = IterationEncoding::groupBased;
+        OpenpmdStandard m_standard =
+            auxiliary::parseStandard(getStandardDefault());
+        bool m_verify_homogeneous_extents = true;
+        // If true, then flush directly upon storeChunk
+        bool m_flush_immediately = false;
+
+    protected:
+        explicit GlobalParameters();
+    };
 } // namespace internal
 
 namespace detail
 {
     class ADIOS2File;
-}
+    struct InitFrom_Tag
+    {};
+    constexpr InitFrom_Tag InitFrom_Tag_v;
+} // namespace detail
 
 /** Interface for communicating between logical and physically persistent data.
  *
@@ -202,7 +319,7 @@ namespace detail
  * scenarios it is therefore necessary to manually execute all operations
  * by calling AbstractIOHandler::flush().
  */
-class AbstractIOHandler
+class AbstractIOHandler : public internal::GlobalParameters
 {
     friend class Series;
     friend class ADIOS2IOHandlerImpl;
@@ -221,23 +338,16 @@ class AbstractIOHandler
 
 public:
 #if openPMD_HAVE_MPI
-    template <typename TracingJSON>
+    template <typename InitFrom, typename TracingJSON>
     AbstractIOHandler(
-        std::optional<std::unique_ptr<AbstractIOHandler>> initialize_from,
-        std::string path,
-        Access at,
-        TracingJSON &&jsonConfig,
-        MPI_Comm);
+        InitFrom &&initialize_from, TracingJSON &&jsonConfig, MPI_Comm);
 #endif
 
-    template <typename TracingJSON>
-    AbstractIOHandler(
-        std::optional<std::unique_ptr<AbstractIOHandler>> initialize_from,
-        std::string path,
-        Access at,
-        TracingJSON &&jsonConfig);
+    template <typename InitFrom, typename TracingJSON>
+    AbstractIOHandler(InitFrom &&initialize_from, TracingJSON &&jsonConfig);
 
-    AbstractIOHandler(std::optional<std::unique_ptr<AbstractIOHandler>>);
+    template <typename InitFrom>
+    AbstractIOHandler(detail::InitFrom_Tag, InitFrom &&);
 
     virtual ~AbstractIOHandler();
 
@@ -265,56 +375,23 @@ class AbstractIOHandler
      * backends that decide to implement this operation asynchronously.
      */
     std::future<void> flush(internal::FlushParams const &);
+    std::queue<IOTask> m_work;
+    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;
     virtual bool fullSupportForVariableBasedEncoding() const;
 
-    std::string directory;
-    /*
-     * Originally, the reason for distinguishing these two was that during
-     * parsing in reading access modes, the access type would be temporarily
-     * const_cast'ed to an access type that would support modifying
-     * the openPMD object model. Then, it would be const_cast'ed back to
-     * READ_ONLY, to disable further modifications.
-     * Due to this approach's tendency to cause subtle bugs, and due to its
-     * difficult debugging properties, this was replaced by the SeriesStatus
-     * enum, defined in this file.
-     * The distinction of backendAccess and frontendAccess stays relevant, since
-     * the frontend can use it in order to pretend to the backend that another
-     * access type is being used. This is used by the file-based append mode,
-     * which is entirely implemented by the frontend, which internally uses
-     * the backend in CREATE mode.
-     */
-    Access m_backendAccess;
-    Access m_frontendAccess;
-    std::queue<IOTask> m_work;
-
-    /**************************************************************************
-     * Since the AbstractIOHandler is linked to every object of the frontend, *
-     * it stores a number of members that are needed by methods traversing    *
-     * the object hierarchy. Those members are found below.                   *
-     **************************************************************************/
-
-    /**
-     * This is to avoid that the destructor tries flushing again if an error
-     * happened. Otherwise, this would lead to confusing error messages.
-     * Initialized as false, set to true after successful construction.
-     * If flushing results in an error, set this back to false.
-     * The destructor will only attempt flushing again if this is true.
-     */
-    bool m_lastFlushSuccessful = false;
-    internal::SeriesStatus m_seriesStatus = internal::SeriesStatus::Default;
-    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/AbstractIOHandlerHelper.hpp b/include/openPMD/IO/AbstractIOHandlerHelper.hpp
index d86911ad35..c50f2c82d1 100644
--- a/include/openPMD/IO/AbstractIOHandlerHelper.hpp
+++ b/include/openPMD/IO/AbstractIOHandlerHelper.hpp
@@ -33,10 +33,6 @@ namespace openPMD
  * @param   initialize_from Optionally initialize the IOHandler from a previous
  *                      interim IOHandler which to replace with the handler now
  *                      being initialized.
- * @param   path        Path to root folder for all operations associated with
- the desired handler.
- * @param   access      Access mode describing desired operations and
- permissions of the desired handler.
  * @param   format      Format describing the IO backend of the desired handler.
  * @param   originalExtension The filename extension as it was originally
  *                            specified by the user.
@@ -48,11 +44,9 @@ namespace openPMD
                         including nlohmann::json in a .hpp file.
  * @return  Smart pointer to created IOHandler.
  */
-template <typename JSON>
+template <typename Init_t, typename JSON>
 std::unique_ptr<AbstractIOHandler> createIOHandler(
-    std::optional<std::unique_ptr<AbstractIOHandler>> initialize_from,
-    std::string path,
-    Access access,
+    Init_t &&initialize_from,
     Format format,
     std::string originalExtension,
     MPI_Comm comm,
@@ -65,10 +59,6 @@ std::unique_ptr<AbstractIOHandler> createIOHandler(
  * @param   initialize_from Optionally initialize the IOHandler from a previous
  *                      interim IOHandler which to replace with the handler now
  *                      being initialized.
- * @param   path        Path to root folder for all operations associated with
- * the desired handler.
- * @param   access      Access describing desired operations and permissions
- * of the desired handler.
  * @param   format      Format describing the IO backend of the desired handler.
  * @param   originalExtension The filename extension as it was originally
  *                            specified by the user.
@@ -79,21 +69,16 @@ std::unique_ptr<AbstractIOHandler> createIOHandler(
                         including nlohmann::json in a .hpp file.
  * @return  Smart pointer to created IOHandler.
  */
-template <typename JSON>
+template <typename Init_t, typename JSON>
 std::unique_ptr<AbstractIOHandler> createIOHandler(
-    std::optional<std::unique_ptr<AbstractIOHandler>> initialize_from,
-    std::string path,
-    Access access,
+    Init_t &&initialize_from,
     Format format,
     std::string originalExtension,
     JSON options,
     std::string const &pathAsItWasSpecifiedInTheConstructor);
 
 // version without configuration to use in AuxiliaryTest
+template <typename Init_t>
 std::unique_ptr<AbstractIOHandler> createIOHandler(
-    std::optional<std::unique_ptr<AbstractIOHandler>> initialize_from,
-    std::string path,
-    Access access,
-    Format format,
-    std::string originalExtension);
+    Init_t &&initialize_from, Format format, std::string originalExtension);
 } // namespace openPMD
diff --git a/include/openPMD/IO/AbstractIOHandler_internal.hpp b/include/openPMD/IO/AbstractIOHandler_internal.hpp
new file mode 100644
index 0000000000..7caa2f3b6f
--- /dev/null
+++ b/include/openPMD/IO/AbstractIOHandler_internal.hpp
@@ -0,0 +1,27 @@
+#pragma once
+
+#include "openPMD/IO/AbstractIOHandler.hpp"
+
+#include <variant>
+
+namespace openPMD::internal
+{
+struct AbstractIOHandlerInitFrom
+    : std::variant<GlobalParameters, AbstractIOHandler *>
+{
+    using Left = GlobalParameters;
+    using Right = AbstractIOHandler *;
+    using parent_t = std::variant<Left, Right>;
+    using parent_t::parent_t;
+    inline auto as_parent() -> parent_t &
+    {
+        return *this;
+    }
+    [[nodiscard]] inline auto as_parent() const -> parent_t const &
+    {
+        return *this;
+    }
+    auto asGlobalParameters() -> GlobalParameters &;
+    [[nodiscard]] auto asGlobalParameters() const -> GlobalParameters const &;
+};
+} // namespace openPMD::internal
diff --git a/include/openPMD/IO/DummyIOHandler.hpp b/include/openPMD/IO/DummyIOHandler.hpp
index 8abcf20990..dfc91215e5 100644
--- a/include/openPMD/IO/DummyIOHandler.hpp
+++ b/include/openPMD/IO/DummyIOHandler.hpp
@@ -21,6 +21,7 @@
 #pragma once
 
 #include "openPMD/IO/AbstractIOHandler.hpp"
+#include "openPMD/IO/AbstractIOHandler_internal.hpp"
 #include "openPMD/IO/Access.hpp"
 #include "openPMD/IO/IOTask.hpp"
 
@@ -34,7 +35,7 @@ namespace openPMD
 class DummyIOHandler : public AbstractIOHandler
 {
 public:
-    DummyIOHandler(std::string, Access);
+    DummyIOHandler(internal::AbstractIOHandlerInitFrom &&);
     ~DummyIOHandler() override = default;
 
     /** No-op consistent with the IOHandler interface to enable library use
@@ -44,7 +45,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..ba8daaa048 100644
--- a/include/openPMD/IO/HDF5/HDF5IOHandler.hpp
+++ b/include/openPMD/IO/HDF5/HDF5IOHandler.hpp
@@ -21,6 +21,7 @@
 #pragma once
 
 #include "openPMD/IO/AbstractIOHandler.hpp"
+#include "openPMD/IO/AbstractIOHandler_internal.hpp"
 #include "openPMD/auxiliary/JSON_internal.hpp"
 
 #include <future>
@@ -35,9 +36,7 @@ class HDF5IOHandler : public AbstractIOHandler
 {
 public:
     HDF5IOHandler(
-        std::optional<std::unique_ptr<AbstractIOHandler>> initialize_from,
-        std::string path,
-        Access,
+        internal::AbstractIOHandlerInitFrom &&initialize_from,
         json::TracingJSON config);
     ~HDF5IOHandler() override;
 
@@ -46,7 +45,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..d8a69d479e 100644
--- a/include/openPMD/IO/HDF5/ParallelHDF5IOHandler.hpp
+++ b/include/openPMD/IO/HDF5/ParallelHDF5IOHandler.hpp
@@ -21,6 +21,7 @@
 #pragma once
 
 #include "openPMD/IO/AbstractIOHandler.hpp"
+#include "openPMD/IO/AbstractIOHandler_internal.hpp"
 #include "openPMD/auxiliary/JSON_internal.hpp"
 #include "openPMD/config.hpp"
 
@@ -37,16 +38,12 @@ class ParallelHDF5IOHandler : public AbstractIOHandler
 public:
 #if openPMD_HAVE_MPI
     ParallelHDF5IOHandler(
-        std::optional<std::unique_ptr<AbstractIOHandler>> initialize_from,
-        std::string path,
-        Access,
+        internal::AbstractIOHandlerInitFrom &&initialize_from,
         MPI_Comm,
         json::TracingJSON config);
 #else
     ParallelHDF5IOHandler(
-        std::optional<std::unique_ptr<AbstractIOHandler>> initialize_from,
-        std::string const &path,
-        Access,
+        internal::AbstractIOHandlerInitFrom &&initialize_from,
         json::TracingJSON config);
 #endif
     ~ParallelHDF5IOHandler() override;
@@ -56,7 +53,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..c0821a17fb 100644
--- a/include/openPMD/IO/JSON/JSONIOHandler.hpp
+++ b/include/openPMD/IO/JSON/JSONIOHandler.hpp
@@ -22,6 +22,7 @@
 #pragma once
 
 #include "openPMD/IO/AbstractIOHandler.hpp"
+#include "openPMD/IO/AbstractIOHandler_internal.hpp"
 #include "openPMD/IO/JSON/JSONIOHandlerImpl.hpp"
 #include "openPMD/auxiliary/JSON_internal.hpp"
 
@@ -35,17 +36,13 @@ class JSONIOHandler : public AbstractIOHandler
 {
 public:
     JSONIOHandler(
-        std::optional<std::unique_ptr<AbstractIOHandler>> initialize_from,
-        std::string path,
-        Access at,
+        internal::AbstractIOHandlerInitFrom &&initialize_from,
         openPMD::json::TracingJSON config,
         JSONIOHandlerImpl::FileFormat,
         std::string originalExtension);
 #if openPMD_HAVE_MPI
     JSONIOHandler(
-        std::optional<std::unique_ptr<AbstractIOHandler>> initialize_from,
-        std::string path,
-        Access at,
+        internal::AbstractIOHandlerInitFrom &&initialize_from,
         MPI_Comm,
         openPMD::json::TracingJSON config,
         JSONIOHandlerImpl::FileFormat,
@@ -59,7 +56,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/Iteration.hpp b/include/openPMD/Iteration.hpp
index c66199c46f..4aed643472 100644
--- a/include/openPMD/Iteration.hpp
+++ b/include/openPMD/Iteration.hpp
@@ -27,6 +27,7 @@
 #include "openPMD/auxiliary/Variant.hpp"
 #include "openPMD/backend/Attributable.hpp"
 #include "openPMD/backend/Container.hpp"
+#include "openPMD/backend/ScientificDefaults.hpp"
 
 #include <cstdint>
 #include <deque>
@@ -142,7 +143,9 @@ namespace internal
  * @see
  * https://github.com/openPMD/openPMD-standard/blob/latest/STANDARD.md#required-attributes-for-the-basepath
  */
-class Iteration : public Attributable
+class Iteration
+    : public Attributable
+    , internal::ScientificDefaults<Iteration>
 {
     template <typename T, typename T_key, typename T_container>
     friend class Container;
@@ -153,6 +156,7 @@ class Iteration : public Attributable
     friend class Writable;
     friend class StatefulIterator;
     friend class StatefulSnapshotsContainer;
+    friend class internal::ScientificDefaults<Iteration>;
 
 public:
     Iteration(Iteration const &) = default;
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/Mesh.hpp b/include/openPMD/Mesh.hpp
index d0bf81ddef..4ff5d3749d 100644
--- a/include/openPMD/Mesh.hpp
+++ b/include/openPMD/Mesh.hpp
@@ -23,7 +23,9 @@
 #include "openPMD/UnitDimension.hpp"
 #include "openPMD/backend/Attributable.hpp"
 #include "openPMD/backend/BaseRecord.hpp"
+#include "openPMD/backend/Container.hpp"
 #include "openPMD/backend/MeshRecordComponent.hpp"
+#include "openPMD/backend/ScientificDefaults.hpp"
 
 #include <ostream>
 #include <string>
@@ -37,10 +39,14 @@ namespace openPMD
  * @see
  * https://github.com/openPMD/openPMD-standard/blob/latest/STANDARD.md#mesh-based-records
  */
-class Mesh : public BaseRecord<MeshRecordComponent>
+class Mesh
+    : public BaseRecord<MeshRecordComponent>
+    , internal::ScientificDefaults<Mesh>
 {
     friend class Container<Mesh>;
     friend class Iteration;
+    template <typename>
+    friend class internal::ScientificDefaults;
 
 public:
     Mesh(Mesh const &) = default;
@@ -328,8 +334,14 @@ class Mesh : public BaseRecord<MeshRecordComponent>
     void
     flush_impl(std::string const &, internal::FlushParams const &) override;
     void read();
+    auto retrieveDimensionality() const -> uint64_t;
 }; // Mesh
 
+static_assert(internal::IsContainer_v<Mesh>);
+static_assert(std::is_same_v<
+              Container<MeshRecordComponent>,
+              internal::AsContainer_t<Mesh>>);
+
 template <typename T>
 inline std::vector<T> Mesh::gridSpacing() const
 {
diff --git a/include/openPMD/ParticleSpecies.hpp b/include/openPMD/ParticleSpecies.hpp
index 4f309c0f2a..075d5bb8cd 100644
--- a/include/openPMD/ParticleSpecies.hpp
+++ b/include/openPMD/ParticleSpecies.hpp
@@ -24,19 +24,24 @@
 #include "openPMD/Record.hpp"
 #include "openPMD/backend/Attributable.hpp"
 #include "openPMD/backend/Container.hpp"
+#include "openPMD/backend/ScientificDefaults.hpp"
 
 #include <string>
 
 namespace openPMD
 {
 
-class ParticleSpecies : public Container<Record>
+class ParticleSpecies
+    : public Container<Record>
+    , internal::ScientificDefaults<ParticleSpecies>
 {
     friend class Container<ParticleSpecies>;
     friend class Container<Record>;
     friend class Iteration;
     template <typename T>
     friend T &internal::makeOwning(T &self, Series);
+    template <typename>
+    friend class internal::ScientificDefaults;
 
 public:
     ParticlePatches particlePatches;
diff --git a/include/openPMD/Record.hpp b/include/openPMD/Record.hpp
index 2bb070365f..618a246c83 100644
--- a/include/openPMD/Record.hpp
+++ b/include/openPMD/Record.hpp
@@ -23,17 +23,22 @@
 #include "openPMD/RecordComponent.hpp"
 #include "openPMD/UnitDimension.hpp"
 #include "openPMD/backend/BaseRecord.hpp"
+#include "openPMD/backend/ScientificDefaults.hpp"
 
 #include <string>
 #include <type_traits>
 
 namespace openPMD
 {
-class Record : public BaseRecord<RecordComponent>
+class Record
+    : public BaseRecord<RecordComponent>
+    , internal::ScientificDefaults<Record>
 {
     friend class Container<Record>;
     friend class Iteration;
     friend class ParticleSpecies;
+    template <typename>
+    friend class internal::ScientificDefaults;
 
 public:
     Record(Record const &) = default;
@@ -57,6 +62,8 @@ class Record : public BaseRecord<RecordComponent>
     [[nodiscard]] internal::HomogenizeExtents read();
 }; // Record
 
+static_assert(internal::HasScientificDefaults_v<Record>);
+
 template <typename T>
 inline T Record::timeOffset() const
 {
diff --git a/include/openPMD/RecordComponent.hpp b/include/openPMD/RecordComponent.hpp
index d06b4213f4..e8ab57def7 100644
--- a/include/openPMD/RecordComponent.hpp
+++ b/include/openPMD/RecordComponent.hpp
@@ -22,14 +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 "openPMD/backend/ScientificDefaults.hpp"
 
 #include <array>
 #include <cmath>
@@ -75,7 +74,8 @@ namespace internal
          */
         std::queue<IOTask> m_chunks;
 
-        void push_chunk(IOTask &&task);
+        void push_chunk(
+            IOTask &&task, std::optional<bool> immediate_flush = std::nullopt);
         /**
          * Stores the value for constant record components.
          * Ignored otherwise.
@@ -107,10 +107,23 @@ 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;
 
-class RecordComponent : public BaseRecordComponent
+class RecordComponent
+    : public BaseRecordComponent
+    , internal::ScientificDefaults<RecordComponent>
 {
     template <typename T, typename T_key, typename T_container>
     friend class Container;
@@ -128,6 +141,15 @@ 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;
+    template <typename>
+    friend class internal::ScientificDefaults;
 
 public:
     enum class Allocation
@@ -214,6 +236,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 +248,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 +287,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 +326,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
@@ -486,7 +476,7 @@ class RecordComponent : public BaseRecordComponent
 
 protected:
     void flush(std::string const &, internal::FlushParams const &);
-    void read(bool require_unit_si);
+    void read();
 
 private:
     /**
@@ -497,8 +487,23 @@ 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,
+        std::optional<bool> flush_immediately = std::nullopt);
+
+    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
@@ -534,7 +539,7 @@ OPENPMD_protected
         BaseRecordComponent::setData(m_recordComponentData);
     }
 
-    void readBase(bool require_unit_si);
+    void readBase();
 
     template <typename T>
     void verifyChunk(Offset const &, Extent const &) const;
@@ -564,6 +569,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..da64c9e898 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,73 @@ 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));
+}
+
+namespace detail
+{
+    template <typename T>
+    struct pointer_as_void;
+
+    template <typename T>
+    struct pointer_as_void<std::shared_ptr<T>>
+    {
+        static auto call(std::shared_ptr<T> const &ptr)
+            -> std::shared_ptr<void const>
+        {
+            return std::static_pointer_cast<void const>(ptr);
+        }
+    };
+
+    template <typename T>
+    struct pointer_as_void<std::unique_ptr<T>>
+    {
+        static auto call(std::unique_ptr<T> &&ptr) -> UniquePtrWithLambda<void>
+        {
+            return UniquePtrWithLambda<void>(std::move(ptr));
+        }
+    };
+    template <typename T>
+    struct pointer_as_void<std::unique_ptr<T[]>>
+    {
+        static auto call(std::unique_ptr<T[]> &&ptr)
+            -> UniquePtrWithLambda<void>
+        {
+            return UniquePtrWithLambda<T[]>(std::move(ptr))
+                .template static_cast_<void>();
+        }
+    };
+} // namespace detail
+
+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 +151,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;
@@ -128,11 +166,16 @@ RecordComponent::storeChunk(Offset o, Extent e, F &&createBuffer)
         // note that data might have either
         // type shared_ptr<T> or shared_ptr<T[]>
         auto data = std::forward<F>(createBuffer)(size);
+        using ptr_type = decltype(data);
         out.ptr = static_cast<void *>(data.get());
-        if (size > 0)
-        {
-            storeChunk(std::move(data), std::move(o), std::move(e));
-        }
+        internal::LoadStoreConfigWithBuffer ls_cfg{
+            std::move(o), std::move(e), std::nullopt};
+        storeChunk_impl(
+            auxiliary::WriteBuffer(
+                detail::pointer_as_void<ptr_type>::call(std::move(data))),
+            getBufferView.dtype,
+            std::move(ls_cfg),
+            /*flush_immediately=*/false);
     }
     setDirtyRecursive(true);
     return DynamicMemoryView<T>{std::move(getBufferView), size, *this};
@@ -169,4 +212,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/Series.hpp b/include/openPMD/Series.hpp
index 603e540c2b..c889406dc5 100644
--- a/include/openPMD/Series.hpp
+++ b/include/openPMD/Series.hpp
@@ -789,6 +789,8 @@ class Series : public Attributable
             "Cannot call this on an instance of Series.");
     }
 
+    [[nodiscard]] bool flushImmediately() const;
+
     // clang-format off
 OPENPMD_private
     // clang-format on
@@ -835,7 +837,7 @@ OPENPMD_private
         Attributable::setData(m_series);
     }
 
-    std::unique_ptr<ParsedInput> parseInput(std::string);
+    std::unique_ptr<ParsedInput> parseInput(std::string) const;
     /**
      * @brief Parse non-backend-specific configuration in JSON config.
      *
@@ -846,7 +848,8 @@ OPENPMD_private
      *         to include the JSON lib here
      */
     template <typename TracingJSON>
-    void parseJsonOptions(TracingJSON &options, ParsedInput &);
+    void parseJsonOptions(
+        TracingJSON &options, ParsedInput &, internal::GlobalParameters &);
     bool hasExpansionPattern(std::string filenameWithExtension);
     bool reparseExpansionPattern(std::string filenameWithExtension);
     template <typename... MPI_Communicator>
@@ -856,10 +859,11 @@ OPENPMD_private
         std::string const &options,
         MPI_Communicator &&...);
     template <typename TracingJSON, typename... MPI_Communicator>
-    std::tuple<std::unique_ptr<ParsedInput>, TracingJSON> initIOHandler(
+    std::tuple<std::unique_ptr<ParsedInput>, TracingJSON>
+    prepareIOHandlerArguments(
+        internal::GlobalParameters &,
         std::string const &filepath,
         std::string const &options,
-        Access at,
         bool resolve_generic_extension,
         MPI_Communicator &&...);
     void initSeries(
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/TypeTraits.hpp b/include/openPMD/auxiliary/TypeTraits.hpp
index faf2b29472..e373873a4f 100644
--- a/include/openPMD/auxiliary/TypeTraits.hpp
+++ b/include/openPMD/auxiliary/TypeTraits.hpp
@@ -124,6 +124,22 @@ namespace detail
     {
         constexpr static bool value = true;
     };
+
+    template <typename T>
+    struct ScalarType
+    {
+        using type = T;
+    };
+    template <typename T>
+    struct ScalarType<std::vector<T>>
+    {
+        using type = T;
+    };
+    template <typename T, size_t N>
+    struct ScalarType<std::array<T, N>>
+    {
+        using type = T;
+    };
 } // namespace detail
 
 template <typename T>
@@ -141,6 +157,12 @@ using IsPointer_t = typename detail::IsPointer<T>::type;
 template <typename C>
 inline constexpr bool IsChar_v = detail::IsChar<C>::value;
 
+template <typename T>
+using ScalarType_t = typename detail::ScalarType<T>::type;
+
+template <typename T>
+using VectorType_t = std::vector<ScalarType_t<T>>;
+
 /** Emulate in the C++ concept ContiguousContainer
  *
  * Users can implement this trait for a type to signal it can be used as
@@ -203,6 +225,34 @@ namespace detail
     // little trick to avoid trailing commas in the macro expansions below
     template <typename Arg, typename... Args>
     using variant_tail_t = std::variant<Args...>;
+
+    template <template <typename...> class Base, typename... Args>
+    auto infer_template_args(Base<Args...> &) -> Base<Args...>;
+
+    template <
+        template <typename...> class Base,
+        typename T,
+        typename SFINAE = void>
+    struct IsTemplateBaseOf
+    {
+        static constexpr bool value = false;
+    };
+
+    template <template <typename...> class Base, typename T>
+    struct IsTemplateBaseOf<
+        Base,
+        T,
+        std::void_t<decltype(detail::infer_template_args<Base>(
+            std::declval<T &>()))>>
+    {
+        static constexpr bool value = true;
+        using type =
+            decltype(detail::infer_template_args<Base>(std::declval<T &>()));
+    };
 } // namespace detail
 
+template <template <typename...> class Base, typename T>
+constexpr bool IsTemplateBaseOf_v = detail::IsTemplateBaseOf<Base, T>::value;
+template <template <typename...> class Base, typename T>
+using AsTemplateBase_t = typename detail::IsTemplateBaseOf<Base, T>::type;
 } // 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..6e71571817 100644
--- a/include/openPMD/backend/Attributable.hpp
+++ b/include/openPMD/backend/Attributable.hpp
@@ -57,6 +57,7 @@ namespace internal
     class IterationData;
     class SeriesData;
     struct HomogenizeExtents;
+    struct ConfigAttribute;
 
     class SharedAttributableData
     {
@@ -213,6 +214,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 +250,8 @@ class Attributable
     friend class internal::AttributableData;
     friend class Snapshots;
     friend struct internal::HomogenizeExtents;
+    friend class core::ConfigureLoadStore;
+    friend struct internal::ConfigAttribute;
 
 protected:
     // tag for internal constructor
@@ -276,6 +284,7 @@ class Attributable
     template <typename T>
     bool setAttribute(std::string const &key, T value);
     bool setAttribute(std::string const &key, char const value[]);
+    bool setAttribute(std::string const &key, Attribute value);
     /** @}
      */
 
@@ -549,6 +558,28 @@ OPENPMD_protected
     {
         return writable().dirtyRecursive;
     }
+    void determineUnsetDirty(FlushLevel fl)
+    {
+        switch (fl)
+        {
+        case FlushLevel::UserFlush:
+            setDirty(false);
+            break;
+        case FlushLevel::InternalFlush:
+            // Used for parsing
+            if (IOHandler()->m_seriesStatus == internal::SeriesStatus::Parsing)
+            {
+                throw error::Internal(
+                    "Parsing procedures should directly unset dirty.");
+            }
+            break;
+        case FlushLevel::ImmediateFlush:
+        case FlushLevel::SkeletonOnly:
+        case FlushLevel::CreateOrOpenFiles:
+            // noop
+            break;
+        }
+    }
     void setDirty(bool dirty_in)
     {
         auto &w = writable();
diff --git a/include/openPMD/backend/Attribute.hpp b/include/openPMD/backend/Attribute.hpp
index 446b4a7375..e9ca440af0 100644
--- a/include/openPMD/backend/Attribute.hpp
+++ b/include/openPMD/backend/Attribute.hpp
@@ -115,9 +115,13 @@ class Attribute
     template <typename U>
     std::optional<U> getOptional() const;
 
-private:
     template <typename U>
-    std::variant<U, std::runtime_error> get_impl() const;
+    std::variant<U, std::runtime_error> getOrError() const;
+
+    [[nodiscard]] std::variant<Attribute, std::runtime_error>
+    requireVector() const;
+    [[nodiscard]] std::variant<Attribute, std::runtime_error>
+    requireScalar() const;
 };
 
 namespace detail
diff --git a/include/openPMD/backend/BaseRecord.hpp b/include/openPMD/backend/BaseRecord.hpp
index f75536e3bd..0a618b20f4 100644
--- a/include/openPMD/backend/BaseRecord.hpp
+++ b/include/openPMD/backend/BaseRecord.hpp
@@ -26,6 +26,7 @@
 #include "openPMD/auxiliary/Variant.hpp"
 #include "openPMD/backend/BaseRecordComponent.hpp"
 #include "openPMD/backend/Container.hpp"
+#include "openPMD/backend/ScientificDefaults.hpp"
 
 #include <array>
 #include <stdexcept>
@@ -179,6 +180,7 @@ template <typename T_elem>
 class BaseRecord
     : public Container<T_elem>
     , public T_elem // T_RecordComponent
+    , internal::ScientificDefaults<BaseRecord<T_elem>>
 {
 public:
     using T_RecordComponent = T_elem;
@@ -197,6 +199,8 @@ class BaseRecord
     friend class internal::ScalarIterator;
     template <typename T>
     friend T &internal::makeOwning(T &self, Series);
+    template <typename>
+    friend class internal::ScientificDefaults;
 
     using Data_t =
         internal::BaseRecordData<T_elem, typename T_RecordComponent::Data_t>;
@@ -362,9 +366,6 @@ class BaseRecord
      */
     bool scalar() const;
 
-protected:
-    void readBase();
-
 private:
     void flush(std::string const &, internal::FlushParams const &) final;
     virtual void
@@ -381,6 +382,21 @@ namespace detail
 
     template <typename BaseRecord>
     void verifyNonscalar(BaseRecord *self);
+
+    template <typename T>
+    struct IsBaseRecord
+    {
+        constexpr static bool value = false;
+    };
+
+    template <typename T>
+    struct IsBaseRecord<BaseRecord<T>>
+    {
+        constexpr static bool value = true;
+    };
+
+    template <typename T>
+    constexpr bool IsBaseRecord_v = IsBaseRecord<T>::value;
 } // namespace detail
 
 template <typename T_elem>
diff --git a/include/openPMD/backend/Container.hpp b/include/openPMD/backend/Container.hpp
index 963fd34802..418823ede4 100644
--- a/include/openPMD/backend/Container.hpp
+++ b/include/openPMD/backend/Container.hpp
@@ -22,6 +22,7 @@
 
 #include "openPMD/Error.hpp"
 #include "openPMD/IO/Access.hpp"
+#include "openPMD/auxiliary/TypeTraits.hpp"
 #include "openPMD/backend/Attributable.hpp"
 
 #include <initializer_list>
@@ -343,5 +344,13 @@ namespace internal
 
         ~EraseStaleEntries();
     };
+
+    template <typename T>
+    constexpr bool IsContainer_v = auxiliary::IsTemplateBaseOf_v<Container, T>;
+    template <typename T>
+    using AsContainer_t = auxiliary::AsTemplateBase_t<Container, T>;
+
+    static_assert(!IsContainer_v<int>);
+    static_assert(IsContainer_v<Container<Attributable>>);
 } // namespace internal
 } // namespace openPMD
diff --git a/include/openPMD/backend/MeshRecordComponent.hpp b/include/openPMD/backend/MeshRecordComponent.hpp
index 708c4a496f..5319985832 100644
--- a/include/openPMD/backend/MeshRecordComponent.hpp
+++ b/include/openPMD/backend/MeshRecordComponent.hpp
@@ -21,6 +21,7 @@
 #pragma once
 
 #include "openPMD/RecordComponent.hpp"
+#include "openPMD/backend/ScientificDefaults.hpp"
 
 #include <vector>
 
@@ -32,7 +33,9 @@ namespace internal
     class BaseRecordData;
 }
 
-class MeshRecordComponent : public RecordComponent
+class MeshRecordComponent
+    : public RecordComponent
+    , internal::ScientificDefaults<MeshRecordComponent>
 {
     template <typename T, typename T_key, typename T_container>
     friend class Container;
@@ -40,6 +43,8 @@ class MeshRecordComponent : public RecordComponent
     friend class BaseRecord;
     template <typename, typename>
     friend class internal::BaseRecordData;
+    template <typename>
+    friend class internal::ScientificDefaults;
 
     friend class Mesh;
 
diff --git a/include/openPMD/backend/PatchRecord.hpp b/include/openPMD/backend/PatchRecord.hpp
index 86317745b8..3443dc4eb0 100644
--- a/include/openPMD/backend/PatchRecord.hpp
+++ b/include/openPMD/backend/PatchRecord.hpp
@@ -22,20 +22,25 @@
 
 #include "openPMD/backend/BaseRecord.hpp"
 #include "openPMD/backend/PatchRecordComponent.hpp"
+#include "openPMD/backend/ScientificDefaults.hpp"
 
 #include <string>
-#include <unordered_map>
 
 namespace openPMD
 {
-class PatchRecord : public BaseRecord<PatchRecordComponent>
+class PatchRecord
+    : public BaseRecord<PatchRecordComponent>
+    , internal::ScientificDefaults<PatchRecord>
 {
     friend class Container<PatchRecord>;
     friend class ParticleSpecies;
     friend class ParticlePatches;
+    template <typename>
+    friend class internal::ScientificDefaults;
 
 public:
-    PatchRecord &setUnitDimension(std::map<UnitDimension, double> const &);
+    PatchRecord &setUnitDimension(unit_representations::AsMap const &);
+    PatchRecord &setUnitDimension(unit_representations::AsArray const &udim);
     ~PatchRecord() override = default;
 
 private:
diff --git a/include/openPMD/backend/PatchRecordComponent.hpp b/include/openPMD/backend/PatchRecordComponent.hpp
index fed17dfd3b..bafb3f4be0 100644
--- a/include/openPMD/backend/PatchRecordComponent.hpp
+++ b/include/openPMD/backend/PatchRecordComponent.hpp
@@ -24,6 +24,7 @@
 #include "openPMD/RecordComponent.hpp"
 #include "openPMD/auxiliary/ShareRawInternal.hpp"
 #include "openPMD/backend/BaseRecordComponent.hpp"
+#include "openPMD/backend/ScientificDefaults.hpp"
 
 #include <memory>
 #include <sstream>
@@ -42,7 +43,9 @@ namespace openPMD
 /**
  * @todo add support for constant patch record components
  */
-class PatchRecordComponent : public RecordComponent
+class PatchRecordComponent
+    : public RecordComponent
+    , internal::ScientificDefaults<PatchRecordComponent>
 {
     template <typename T, typename T_key, typename T_container>
     friend class Container;
@@ -53,6 +56,8 @@ class PatchRecordComponent : public RecordComponent
     friend class ParticlePatches;
     friend class PatchRecord;
     friend class ParticleSpecies;
+    template <typename>
+    friend class internal::ScientificDefaults;
 
 public:
     /**
@@ -93,6 +98,10 @@ OPENPMD_private
 
     using RecordComponent::flush;
 
+    // This differs from RecordComponent::read() such that unitSI is not
+    // required
+    void read();
+
     // clang-format off
 OPENPMD_protected
     // clang-format on
diff --git a/include/openPMD/backend/ScientificDefaults.hpp b/include/openPMD/backend/ScientificDefaults.hpp
new file mode 100644
index 0000000000..959f446d47
--- /dev/null
+++ b/include/openPMD/backend/ScientificDefaults.hpp
@@ -0,0 +1,39 @@
+#pragma once
+
+#include "openPMD/IO/AbstractIOHandler.hpp"
+
+#include <type_traits>
+
+namespace openPMD::internal
+{
+struct ConfigAttribute;
+
+template <typename Child> // CRT
+class ScientificDefaults
+{
+private:
+    auto asChild() -> Child &;
+    auto asChild() const -> Child const &;
+
+    template <typename F>
+    using setter_t = Child &(Child::*)();
+
+    [[nodiscard]] auto defaultAttribute(char const *attrName)
+        -> ConfigAttribute;
+
+    template <typename Parent, bool write>
+    void addParentDefaults(OpenpmdStandard);
+
+    template <bool write>
+    void defaults_impl(OpenpmdStandard);
+
+protected:
+    void addDefaultsRecursively(OpenpmdStandard);
+    void addDefaults(OpenpmdStandard);
+    void readDefaults(OpenpmdStandard);
+};
+
+template <typename Child>
+constexpr bool HasScientificDefaults_v =
+    std::is_base_of_v<ScientificDefaults<Child>, Child>;
+} // namespace openPMD::internal
diff --git a/include/openPMD/backend/ScientificDefaults_internal.hpp b/include/openPMD/backend/ScientificDefaults_internal.hpp
new file mode 100644
index 0000000000..e25ba80c99
--- /dev/null
+++ b/include/openPMD/backend/ScientificDefaults_internal.hpp
@@ -0,0 +1,229 @@
+#pragma once
+
+#include "openPMD/Error.hpp"
+#include "openPMD/Mesh.hpp"
+#include "openPMD/backend/Attributable.hpp"
+#include "openPMD/backend/Attribute.hpp"
+
+#include <deque>
+#include <iostream>
+#include <optional>
+#include <string>
+#include <type_traits>
+#include <variant>
+#include <vector>
+
+namespace openPMD::detail
+{
+template <typename F, typename SFINAE = void>
+struct IsCallable
+{
+    static constexpr bool value = false;
+    using type = F;
+};
+
+template <typename F>
+struct IsCallable<F, std::void_t<decltype(std::declval<F>()())>>
+{
+    static constexpr bool value = true;
+    using type = decltype(std::declval<F>()());
+};
+
+template <typename F>
+constexpr bool IsCallable_v = IsCallable<F>::value;
+template <typename F>
+using CallResult_t = typename IsCallable<F>::type;
+} // namespace openPMD::detail
+
+namespace openPMD::internal
+{
+namespace
+{
+    template <typename T>
+    inline auto write_val_to_stderr(T const &val) -> std::ostream &;
+    inline auto write_to_stderr(Attribute const &a) -> std::ostream &;
+
+    // Helper functions used in ScientificDefaults implementations
+    inline auto setMeshGeometryFromString(Mesh &mesh, std::string val)
+        -> std::optional<error::ReadError>;
+    inline auto setMeshDataOrderFromChar(Mesh &mesh, char val)
+        -> std::optional<error::ReadError>;
+    inline auto createDefaultAxisLabels(uint64_t dimensionality)
+        -> std::vector<std::string>;
+    inline auto
+    createDefaultVector(uint64_t dimensionality, double defaultValue)
+        -> std::vector<double>;
+} // namespace
+
+namespace attribute_read_result
+{
+    struct TypeUnmatched
+    {
+        std::deque<Datatype> expectedDatatypes;
+    };
+    struct Success
+    {};
+} // namespace attribute_read_result
+
+struct ProcessAttribute
+{
+    virtual auto operator()(Attributable &, char const *, Attribute const &)
+        -> std::optional<error::ReadError> = 0;
+    virtual ~ProcessAttribute() = default;
+};
+
+template <typename T>
+struct PostProcessConvertedAttribute
+{
+    virtual auto operator()(T val) -> std::optional<error::ReadError> = 0;
+    virtual ~PostProcessConvertedAttribute() = default;
+};
+
+struct constructor_tag
+{};
+static constexpr constructor_tag constructor_tag_v = {};
+
+template <typename T, typename RecordType>
+struct PostProcessConvertedAttributeImpl : PostProcessConvertedAttribute<T>
+{
+    RecordType record;
+    using handler_t = std::optional<error::ReadError> (*)(RecordType &, T);
+    handler_t reader;
+
+    PostProcessConvertedAttributeImpl(
+        RecordType record_in, handler_t reader_in);
+
+    auto operator()(T val) -> std::optional<error::ReadError> override;
+};
+
+template <typename T, typename RecordType>
+auto makePostProcessConvertedAttribute(
+    RecordType &&record,
+    std::optional<error::ReadError> (*handler)(
+        std::remove_reference_t<RecordType> &, T))
+    -> std::shared_ptr<PostProcessConvertedAttribute<T>>;
+
+template <typename T>
+struct RequireType : ProcessAttribute
+{
+    std::optional<std::shared_ptr<PostProcessConvertedAttribute<T>>>
+        postProcess;
+
+    explicit RequireType() = default;
+
+    template <typename RecordType>
+    RequireType(
+        RecordType &&record,
+        std::optional<error::ReadError> (*handler)(
+            std::remove_reference_t<RecordType> &, T));
+
+    auto operator()(Attributable &, char const *, Attribute const &)
+        -> std::optional<error::ReadError> override;
+};
+
+struct RequireVector : ProcessAttribute
+{
+    auto operator()(Attributable &, char const *, Attribute const &)
+        -> std::optional<error::ReadError> override;
+};
+
+struct RequireScalar : ProcessAttribute
+{
+    auto operator()(Attributable &, char const *, Attribute const &)
+        -> std::optional<error::ReadError> override;
+};
+
+using AttributeReadResult = std::variant<
+    attribute_read_result::Success,
+    attribute_read_result::TypeUnmatched,
+    error::ReadError>;
+
+struct AttributeReader
+{
+    std::deque<Datatype> eligibleDatatypes;
+    std::optional<std::shared_ptr<ProcessAttribute>> processAttribute;
+
+    AttributeReader(
+        std::deque<Datatype> eligibleDatatypes_in,
+        std::optional<std::shared_ptr<ProcessAttribute>> processAttribute_in);
+
+    auto operator()(
+        Attributable &record,
+        char const *attrName,
+        Attribute const &a,
+        std::deque<Datatype> unmatched_so_far) -> AttributeReadResult;
+};
+
+enum class WriteOrRead : std::uint8_t
+{
+    Write,
+    Read
+};
+
+/////////////////////
+// ConfigAttribute //
+// //////////////////
+
+struct ConfigAttribute
+{
+    Attributable &child;
+    char const *attrName;
+    std::optional<std::function<void(Attributable &)>> initDefaultAttribute;
+    // processed "from left to right"
+    std::deque<AttributeReader> attributeReaders;
+
+    template <typename RecordType, typename ValueType>
+    using set_default_val_t = RecordType &(RecordType::*)(ValueType);
+
+    ConfigAttribute(Attributable &child_in, char const *attrName_in);
+
+    ConfigAttribute(ConfigAttribute const &) = delete;
+    ConfigAttribute(ConfigAttribute &&) = delete;
+
+    ConfigAttribute &operator=(ConfigAttribute const &) = delete;
+    ConfigAttribute &operator=(ConfigAttribute &&) = delete;
+
+    template <typename RecordType, typename S = void, typename GetDefaultValue>
+    [[nodiscard]] auto withSetter(
+        GetDefaultValue &&getDefaultVal,
+        set_default_val_t<
+            RecordType,
+            std::conditional_t<
+                std::is_void_v<S>,
+                detail::CallResult_t<GetDefaultValue>,
+                S>> setDefaultVal) -> ConfigAttribute &;
+
+    template <typename DefaultValue>
+    [[nodiscard]] auto withGenericSetter(DefaultValue &&defaultVal)
+        -> ConfigAttribute &;
+
+    [[nodiscard]] auto withReader(
+        std::deque<Datatype> eligibleDatatypes,
+        std::optional<std::shared_ptr<ProcessAttribute>> processAttribute =
+            std::nullopt) -> ConfigAttribute &;
+
+    void write();
+    void read();
+    void operator()(WriteOrRead wor);
+};
+
+// below are some helpers that may be used as processing functions for
+// attributes in withReader()
+namespace
+{ // try converting to scalar values (e.g. when a vector of length 1 is given)
+    extern std::shared_ptr<ProcessAttribute> require_scalar;
+    // try converting to vectors (e.g. when a scalar or an array is given)
+    extern std::shared_ptr<ProcessAttribute> require_vector;
+    template <typename T, typename RecordType>
+    auto require_type(
+        std::optional<error::ReadError> (*)(
+            std::remove_reference_t<RecordType> &, T))
+        -> std::shared_ptr<ProcessAttribute>;
+    // common case: directly use setAttribute
+    template <typename T>
+    auto require_type() -> std::shared_ptr<ProcessAttribute>;
+
+    inline auto get_float_types() -> std::deque<Datatype>;
+    inline auto get_string_types() -> std::deque<Datatype>;
+} // namespace
+} // namespace openPMD::internal
diff --git a/include/openPMD/backend/Writable.hpp b/include/openPMD/backend/Writable.hpp
index 0396aa1f93..b36c299b4d 100644
--- a/include/openPMD/backend/Writable.hpp
+++ b/include/openPMD/backend/Writable.hpp
@@ -51,6 +51,8 @@ namespace internal
     class SharedAttributableData;
     class AttributableData;
     class SeriesData;
+    template <typename>
+    class ScientificDefaults;
 } // namespace internal
 namespace detail
 {
@@ -106,6 +108,8 @@ class Writable final
     friend void debug::printDirty(Series const &);
     friend struct Parameter<Operation::CREATE_DATASET>;
     friend struct Parameter<Operation::OPEN_DATASET>;
+    template <typename>
+    friend class internal::ScientificDefaults;
 
 private:
     Writable(internal::AttributableData *);
diff --git a/src/IO/ADIOS/ADIOS2File.cpp b/src/IO/ADIOS/ADIOS2File.cpp
index 1d20aeb04d..c1e8e833aa 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";
@@ -1034,25 +1077,16 @@ void ADIOS2File::flush_impl(
         drainedUniquePtrPuts.swap(m_uniquePtrPuts);
     }
 
-    if (readOnly(m_mode))
-    {
-        level = FlushLevel::UserFlush;
-    }
-
-    switch (level)
+    if (readOnly(m_mode) || flush_level::write_datasets(level))
     {
-    case FlushLevel::UserFlush:
         performPutGets(*this, eng);
         m_updateSpans.clear();
         m_buffer.clear();
         m_alreadyEnqueued.clear();
         drainedUniquePtrPuts.clear();
-
-        break;
-
-    case FlushLevel::InternalFlush:
-    case FlushLevel::SkeletonOnly:
-    case FlushLevel::CreateOrOpenFiles:
+    }
+    else
+    {
         /*
          * Tasks have been given to ADIOS2, but we don't flush them
          * yet. So, move everything to m_alreadyEnqueued to avoid
@@ -1069,7 +1103,6 @@ void ADIOS2File::flush_impl(
                 "wrong time.");
         }
         m_buffer.clear();
-        break;
     }
 }
 
diff --git a/src/IO/ADIOS/ADIOS2IOHandler.cpp b/src/IO/ADIOS/ADIOS2IOHandler.cpp
index 0ee10a77c4..235b12f786 100644
--- a/src/IO/ADIOS/ADIOS2IOHandler.cpp
+++ b/src/IO/ADIOS/ADIOS2IOHandler.cpp
@@ -30,6 +30,7 @@
 #include "openPMD/IO/ADIOS/ADIOS2IOHandler.hpp"
 #include "openPMD/IO/ADIOS/ADIOS2PreloadAttributes.hpp"
 #include "openPMD/IO/ADIOS/ADIOS2PreloadVariables.hpp"
+#include "openPMD/IO/AbstractIOHandler_internal.hpp"
 #include "openPMD/IO/IOTask.hpp"
 #include "openPMD/IterationEncoding.hpp"
 #include "openPMD/Streaming.hpp"
@@ -51,6 +52,7 @@
 #include <iterator>
 #include <memory>
 #include <numeric>
+#include <optional>
 #include <set>
 #include <sstream>
 #include <stdexcept>
@@ -1231,6 +1233,7 @@ namespace detail
             adios2::Variable<T> variable = impl->verifyDataset<T>(
                 params.offset,
                 params.extent,
+                std::nullopt,
                 IO,
                 engine,
                 varName,
@@ -2581,38 +2584,28 @@ namespace detail
 #if openPMD_HAVE_MPI
 
 ADIOS2IOHandler::ADIOS2IOHandler(
-    std::optional<std::unique_ptr<AbstractIOHandler>> initialize_from,
-    std::string path,
-    openPMD::Access at,
+    internal::AbstractIOHandlerInitFrom &&initialize_from,
     MPI_Comm comm,
     json::TracingJSON options,
     std::string engineType,
     std::string specifiedExtension)
-    : AbstractIOHandler(
-          std::move(initialize_from),
-          std::move(path),
-          at,
-          std::move(options),
-          comm)
+    : AbstractIOHandler(std::move(initialize_from), std::move(options), comm)
     , m_impl{this, comm, std::move(engineType), std::move(specifiedExtension)}
 {}
 
 #endif
 
 ADIOS2IOHandler::ADIOS2IOHandler(
-    std::optional<std::unique_ptr<AbstractIOHandler>> initialize_from,
-    std::string path,
-    Access at,
+    internal::AbstractIOHandlerInitFrom &&initialize_from,
     json::TracingJSON options,
     std::string engineType,
     std::string specifiedExtension)
-    : AbstractIOHandler(
-          std::move(initialize_from), std::move(path), at, std::move(options))
+    : AbstractIOHandler(std::move(initialize_from), std::move(options))
     , m_impl{this, std::move(engineType), std::move(specifiedExtension)}
 {}
 
 std::future<void>
-ADIOS2IOHandler::flush(internal::ParsedFlushParams &flushParams)
+ADIOS2IOHandler::flush_impl(internal::ParsedFlushParams &flushParams)
 {
     return m_impl.flush(flushParams);
 }
@@ -2621,39 +2614,29 @@ ADIOS2IOHandler::flush(internal::ParsedFlushParams &flushParams)
 
 #if openPMD_HAVE_MPI
 ADIOS2IOHandler::ADIOS2IOHandler(
-    std::optional<std::unique_ptr<AbstractIOHandler>> initialize_from,
-    std::string path,
-    Access at,
+    internal::AbstractIOHandlerInitFrom &&initialize_from,
     MPI_Comm comm,
     json::TracingJSON config,
     // NOLINTNEXTLINE(performance-unnecessary-value-param)
     std::string,
     // NOLINTNEXTLINE(performance-unnecessary-value-param)
     std::string)
-    : AbstractIOHandler(
-          std::move(initialize_from),
-          std::move(path),
-          at,
-          std::move(config),
-          comm)
+    : AbstractIOHandler(std::move(initialize_from), std::move(config), comm)
 {}
 
 #endif // openPMD_HAVE_MPI
 
 ADIOS2IOHandler::ADIOS2IOHandler(
-    std::optional<std::unique_ptr<AbstractIOHandler>> initialize_from,
-    std::string path,
-    Access at,
+    internal::AbstractIOHandlerInitFrom &&initialize_from,
     json::TracingJSON config,
     // NOLINTNEXTLINE(performance-unnecessary-value-param)
     std::string,
     // NOLINTNEXTLINE(performance-unnecessary-value-param)
     std::string)
-    : AbstractIOHandler(
-          std::move(initialize_from), std::move(path), at, std::move(config))
+    : AbstractIOHandler(std::move(initialize_from), std::move(config))
 {}
 
-std::future<void> ADIOS2IOHandler::flush(internal::ParsedFlushParams &)
+std::future<void> ADIOS2IOHandler::flush_impl(internal::ParsedFlushParams &)
 {
     return std::future<void>();
 }
diff --git a/src/IO/AbstractIOHandler.cpp b/src/IO/AbstractIOHandler.cpp
index 5f2bdeb2f5..4073588a63 100644
--- a/src/IO/AbstractIOHandler.cpp
+++ b/src/IO/AbstractIOHandler.cpp
@@ -22,10 +22,12 @@
 #include "openPMD/IO/AbstractIOHandler.hpp"
 
 #include "openPMD/Error.hpp"
+#include "openPMD/IO/AbstractIOHandler_internal.hpp"
 #include "openPMD/IO/FlushParametersInternal.hpp"
 #include "openPMD/auxiliary/JSONMatcher.hpp"
 
 #include <utility>
+#include <variant>
 
 namespace openPMD::auxiliary
 {
@@ -63,6 +65,14 @@ auto formatStandard(OpenpmdStandard std) -> char const *
 }
 } // namespace openPMD::auxiliary
 
+namespace openPMD::internal
+{
+GlobalParameters::GlobalParameters(Access at)
+    : m_backendAccess(at), m_frontendAccess(at)
+{}
+GlobalParameters::GlobalParameters() = default;
+} // namespace openPMD::internal
+
 namespace openPMD
 {
 void AbstractIOHandler::setIterationEncoding(IterationEncoding encoding)
@@ -122,49 +132,61 @@ 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;
 }
 
+template <>
+AbstractIOHandler::AbstractIOHandler(
+    detail::InitFrom_Tag, internal::AbstractIOHandlerInitFrom &&initialize_from)
+{
+    using IF = internal::AbstractIOHandlerInitFrom;
+    std::visit(
+        auxiliary::overloaded{
+            [this](IF::Left &&l) {
+                static_cast<internal::GlobalParameters *>(this)->operator=(
+                    std::move(l));
+            },
+            [this](IF::Right &&r) { this->operator=(std::move(*r)); }},
+        std::move(initialize_from.as_parent()));
+}
+
 #if openPMD_HAVE_MPI
 template <>
 AbstractIOHandler::AbstractIOHandler(
-    std::optional<std::unique_ptr<AbstractIOHandler>> initialize_from,
-    std::string path,
-    Access at,
+    internal::AbstractIOHandlerInitFrom &&initialize_from,
     json::TracingJSON &&jsonConfig,
     MPI_Comm)
-    : AbstractIOHandler(std::move(initialize_from))
+    : AbstractIOHandler(detail::InitFrom_Tag_v, std::move(initialize_from))
 {
     jsonMatcher = std::make_unique<json::JsonMatcher>(std::move(jsonConfig));
-    directory = std::move(path);
-    m_backendAccess = at;
-    m_frontendAccess = at;
 }
 #endif
 
 template <>
 AbstractIOHandler::AbstractIOHandler(
-    std::optional<std::unique_ptr<AbstractIOHandler>> initialize_from,
-    std::string path,
-    Access at,
+    internal::AbstractIOHandlerInitFrom &&initialize_from,
     json::TracingJSON &&jsonConfig)
-    : AbstractIOHandler(std::move(initialize_from))
+    : AbstractIOHandler(detail::InitFrom_Tag_v, std::move(initialize_from))
 {
     jsonMatcher = std::make_unique<json::JsonMatcher>(std::move(jsonConfig));
-    directory = std::move(path);
-    m_backendAccess = at;
-    m_frontendAccess = at;
-}
-
-AbstractIOHandler::AbstractIOHandler(
-    std::optional<std::unique_ptr<AbstractIOHandler>> initialize_from)
-{
-    if (initialize_from.has_value() && *initialize_from)
-    {
-        this->operator=(std::move(**initialize_from));
-    }
 }
 
 AbstractIOHandler::~AbstractIOHandler() = default;
@@ -175,3 +197,29 @@ AbstractIOHandler::AbstractIOHandler(AbstractIOHandler &&) = default;
 AbstractIOHandler &
 AbstractIOHandler::operator=(AbstractIOHandler &&) noexcept = default;
 } // namespace openPMD
+
+namespace openPMD::internal
+{
+auto AbstractIOHandlerInitFrom::asGlobalParameters() const
+    -> GlobalParameters const &
+{
+    return std::visit(
+        auxiliary::overloaded{
+            [](Left const &params) -> GlobalParameters const & {
+                // ?? why
+                // NOLINTNEXTLINE(bugprone-return-const-ref-from-parameter)
+                return params;
+            },
+            [](Right const &ioHandler) -> GlobalParameters const & {
+                return *ioHandler;
+            }},
+        this->as_parent());
+}
+
+auto AbstractIOHandlerInitFrom::asGlobalParameters() -> GlobalParameters &
+{
+    return const_cast<GlobalParameters &>(
+        static_cast<AbstractIOHandlerInitFrom const *>(this)
+            ->asGlobalParameters());
+}
+} // namespace openPMD::internal
diff --git a/src/IO/AbstractIOHandlerHelper.cpp b/src/IO/AbstractIOHandlerHelper.cpp
index 443d22f498..f1855738bf 100644
--- a/src/IO/AbstractIOHandlerHelper.cpp
+++ b/src/IO/AbstractIOHandlerHelper.cpp
@@ -20,6 +20,7 @@
  */
 #include "openPMD/IO/AbstractIOHandlerHelper.hpp"
 
+#include "openPMD/IO/AbstractIOHandler_internal.hpp"
 #include "openPMD/config.hpp"
 
 #include "openPMD/Error.hpp"
@@ -64,10 +65,9 @@ namespace
 
 #if openPMD_HAVE_MPI
 template <>
-std::unique_ptr<AbstractIOHandler> createIOHandler<json::TracingJSON>(
-    std::optional<std::unique_ptr<AbstractIOHandler>> initialize_from,
-    std::string path,
-    Access access,
+std::unique_ptr<AbstractIOHandler>
+createIOHandler<internal::AbstractIOHandlerInitFrom, json::TracingJSON>(
+    internal::AbstractIOHandlerInitFrom &&initialize_from,
     Format format,
     std::string originalExtension,
     MPI_Comm comm,
@@ -79,18 +79,11 @@ std::unique_ptr<AbstractIOHandler> createIOHandler<json::TracingJSON>(
     {
     case Format::HDF5:
         return constructIOHandler<ParallelHDF5IOHandler, openPMD_HAVE_HDF5>(
-            "HDF5",
-            std::move(initialize_from),
-            std::move(path),
-            access,
-            comm,
-            std::move(options));
+            "HDF5", std::move(initialize_from), comm, std::move(options));
     case Format::ADIOS2_BP:
         return constructIOHandler<ADIOS2IOHandler, openPMD_HAVE_ADIOS2>(
             "ADIOS2",
             std::move(initialize_from),
-            std::move(path),
-            access,
             comm,
             std::move(options),
             "file",
@@ -99,8 +92,6 @@ std::unique_ptr<AbstractIOHandler> createIOHandler<json::TracingJSON>(
         return constructIOHandler<ADIOS2IOHandler, openPMD_HAVE_ADIOS2>(
             "ADIOS2",
             std::move(initialize_from),
-            std::move(path),
-            access,
             comm,
             std::move(options),
             "bp4",
@@ -109,8 +100,6 @@ std::unique_ptr<AbstractIOHandler> createIOHandler<json::TracingJSON>(
         return constructIOHandler<ADIOS2IOHandler, openPMD_HAVE_ADIOS2>(
             "ADIOS2",
             std::move(initialize_from),
-            std::move(path),
-            access,
             comm,
             std::move(options),
             "bp5",
@@ -119,8 +108,6 @@ std::unique_ptr<AbstractIOHandler> createIOHandler<json::TracingJSON>(
         return constructIOHandler<ADIOS2IOHandler, openPMD_HAVE_ADIOS2>(
             "ADIOS2",
             std::move(initialize_from),
-            std::move(path),
-            access,
             comm,
             std::move(options),
             "sst",
@@ -129,8 +116,6 @@ std::unique_ptr<AbstractIOHandler> createIOHandler<json::TracingJSON>(
         return constructIOHandler<ADIOS2IOHandler, openPMD_HAVE_ADIOS2>(
             "ADIOS2",
             std::move(initialize_from),
-            std::move(path),
-            access,
             comm,
             std::move(options),
             "ssc",
@@ -139,8 +124,6 @@ std::unique_ptr<AbstractIOHandler> createIOHandler<json::TracingJSON>(
         return constructIOHandler<JSONIOHandler, openPMD_HAVE_JSON>(
             "JSON",
             std::move(initialize_from),
-            std::move(path),
-            access,
             comm,
             std::move(options),
             JSONIOHandlerImpl::FileFormat::Json,
@@ -149,8 +132,6 @@ std::unique_ptr<AbstractIOHandler> createIOHandler<json::TracingJSON>(
         return constructIOHandler<JSONIOHandler, openPMD_HAVE_JSON>(
             "JSON",
             std::move(initialize_from),
-            std::move(path),
-            access,
             comm,
             std::move(options),
             JSONIOHandlerImpl::FileFormat::Toml,
@@ -165,10 +146,9 @@ std::unique_ptr<AbstractIOHandler> createIOHandler<json::TracingJSON>(
 #endif
 
 template <>
-std::unique_ptr<AbstractIOHandler> createIOHandler<json::TracingJSON>(
-    std::optional<std::unique_ptr<AbstractIOHandler>> initialize_from,
-    std::string path,
-    Access access,
+std::unique_ptr<AbstractIOHandler>
+createIOHandler<internal::AbstractIOHandlerInitFrom, json::TracingJSON>(
+    internal::AbstractIOHandlerInitFrom &&initialize_from,
     Format format,
     std::string originalExtension,
     json::TracingJSON options,
@@ -179,17 +159,11 @@ std::unique_ptr<AbstractIOHandler> createIOHandler<json::TracingJSON>(
     {
     case Format::HDF5:
         return constructIOHandler<HDF5IOHandler, openPMD_HAVE_HDF5>(
-            "HDF5",
-            std::move(initialize_from),
-            std::move(path),
-            access,
-            std::move(options));
+            "HDF5", std::move(initialize_from), std::move(options));
     case Format::ADIOS2_BP:
         return constructIOHandler<ADIOS2IOHandler, openPMD_HAVE_ADIOS2>(
             "ADIOS2",
             std::move(initialize_from),
-            std::move(path),
-            access,
             std::move(options),
             "file",
             std::move(originalExtension));
@@ -197,8 +171,6 @@ std::unique_ptr<AbstractIOHandler> createIOHandler<json::TracingJSON>(
         return constructIOHandler<ADIOS2IOHandler, openPMD_HAVE_ADIOS2>(
             "ADIOS2",
             std::move(initialize_from),
-            std::move(path),
-            access,
             std::move(options),
             "bp4",
             std::move(originalExtension));
@@ -206,8 +178,6 @@ std::unique_ptr<AbstractIOHandler> createIOHandler<json::TracingJSON>(
         return constructIOHandler<ADIOS2IOHandler, openPMD_HAVE_ADIOS2>(
             "ADIOS2",
             std::move(initialize_from),
-            std::move(path),
-            access,
             std::move(options),
             "bp5",
             std::move(originalExtension));
@@ -215,8 +185,6 @@ std::unique_ptr<AbstractIOHandler> createIOHandler<json::TracingJSON>(
         return constructIOHandler<ADIOS2IOHandler, openPMD_HAVE_ADIOS2>(
             "ADIOS2",
             std::move(initialize_from),
-            std::move(path),
-            access,
             std::move(options),
             "sst",
             std::move(originalExtension));
@@ -224,8 +192,6 @@ std::unique_ptr<AbstractIOHandler> createIOHandler<json::TracingJSON>(
         return constructIOHandler<ADIOS2IOHandler, openPMD_HAVE_ADIOS2>(
             "ADIOS2",
             std::move(initialize_from),
-            std::move(path),
-            access,
             std::move(options),
             "ssc",
             std::move(originalExtension));
@@ -233,8 +199,6 @@ std::unique_ptr<AbstractIOHandler> createIOHandler<json::TracingJSON>(
         return constructIOHandler<JSONIOHandler, openPMD_HAVE_JSON>(
             "JSON",
             std::move(initialize_from),
-            std::move(path),
-            access,
             std::move(options),
             JSONIOHandlerImpl::FileFormat::Json,
             std::move(originalExtension));
@@ -242,8 +206,6 @@ std::unique_ptr<AbstractIOHandler> createIOHandler<json::TracingJSON>(
         return constructIOHandler<JSONIOHandler, openPMD_HAVE_JSON>(
             "JSON",
             std::move(initialize_from),
-            std::move(path),
-            access,
             std::move(options),
             JSONIOHandlerImpl::FileFormat::Toml,
             std::move(originalExtension));
@@ -255,17 +217,15 @@ std::unique_ptr<AbstractIOHandler> createIOHandler<json::TracingJSON>(
     }
 }
 
-std::unique_ptr<AbstractIOHandler> createIOHandler(
-    std::optional<std::unique_ptr<AbstractIOHandler>> initialize_from,
-    std::string path,
-    Access access,
+template <>
+std::unique_ptr<AbstractIOHandler>
+createIOHandler<internal::AbstractIOHandlerInitFrom>(
+    internal::AbstractIOHandlerInitFrom &&initialize_from,
     Format format,
     std::string originalExtension)
 {
     return createIOHandler(
         std::move(initialize_from),
-        std::move(path),
-        access,
         format,
         std::move(originalExtension),
         json::TracingJSON(json::ParsedConfig{}),
diff --git a/src/IO/AbstractIOHandlerImpl.cpp b/src/IO/AbstractIOHandlerImpl.cpp
index 4f93ff1a5b..fe5efc2d66 100644
--- a/src/IO/AbstractIOHandlerImpl.cpp
+++ b/src/IO/AbstractIOHandlerImpl.cpp
@@ -275,10 +275,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..2147ef8cc1 100644
--- a/src/IO/DummyIOHandler.cpp
+++ b/src/IO/DummyIOHandler.cpp
@@ -19,19 +19,16 @@
  * If not, see <http://www.gnu.org/licenses/>.
  */
 #include "openPMD/IO/DummyIOHandler.hpp"
+#include "openPMD/IO/AbstractIOHandler_internal.hpp"
 #include "openPMD/auxiliary/JSON_internal.hpp"
 
-#include <iostream>
-#include <optional>
 #include <utility>
 
 namespace openPMD
 {
-DummyIOHandler::DummyIOHandler(std::string path, Access at)
+DummyIOHandler::DummyIOHandler(internal::AbstractIOHandlerInitFrom &&init_from)
     : AbstractIOHandler(
-          std::nullopt,
-          std::move(path),
-          at,
+          std::move(init_from),
           json::TracingJSON(
               nlohmann::json::object(), json::SupportedLanguages::JSON))
 {}
@@ -39,7 +36,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..7ab2dc34a1 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;
@@ -3414,37 +3420,31 @@ std::future<void> HDF5IOHandlerImpl::flush(internal::ParsedFlushParams &params)
 
 #if openPMD_HAVE_HDF5
 HDF5IOHandler::HDF5IOHandler(
-    std::optional<std::unique_ptr<AbstractIOHandler>> initialize_from,
-    std::string path,
-    Access at,
+    internal::AbstractIOHandlerInitFrom &&initialize_from,
     json::TracingJSON config)
-    : AbstractIOHandler(
-          std::move(initialize_from), std::move(path), at, std::move(config))
+    : AbstractIOHandler(std::move(initialize_from), std::move(config))
     , m_impl{new HDF5IOHandlerImpl(this)}
 {}
 
 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);
 }
 #else
 
 HDF5IOHandler::HDF5IOHandler(
-    std::optional<std::unique_ptr<AbstractIOHandler>> initialize_from,
-    std::string path,
-    Access at,
+    internal::AbstractIOHandlerInitFrom &&initialize_from,
     json::TracingJSON config)
-    : AbstractIOHandler(
-          std::move(initialize_from), std::move(path), at, std::move(config))
+    : AbstractIOHandler(std::move(initialize_from), std::move(config))
 {
     throw std::runtime_error("openPMD-api built without HDF5 support");
 }
 
 HDF5IOHandler::~HDF5IOHandler() = default;
 
-std::future<void> HDF5IOHandler::flush(internal::ParsedFlushParams &)
+std::future<void> HDF5IOHandler::flush_impl(internal::ParsedFlushParams &)
 {
     return std::future<void>();
 }
diff --git a/src/IO/HDF5/ParallelHDF5IOHandler.cpp b/src/IO/HDF5/ParallelHDF5IOHandler.cpp
index 7de4960feb..fc568e5294 100644
--- a/src/IO/HDF5/ParallelHDF5IOHandler.cpp
+++ b/src/IO/HDF5/ParallelHDF5IOHandler.cpp
@@ -21,6 +21,7 @@
  */
 #include "openPMD/IO/HDF5/ParallelHDF5IOHandler.hpp"
 #include "openPMD/Error.hpp"
+#include "openPMD/IO/AbstractIOHandler_internal.hpp"
 #include "openPMD/IO/FlushParametersInternal.hpp"
 #include "openPMD/IO/HDF5/HDF5IOHandlerImpl.hpp"
 #include "openPMD/IO/HDF5/ParallelHDF5IOHandlerImpl.hpp"
@@ -59,24 +60,17 @@ namespace openPMD
 #endif
 
 ParallelHDF5IOHandler::ParallelHDF5IOHandler(
-    std::optional<std::unique_ptr<AbstractIOHandler>> initialize_from,
-    std::string path,
-    Access at,
+    internal::AbstractIOHandlerInitFrom &&initialize_from,
     MPI_Comm comm,
     json::TracingJSON config)
-    : AbstractIOHandler(
-          std::move(initialize_from),
-          std::move(path),
-          at,
-          std::move(config),
-          comm)
+    : AbstractIOHandler(std::move(initialize_from), std::move(config), comm)
     , m_impl{new ParallelHDF5IOHandlerImpl(this, comm)}
 {}
 
 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())
@@ -433,27 +427,18 @@ ParallelHDF5IOHandlerImpl::flush(internal::ParsedFlushParams &params)
 
 #if openPMD_HAVE_MPI
 ParallelHDF5IOHandler::ParallelHDF5IOHandler(
-    std::optional<std::unique_ptr<AbstractIOHandler>> initialize_from,
-    std::string path,
-    Access at,
+    internal::AbstractIOHandlerInitFrom &&initialize_from,
     MPI_Comm comm,
     json::TracingJSON config)
-    : AbstractIOHandler(
-          std::move(initialize_from),
-          std::move(path),
-          at,
-          std::move(config),
-          comm)
+    : AbstractIOHandler(std::move(initialize_from), std::move(config), comm)
 {
     throw std::runtime_error("openPMD-api built without HDF5 support");
 }
 #else
 ParallelHDF5IOHandler::ParallelHDF5IOHandler(
-    std::optional<std::unique_ptr<AbstractIOHandler>> initialize_from,
-    std::string const &path,
-    Access at,
+    internal::AbstractIOHandlerInitFrom &&initialize_from,
     json::TracingJSON config)
-    : AbstractIOHandler(std::move(initialize_from), path, at, std::move(config))
+    : AbstractIOHandler(std::move(initialize_from), std::move(config))
 {
     throw std::runtime_error(
         "openPMD-api built without parallel support and without HDF5 support");
@@ -462,7 +447,8 @@ ParallelHDF5IOHandler::ParallelHDF5IOHandler(
 
 ParallelHDF5IOHandler::~ParallelHDF5IOHandler() = default;
 
-std::future<void> ParallelHDF5IOHandler::flush(internal::ParsedFlushParams &)
+std::future<void>
+ParallelHDF5IOHandler::flush_impl(internal::ParsedFlushParams &)
 {
     return std::future<void>();
 }
diff --git a/src/IO/JSON/JSONIOHandler.cpp b/src/IO/JSON/JSONIOHandler.cpp
index 03cef438d3..f103a5c47a 100644
--- a/src/IO/JSON/JSONIOHandler.cpp
+++ b/src/IO/JSON/JSONIOHandler.cpp
@@ -20,38 +20,35 @@
  */
 
 #include "openPMD/IO/JSON/JSONIOHandler.hpp"
+#include "openPMD/IO/AbstractIOHandler_internal.hpp"
 
 namespace openPMD
 {
 JSONIOHandler::~JSONIOHandler() = default;
 
 JSONIOHandler::JSONIOHandler(
-    std::optional<std::unique_ptr<AbstractIOHandler>> initialize_from,
-    std::string path,
-    Access at,
+    internal::AbstractIOHandlerInitFrom &&initialize_from,
     openPMD::json::TracingJSON jsonCfg,
     JSONIOHandlerImpl::FileFormat format,
     std::string originalExtension)
-    : AbstractIOHandler{std::move(initialize_from), std::move(path), at, std::move(jsonCfg)}
+    : AbstractIOHandler{std::move(initialize_from), std::move(jsonCfg)}
     , m_impl{this, format, std::move(originalExtension)}
 {}
 
 #if openPMD_HAVE_MPI
 JSONIOHandler::JSONIOHandler(
-    std::optional<std::unique_ptr<AbstractIOHandler>> initialize_from,
-    std::string path,
-    Access at,
+    internal::AbstractIOHandlerInitFrom &&initialize_from,
     MPI_Comm comm,
     openPMD::json::TracingJSON jsonCfg,
     JSONIOHandlerImpl::FileFormat format,
     std::string originalExtension)
-    : AbstractIOHandler{std::move(initialize_from), std::move(path), at, std::move(jsonCfg)}
+    : AbstractIOHandler{std::move(initialize_from), std::move(jsonCfg)}
     , m_impl{
           JSONIOHandlerImpl{this, comm, format, std::move(originalExtension)}}
 {}
 #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/Iteration.cpp b/src/Iteration.cpp
index ab35c1e3ae..40ed795310 100644
--- a/src/Iteration.cpp
+++ b/src/Iteration.cpp
@@ -32,6 +32,7 @@
 #include "openPMD/auxiliary/StringManip.hpp"
 #include "openPMD/auxiliary/Variant.hpp"
 #include "openPMD/backend/Attributable.hpp"
+#include "openPMD/backend/ScientificDefaults.hpp"
 #include "openPMD/backend/Variant_internal.hpp"
 #include "openPMD/backend/Writable.hpp"
 
@@ -52,9 +53,6 @@ using internal::DeferredParseAccess;
 Iteration::Iteration() : Attributable(NoInit())
 {
     setData(std::make_shared<Data_t>());
-    setTime(static_cast<double>(0));
-    setDt(static_cast<double>(1));
-    setTimeUnitSI(1);
     meshes.writable().ownKeyWithinParent = "meshes";
     particles.writable().ownKeyWithinParent = "particles";
 }
@@ -112,6 +110,12 @@ Iteration &Iteration::close(bool _flush)
         // yet keeps it re-openable)
         break;
     }
+
+    if (access::write(IOHandler()->m_frontendAccess))
+    {
+        addDefaultsRecursively(IOHandler()->m_standard);
+    }
+
     if (_flush)
     {
         if (flag == StepStatus::DuringStep)
@@ -268,15 +272,9 @@ void Iteration::flushFileBased(
         s.openIteration(i, *this);
     }
 
-    switch (flushParams.flushLevel)
+    if (flush_level::flush_hierarchy(flushParams.flushLevel))
     {
-    case FlushLevel::CreateOrOpenFiles:
-        break;
-    case FlushLevel::SkeletonOnly:
-    case FlushLevel::InternalFlush:
-    case FlushLevel::UserFlush:
         flush(flushParams);
-        break;
     }
 }
 
@@ -291,15 +289,9 @@ void Iteration::flushGroupBased(
         IOHandler()->enqueue(IOTask(this, pCreate));
     }
 
-    switch (flushParams.flushLevel)
+    if (flush_level::flush_hierarchy(flushParams.flushLevel))
     {
-    case FlushLevel::CreateOrOpenFiles:
-        break;
-    case FlushLevel::SkeletonOnly:
-    case FlushLevel::InternalFlush:
-    case FlushLevel::UserFlush:
         flush(flushParams);
-        break;
     }
 }
 
@@ -314,17 +306,13 @@ void Iteration::flushVariableBased(
         IOHandler()->enqueue(IOTask(this, pOpen));
     }
 
-    switch (flushParams.flushLevel)
+    if (!flush_level::flush_hierarchy(flushParams.flushLevel))
     {
-    case FlushLevel::CreateOrOpenFiles:
         return;
-    case FlushLevel::SkeletonOnly:
-    case FlushLevel::InternalFlush:
-    case FlushLevel::UserFlush:
-        flush(flushParams);
-        break;
     }
 
+    flush(flushParams);
+
     if (!written())
     {
         /* create iteration path */
@@ -357,7 +345,7 @@ void Iteration::flush(internal::FlushParams const &flushParams)
             m.second.flush(m.first, flushParams);
         for (auto &species : particles)
             species.second.flush(species.first, flushParams);
-        setDirty(false);
+        determineUnsetDirty(flushParams.flushLevel);
     }
     else
     {
@@ -411,9 +399,9 @@ void Iteration::flush(internal::FlushParams const &flushParams)
     }
     if (flushParams.flushLevel != FlushLevel::SkeletonOnly)
     {
-        setDirty(false);
-        meshes.setDirty(false);
-        particles.setDirty(false);
+        determineUnsetDirty(flushParams.flushLevel);
+        meshes.determineUnsetDirty(flushParams.flushLevel);
+        particles.determineUnsetDirty(flushParams.flushLevel);
     }
 }
 
@@ -499,78 +487,8 @@ void Iteration::read_impl(std::string const &groupPath)
     pOpen.path = groupPath;
     IOHandler()->enqueue(IOTask(this, pOpen));
 
-    using DT = Datatype;
-    Parameter<Operation::READ_ATT> aRead;
-
-    aRead.name = "dt";
-    IOHandler()->enqueue(IOTask(this, aRead));
-    IOHandler()->flush(internal::defaultFlushParams);
-    if (*aRead.dtype == DT::FLOAT)
-        setDt(Attribute(Attribute::from_any, *aRead.m_resource).get<float>());
-    else if (*aRead.dtype == DT::DOUBLE)
-        setDt(Attribute(Attribute::from_any, *aRead.m_resource).get<double>());
-    else if (*aRead.dtype == DT::LONG_DOUBLE)
-        setDt(Attribute(Attribute::from_any, *aRead.m_resource)
-                  .get<long double>());
-    // conversion cast if a backend reports an integer type
-    else if (auto val = Attribute(Attribute::from_any, *aRead.m_resource)
-                            .getOptional<double>();
-             val.has_value())
-        setDt(val.value());
-    else
-        throw error::ReadError(
-            error::AffectedObject::Attribute,
-            error::Reason::UnexpectedContent,
-            {},
-            "Unexpected Attribute datatype for 'dt' (expected double, found " +
-                datatypeToString(
-                    Attribute(Attribute::from_any, *aRead.m_resource).dtype) +
-                ")");
-
-    aRead.name = "time";
-    IOHandler()->enqueue(IOTask(this, aRead));
-    IOHandler()->flush(internal::defaultFlushParams);
-    if (*aRead.dtype == DT::FLOAT)
-        setTime(Attribute(Attribute::from_any, *aRead.m_resource).get<float>());
-    else if (*aRead.dtype == DT::DOUBLE)
-        setTime(
-            Attribute(Attribute::from_any, *aRead.m_resource).get<double>());
-    else if (*aRead.dtype == DT::LONG_DOUBLE)
-        setTime(Attribute(Attribute::from_any, *aRead.m_resource)
-                    .get<long double>());
-    // conversion cast if a backend reports an integer type
-    else if (auto val = Attribute(Attribute::from_any, *aRead.m_resource)
-                            .getOptional<double>();
-             val.has_value())
-        setTime(val.value());
-    else
-        throw error::ReadError(
-            error::AffectedObject::Attribute,
-            error::Reason::UnexpectedContent,
-            {},
-            "Unexpected Attribute datatype for 'time' (expected double, "
-            "found " +
-                datatypeToString(
-                    Attribute(Attribute::from_any, *aRead.m_resource).dtype) +
-                ")");
-
-    aRead.name = "timeUnitSI";
-    IOHandler()->enqueue(IOTask(this, aRead));
-    IOHandler()->flush(internal::defaultFlushParams);
-    if (auto val = Attribute(Attribute::from_any, *aRead.m_resource)
-                       .getOptional<double>();
-        val.has_value())
-        setTimeUnitSI(val.value());
-    else
-        throw error::ReadError(
-            error::AffectedObject::Attribute,
-            error::Reason::UnexpectedContent,
-            {},
-            "Unexpected Attribute datatype for 'timeUnitSI' (expected double, "
-            "found " +
-                datatypeToString(
-                    Attribute(Attribute::from_any, *aRead.m_resource).dtype) +
-                ")");
+    internal::ScientificDefaults<Iteration>::readDefaults(
+        IOHandler()->m_standard);
 
     /* Find the root point [Series] of this file,
      * meshesPath and particlesPath are stored there */
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/Mesh.cpp b/src/Mesh.cpp
index e93b2b5219..985e4643b1 100644
--- a/src/Mesh.cpp
+++ b/src/Mesh.cpp
@@ -28,6 +28,7 @@
 #include "openPMD/auxiliary/DerefDynamicCast.hpp"
 #include "openPMD/auxiliary/StringManip.hpp"
 #include "openPMD/backend/Attribute.hpp"
+#include "openPMD/backend/ScientificDefaults.hpp"
 #include "openPMD/backend/Writable.hpp"
 
 #include <algorithm>
@@ -35,17 +36,7 @@
 
 namespace openPMD
 {
-Mesh::Mesh()
-{
-    setTimeOffset(0.f);
-
-    setGeometry(Geometry::cartesian);
-    setDataOrder(DataOrder::C);
-
-    setAxisLabels({"x"}); // empty strings are not allowed in HDF5
-    setGridSpacing(std::vector<double>{1});
-    setGridGlobalOffset({0});
-}
+Mesh::Mesh() = default;
 
 Mesh::Geometry Mesh::geometry() const
 {
@@ -204,27 +195,24 @@ Mesh &Mesh::setGridUnitSI(std::vector<double> const &gusi)
     return setGridUnitSIPerDimension(gusi);
 }
 
-namespace
+auto Mesh::retrieveDimensionality() const -> uint64_t
 {
-    uint64_t retrieveMeshDimensionality(Mesh const &m)
+    if (containsAttribute("axisLabels"))
     {
-        if (m.containsAttribute("axisLabels"))
-        {
-            return m.axisLabels().size();
-        }
+        return axisLabels().size();
+    }
 
-        // maybe we have record components and can ask them
-        if (auto it = m.begin(); it != m.end())
-        {
-            return it->second.getDimensionality();
-        }
-        /*
-         * Since some backends cannot distinguish between vector and
-         * scalar values, the most likely answer here is 1.
-         */
-        return 1;
+    // maybe we have record components and can ask them
+    if (auto it = begin(); it != end())
+    {
+        return it->second.getDimensionality();
     }
-} // namespace
+    /*
+     * Since some backends cannot distinguish between vector and
+     * scalar values, the most likely answer here is 1.
+     */
+    return 1;
+}
 
 std::vector<double> Mesh::gridUnitSIPerDimension() const
 {
@@ -235,7 +223,7 @@ std::vector<double> Mesh::gridUnitSIPerDimension() const
             // If the openPMD version is lower than 2.0, the gridUnitSI is a
             // scalar interpreted for all axes. Copy it d times.
             return std::vector<double>(
-                retrieveMeshDimensionality(*this),
+                retrieveDimensionality(),
                 getAttribute("gridUnitSI").get<double>());
         }
         return getAttribute("gridUnitSI").get<std::vector<double>>();
@@ -244,7 +232,7 @@ std::vector<double> Mesh::gridUnitSIPerDimension() const
     {
         // gridUnitSI is an optional attribute
         // if it is missing, the mesh is interpreted as unscaled
-        return std::vector<double>(retrieveMeshDimensionality(*this), 1.);
+        return std::vector<double>(retrieveDimensionality(), 1.);
     }
 }
 
@@ -269,7 +257,9 @@ Mesh &Mesh::setUnitDimension(unit_representations::AsMap const &udim)
 {
     if (!udim.empty())
     {
-        std::array<double, 7> tmpUnitDimension = this->unitDimension();
+        std::array<double, 7> tmpUnitDimension =
+            this->containsAttribute("unitDimension") ? this->unitDimension()
+                                                     : std::array<double, 7>{0};
         unit_representations::auxiliary::fromMapOfUnitDimension(
             tmpUnitDimension.data(), udim);
         setAttribute("unitDimension", tmpUnitDimension);
@@ -285,15 +275,20 @@ Mesh &Mesh::setUnitDimension(unit_representations::AsArray const &udim)
 
 Mesh &Mesh::setGridUnitDimension(unit_representations::AsMaps const &udims)
 {
-    auto rawGridUnitDimension = [this]() {
-        try
+    auto rawGridUnitDimension = [&udims, this]() {
+        if (!this->containsAttribute("gridUnitDimension"))
         {
-            return this->getAttribute("gridUnitDimension")
-                .get<std::vector<double>>();
+            std::vector<double> res(udims.size() * 7);
+            // for (size_t i = 0; i < udims.size(); ++i)
+            // {
+            //     res[7 * i] = 1;
+            // }
+            return res;
         }
-        catch (no_such_attribute_error const &)
+        else
         {
-            return std::vector<double>();
+            return this->getAttribute("gridUnitDimension")
+                .get<std::vector<double>>();
         }
     }();
     rawGridUnitDimension.resize(7 * udims.size());
@@ -341,7 +336,7 @@ unit_representations::AsArrays Mesh::gridUnitDimension() const
         // if it is missing, the mesh is interpreted as spatial
         auto spatialMesh =
             unit_representations::asArray({{UnitDimension::L, 1}});
-        auto dim = retrieveMeshDimensionality(*this);
+        auto dim = retrieveDimensionality();
         unit_representations::AsArrays res(dim, spatialMesh);
         return res;
     }
@@ -417,18 +412,6 @@ void Mesh::flush_impl(
                     comp.second.flush(comp.first, flushParams);
             }
         }
-        if (!containsAttribute("gridUnitSI"))
-        {
-            if (IOHandler()->m_standard < OpenpmdStandard::v_2_0_0)
-            {
-                setGridUnitSI(1);
-            }
-            else
-            {
-                setGridUnitSIPerDimension(
-                    std::vector<double>(retrieveMeshDimensionality(*this), 1));
-            }
-        }
         flushAttributes(flushParams);
     }
 }
@@ -439,170 +422,7 @@ void Mesh::read()
         IOHandler()->m_verify_homogeneous_extents);
     internal::EraseStaleEntries<Mesh> map{*this};
 
-    using DT = Datatype;
-    Parameter<Operation::READ_ATT> aRead;
-
-    aRead.name = "geometry";
-    IOHandler()->enqueue(IOTask(this, aRead));
-    IOHandler()->flush(internal::defaultFlushParams);
-    if (*aRead.dtype == DT::STRING)
-    {
-        std::string tmpGeometry =
-            Attribute(Attribute::from_any, *aRead.m_resource)
-                .get<std::string>();
-        if ("cartesian" == tmpGeometry)
-            setGeometry(Geometry::cartesian);
-        else if ("thetaMode" == tmpGeometry)
-            setGeometry(Geometry::thetaMode);
-        else if ("cylindrical" == tmpGeometry)
-            setGeometry(Geometry::cylindrical);
-        else if ("spherical" == tmpGeometry)
-            setGeometry(Geometry::spherical);
-        else
-            setGeometry(tmpGeometry);
-    }
-    else
-        throw error::ReadError(
-            error::AffectedObject::Attribute,
-            error::Reason::UnexpectedContent,
-            {},
-            "Unexpected Attribute datatype for 'geometry' (expected a string, "
-            "found " +
-                datatypeToString(
-                    Attribute(Attribute::from_any, *aRead.m_resource).dtype) +
-                ")");
-
-    aRead.name = "dataOrder";
-    IOHandler()->enqueue(IOTask(this, aRead));
-    IOHandler()->flush(internal::defaultFlushParams);
-    if (*aRead.dtype == DT::CHAR)
-        setDataOrder(
-            static_cast<DataOrder>(
-                Attribute(Attribute::from_any, *aRead.m_resource).get<char>()));
-    else if (*aRead.dtype == DT::STRING)
-    {
-        std::string tmpDataOrder =
-            Attribute(Attribute::from_any, *aRead.m_resource)
-                .get<std::string>();
-        if (tmpDataOrder.size() == 1)
-            setDataOrder(static_cast<DataOrder>(tmpDataOrder[0]));
-        else
-            throw error::ReadError(
-                error::AffectedObject::Attribute,
-                error::Reason::UnexpectedContent,
-                {},
-                "Unexpected Attribute value for 'dataOrder': " + tmpDataOrder);
-    }
-    else
-        throw error::ReadError(
-            error::AffectedObject::Attribute,
-            error::Reason::UnexpectedContent,
-            {},
-            "Unexpected Attribute datatype for 'dataOrder' (expected char or "
-            "string, found " +
-                datatypeToString(
-                    Attribute(Attribute::from_any, *aRead.m_resource).dtype) +
-                ")");
-
-    aRead.name = "axisLabels";
-    IOHandler()->enqueue(IOTask(this, aRead));
-    IOHandler()->flush(internal::defaultFlushParams);
-    Attribute a = Attribute(Attribute::from_any, *aRead.m_resource);
-    if (auto val = a.getOptional<std::vector<std::string>>(); val.has_value())
-        setAxisLabels(*val);
-    else
-        throw error::ReadError(
-            error::AffectedObject::Attribute,
-            error::Reason::UnexpectedContent,
-            {},
-            "Unexpected Attribute datatype for 'axisLabels' (expected a vector "
-            "of string, found " +
-                datatypeToString(
-                    Attribute(Attribute::from_any, *aRead.m_resource).dtype) +
-                ")");
-
-    aRead.name = "gridSpacing";
-    IOHandler()->enqueue(IOTask(this, aRead));
-    IOHandler()->flush(internal::defaultFlushParams);
-    a = Attribute(Attribute::from_any, *aRead.m_resource);
-    if (*aRead.dtype == DT::VEC_FLOAT || *aRead.dtype == DT::FLOAT)
-        setGridSpacing(a.get<std::vector<float>>());
-    else if (*aRead.dtype == DT::VEC_DOUBLE || *aRead.dtype == DT::DOUBLE)
-        setGridSpacing(a.get<std::vector<double>>());
-    else if (
-        *aRead.dtype == DT::VEC_LONG_DOUBLE || *aRead.dtype == DT::LONG_DOUBLE)
-        setGridSpacing(a.get<std::vector<long double>>());
-    // conversion cast if a backend reports an integer type
-    else if (auto val = a.getOptional<std::vector<double>>(); val.has_value())
-        setGridSpacing(val.value());
-    else
-        throw error::ReadError(
-            error::AffectedObject::Attribute,
-            error::Reason::UnexpectedContent,
-            {},
-            "Unexpected Attribute datatype for 'gridSpacing' (expected a "
-            "vector of double, found " +
-                datatypeToString(
-                    Attribute(Attribute::from_any, *aRead.m_resource).dtype) +
-                ")");
-
-    aRead.name = "gridGlobalOffset";
-    IOHandler()->enqueue(IOTask(this, aRead));
-    IOHandler()->flush(internal::defaultFlushParams);
-    if (auto val = Attribute(Attribute::from_any, *aRead.m_resource)
-                       .getOptional<std::vector<double>>();
-        val.has_value())
-        setGridGlobalOffset(val.value());
-    else
-        throw error::ReadError(
-            error::AffectedObject::Attribute,
-            error::Reason::UnexpectedContent,
-            {},
-            "Unexpected Attribute datatype for 'gridGlobalOffset' (expected a "
-            "vector of double, found " +
-                datatypeToString(
-                    Attribute(Attribute::from_any, *aRead.m_resource).dtype) +
-                ")");
-
-    aRead.name = "gridUnitSI";
-    IOHandler()->enqueue(IOTask(this, aRead));
-    IOHandler()->flush(internal::defaultFlushParams);
-    if (IOHandler()->m_standard >= OpenpmdStandard::v_2_0_0)
-    {
-        if (auto val = Attribute(Attribute::from_any, *aRead.m_resource)
-                           .getOptional<std::vector<double>>();
-            val.has_value())
-            setGridUnitSIPerDimension(val.value());
-        else
-            throw error::ReadError(
-                error::AffectedObject::Attribute,
-                error::Reason::UnexpectedContent,
-                {},
-                "Unexpected Attribute datatype for 'gridUnitSI' "
-                "(expected vector of double, found " +
-                    datatypeToString(
-                        Attribute(Attribute::from_any, *aRead.m_resource)
-                            .dtype) +
-                    ")");
-    }
-    else
-    {
-        if (auto val = Attribute(Attribute::from_any, *aRead.m_resource)
-                           .getOptional<double>();
-            val.has_value())
-            setGridUnitSI(val.value());
-        else
-            throw error::ReadError(
-                error::AffectedObject::Attribute,
-                error::Reason::UnexpectedContent,
-                {},
-                "Unexpected Attribute datatype for 'gridUnitSI' "
-                "(expected double, found " +
-                    datatypeToString(
-                        Attribute(Attribute::from_any, *aRead.m_resource)
-                            .dtype) +
-                    ")");
-    }
+    internal::ScientificDefaults<Mesh>::readDefaults(IOHandler()->m_standard);
 
     if (scalar())
     {
@@ -669,7 +489,7 @@ void Mesh::read()
 
     std::move(homogenizeExtents).homogenize(*this);
 
-    readBase();
+    internal::ScientificDefaults<Mesh>::readDefaults(IOHandler()->m_standard);
 
     readAttributes(ReadMode::FullyReread);
 }
diff --git a/src/ParticlePatches.cpp b/src/ParticlePatches.cpp
index 789559a67f..9a18a7d34f 100644
--- a/src/ParticlePatches.cpp
+++ b/src/ParticlePatches.cpp
@@ -100,7 +100,7 @@ void ParticlePatches::read()
         pr.setDirty(false);
         try
         {
-            prc.PatchRecordComponent::read(/* require_unit_si = */ false);
+            prc.PatchRecordComponent::read();
         }
         catch (error::ReadError const &err)
         {
diff --git a/src/ParticleSpecies.cpp b/src/ParticleSpecies.cpp
index b3e7ea1f7e..bd17992354 100644
--- a/src/ParticleSpecies.cpp
+++ b/src/ParticleSpecies.cpp
@@ -175,23 +175,9 @@ void ParticleSpecies::flush(
             record.second.flush(record.first, flushParams);
         for (auto &patch : particlePatches)
             patch.second.flush(patch.first, flushParams);
-        if (flushParams.flushLevel != FlushLevel::SkeletonOnly)
-        {
-            particlePatches.setDirty(false);
-        }
     }
     else
     {
-        if (flushParams.flushLevel != FlushLevel::SkeletonOnly)
-        {
-            auto it = find("position");
-            if (it != end())
-                it->second.setUnitDimension({{UnitDimension::L, 1}});
-            it = find("positionOffset");
-            if (it != end())
-                it->second.setUnitDimension({{UnitDimension::L, 1}});
-        }
-
         Container<Record>::flush(path, flushParams);
 
         for (auto &record : *this)
@@ -203,14 +189,8 @@ void ParticleSpecies::flush(
             for (auto &patch : particlePatches)
                 patch.second.flush(patch.first, flushParams);
         }
-        else
-        {
-            particlePatches.setDirty(false);
-        }
-    }
-    if (flushParams.flushLevel != FlushLevel::SkeletonOnly)
-    {
-        setDirty(false);
     }
+    determineUnsetDirty(flushParams.flushLevel);
+    particlePatches.determineUnsetDirty(flushParams.flushLevel);
 }
 } // namespace openPMD
diff --git a/src/Record.cpp b/src/Record.cpp
index 8056718edd..f45792b729 100644
--- a/src/Record.cpp
+++ b/src/Record.cpp
@@ -24,21 +24,21 @@
 #include "openPMD/ThrowError.hpp"
 #include "openPMD/UnitDimension.hpp"
 #include "openPMD/backend/BaseRecord.hpp"
+#include "openPMD/backend/ScientificDefaults.hpp"
 
 #include <iostream>
 
 namespace openPMD
 {
-Record::Record()
-{
-    setTimeOffset(0.f);
-}
+Record::Record() = default;
 
 Record &Record::setUnitDimension(unit_representations::AsMap const &udim)
 {
     if (!udim.empty())
     {
-        std::array<double, 7> tmpUnitDimension = this->unitDimension();
+        std::array<double, 7> tmpUnitDimension =
+            this->containsAttribute("unitDimension") ? this->unitDimension()
+                                                     : std::array<double, 7>{};
         for (auto const &entry : udim)
             tmpUnitDimension[static_cast<uint8_t>(entry.first)] = entry.second;
         setAttribute("unitDimension", tmpUnitDimension);
@@ -121,7 +121,7 @@ auto Record::read() -> internal::HomogenizeExtents
             /* using operator[] will incorrectly update parent */
             try
             {
-                T_RecordComponent::read(/* require_unit_si = */ true);
+                T_RecordComponent::read();
             }
             catch (error::ReadError const &err)
             {
@@ -149,7 +149,7 @@ auto Record::read() -> internal::HomogenizeExtents
             rc.get().m_isConstant = true;
             try
             {
-                rc.read(/* require_unit_si = */ true);
+                rc.read();
             }
             catch (error::ReadError const &err)
             {
@@ -178,7 +178,7 @@ auto Record::read() -> internal::HomogenizeExtents
             rc.setWritten(true, Attributable::EnqueueAsynchronously::No);
             try
             {
-                rc.read(/* require_unit_si = */ true);
+                rc.read();
             }
             catch (error::ReadError const &err)
             {
@@ -192,7 +192,7 @@ auto Record::read() -> internal::HomogenizeExtents
         }
     }
 
-    readBase();
+    internal::ScientificDefaults<Record>::readDefaults(IOHandler()->m_standard);
 
     readAttributes(ReadMode::FullyReread);
     return res;
diff --git a/src/RecordComponent.cpp b/src/RecordComponent.cpp
index c6eef23313..1b6029b807 100644
--- a/src/RecordComponent.cpp
+++ b/src/RecordComponent.cpp
@@ -22,18 +22,24 @@
 #include "openPMD/Dataset.hpp"
 #include "openPMD/DatatypeHelpers.hpp"
 #include "openPMD/Error.hpp"
+#include "openPMD/IO/AbstractIOHandler.hpp"
 #include "openPMD/IO/Format.hpp"
+#include "openPMD/LoadStoreChunk.hpp"
 #include "openPMD/Series.hpp"
 #include "openPMD/auxiliary/Environment.hpp"
 #include "openPMD/auxiliary/Memory.hpp"
 #include "openPMD/auxiliary/StringManip.hpp"
 #include "openPMD/backend/Attributable.hpp"
 #include "openPMD/backend/BaseRecord.hpp"
+#include "openPMD/backend/ScientificDefaults.hpp"
 #include "openPMD/backend/Variant_internal.hpp"
 
 // comment so clang-format does not move this
 #include "openPMD/DatatypeMacros.hpp"
 
+// comment
+#include "openPMD/DatatypeMacros.hpp"
+
 #include <algorithm>
 #include <climits>
 #include <complex>
@@ -46,7 +52,8 @@ namespace openPMD
 namespace internal
 {
     RecordComponentData::RecordComponentData() = default;
-    auto RecordComponentData::push_chunk(IOTask &&task) -> void
+    void RecordComponentData::push_chunk(
+        IOTask &&task, std::optional<bool> immediate_flush)
     {
         Attributable a;
         a.setData(std::shared_ptr<AttributableData>{this, [](auto const &) {}});
@@ -68,8 +75,29 @@ namespace internal
                 "Cannot write/read chunks to/from closed Iterations.");
         }
 #endif
+        bool immediate_flush_resolved = [&]() {
+            if (immediate_flush.has_value())
+            {
+                return *immediate_flush;
+            }
+            else
+            {
+                return a.IOHandler()->m_flush_immediately;
+            }
+        }();
         a.setDirtyRecursive(true);
-        m_chunks.push(std::move(task));
+        if (immediate_flush_resolved)
+        {
+            a.seriesFlush_impl<false>(
+                internal::FlushParams{FlushLevel::ImmediateFlush});
+            auto IOHandler = a.IOHandler();
+            IOHandler->enqueue(task);
+            IOHandler->flush(FlushLevel::UserFlush);
+        }
+        else
+        {
+            m_chunks.push(std::move(task));
+        }
     }
 
     static constexpr char const *note_on_deactivating_this_check = R"(
@@ -189,6 +217,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>());
@@ -395,10 +490,15 @@ void RecordComponent::flush(
     }
     if (access::readOnly(IOHandler()->m_frontendAccess))
     {
-        while (!rc.m_chunks.empty())
+        // sic! this needs to be a separate if term, otherwise flushes may
+        // wrongly jump into the write branch below
+        if (flush_level::global_flushpoint(flushParams.flushLevel))
         {
-            IOHandler()->enqueue(rc.m_chunks.front());
-            rc.m_chunks.pop();
+            while (!rc.m_chunks.empty())
+            {
+                IOHandler()->enqueue(rc.m_chunks.front());
+                rc.m_chunks.pop();
+            }
         }
     }
     else
@@ -425,10 +525,6 @@ void RecordComponent::flush(
                     "RecordComponent::resetDataset()).");
             }
         }
-        if (!containsAttribute("unitSI"))
-        {
-            setUnitSI(1);
-        }
         auto constant_component_write_shape = [&]() {
             auto extent = getExtent();
             return !Dataset::undefinedExtent(extent) &&
@@ -520,15 +616,14 @@ void RecordComponent::flush(
 
         flushAttributes(flushParams);
     }
-    if (flushParams.flushLevel != FlushLevel::SkeletonOnly)
-    {
-        setDirty(false);
-    }
+    determineUnsetDirty(flushParams.flushLevel);
 }
 
-void RecordComponent::read(bool require_unit_si)
+void RecordComponent::read()
 {
-    readBase(require_unit_si);
+    readBase();
+    internal::ScientificDefaults<RecordComponent>::readDefaults(
+        IOHandler()->m_standard);
 }
 
 namespace
@@ -553,7 +648,7 @@ namespace
     };
 } // namespace
 
-void RecordComponent::readBase(bool require_unit_si)
+void RecordComponent::readBase()
 {
     using DT = Datatype;
     auto &rc = get();
@@ -605,47 +700,26 @@ void RecordComponent::readBase(bool require_unit_si)
     {
         read_constant();
     }
-
-    if (require_unit_si)
-    {
-        if (!containsAttribute("unitSI"))
-        {
-            throw error::ReadError(
-                error::AffectedObject::Attribute,
-                error::Reason::NotFound,
-                {},
-                "Attribute unitSI required for record components, not found in "
-                "'" +
-                    myPath().openPMDPath() + "'.");
-        }
-        if (auto attr = getAttribute("unitSI");
-            !attr.getOptional<double>().has_value())
-        {
-            throw error::ReadError(
-                error::AffectedObject::Attribute,
-                error::Reason::UnexpectedContent,
-                {},
-                "Unexpected Attribute datatype for 'unitSI' (expected double, "
-                "found " +
-                    datatypeToString(attr.dtype) + ") in '" +
-                    myPath().openPMDPath() + "'.");
-        }
-    }
 }
 
-void RecordComponent::storeChunk(
-    auxiliary::WriteBuffer buffer, Datatype dtype, Offset o, Extent e)
+void RecordComponent::storeChunk_impl(
+    auxiliary::WriteBuffer buffer,
+    Datatype dtype,
+    internal::LoadStoreConfigWithBuffer cfg,
+    std::optional<bool> flush_immediately)
 {
+    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);
     auto &rc = get();
-    rc.push_chunk(IOTask(this, std::move(dWrite)));
+    rc.push_chunk(IOTask(this, std::move(dWrite)), flush_immediately);
 }
 
 void RecordComponent::verifyChunk(
@@ -764,40 +838,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
@@ -822,9 +878,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
@@ -849,24 +913,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)
     {
@@ -885,9 +933,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())
@@ -902,7 +947,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
@@ -928,80 +973,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>
@@ -1015,10 +1056,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>(                          \
@@ -1026,21 +1063,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/Series.cpp b/src/Series.cpp
index a826303193..6250d48229 100644
--- a/src/Series.cpp
+++ b/src/Series.cpp
@@ -25,6 +25,7 @@
 #include "openPMD/Error.hpp"
 #include "openPMD/IO/AbstractIOHandler.hpp"
 #include "openPMD/IO/AbstractIOHandlerHelper.hpp"
+#include "openPMD/IO/AbstractIOHandler_internal.hpp"
 #include "openPMD/IO/Access.hpp"
 #include "openPMD/IO/DummyIOHandler.hpp"
 #include "openPMD/IO/Format.hpp"
@@ -214,8 +215,6 @@ struct Series::ParsedInput
     std::string filenamePostfix;
     std::optional<std::string> filenameExtension;
     int filenamePadding = -1;
-    // optional fields
-    bool verify_homogeneous_extents = true;
 }; // ParsedInput
 
 std::string Series::openPMD() const
@@ -786,7 +785,8 @@ void Series::flush(std::string backendConfig)
         {FlushLevel::UserFlush, std::move(backendConfig)});
 }
 
-std::unique_ptr<Series::ParsedInput> Series::parseInput(std::string filepath)
+std::unique_ptr<Series::ParsedInput>
+Series::parseInput(std::string filepath) const
 {
     std::unique_ptr<Series::ParsedInput> input{new Series::ParsedInput};
 
@@ -936,104 +936,90 @@ void Series::init(
     // Either an MPI_Comm or none, the template works for both options
     MPI_Communicator &&...comm)
 {
-    auto emplace_parse_config_options_into_iohandler =
-        [](AbstractIOHandler &ioHandler, ParsedInput &input) {
-            ioHandler.m_verify_homogeneous_extents =
-                input.verify_homogeneous_extents;
-        };
-
-    auto init_directly = [this,
-                          &comm...,
-                          at,
-                          &filepath,
-                          &emplace_parse_config_options_into_iohandler](
+    auto init_directly = [this, &comm..., &filepath](
                              std::unique_ptr<ParsedInput> parsed_input,
-                             json::TracingJSON tracing_json) {
+                             json::TracingJSON tracing_json,
+                             internal::GlobalParameters global_parameters) {
         auto io_handler = createIOHandler(
-            std::nullopt,
-            parsed_input->path,
-            at,
+            internal::AbstractIOHandlerInitFrom(std::move(global_parameters)),
             parsed_input->format,
             parsed_input->filenameExtension.value_or(std::string()),
             comm...,
             tracing_json,
             filepath);
-        emplace_parse_config_options_into_iohandler(*io_handler, *parsed_input);
         initSeries(std::move(io_handler), std::move(parsed_input));
         json::warnGlobalUnusedOptions(tracing_json);
     };
 
-    auto init_deferred = [this,
-                          at,
-                          &filepath,
-                          &options,
-                          &emplace_parse_config_options_into_iohandler,
-                          &comm...](std::string const &parsed_directory) {
+    auto init_deferred = [this, &filepath, &options, &comm...](
+                             internal::GlobalParameters gp) {
         // Set a temporary IOHandler so that API calls which require a present
         // IOHandler don't fail
         writable().IOHandler =
             std::make_shared<std::optional<std::unique_ptr<AbstractIOHandler>>>(
-                std::make_unique<DummyIOHandler>(parsed_directory, at));
+                std::make_unique<DummyIOHandler>(std::move(gp)));
         auto &series = get();
         series.iterations.linkHierarchy(writable());
         series.m_rankTable.m_attributable.linkHierarchy(writable());
-        series.m_deferred_initialization =
-            [called_this_already = false,
-             filepath,
-             options,
-             at,
-             emplace_parse_config_options_into_iohandler,
-             comm...](Series &s) mutable {
-                if (called_this_already)
-                {
-                    throw std::runtime_error("Must be called one time only");
-                }
-                else
-                {
-                    called_this_already = true;
-                }
+        series.m_deferred_initialization = [called_this_already = false,
+                                            filepath,
+                                            options,
+                                            comm...](Series &s) mutable {
+            if (called_this_already)
+            {
+                throw std::runtime_error("Must be called one time only");
+            }
+            else
+            {
+                called_this_already = true;
+            }
 
-                auto [parsed_input, tracing_json] =
-                    s.initIOHandler<json::TracingJSON>(
-                        filepath,
-                        options,
-                        at,
-                        true,
-                        std::forward<MPI_Communicator>(comm)...);
-
-                auto &writable = s.get()->m_writable;
-
-                auto io_handler = createIOHandler(
-                    writable.IOHandler ? std::move(*writable.IOHandler)
-                                       : std::nullopt,
-                    parsed_input->path,
-                    at,
-                    parsed_input->format,
-                    parsed_input->filenameExtension.value_or(std::string()),
-                    comm...,
-                    tracing_json,
-                    filepath);
-                emplace_parse_config_options_into_iohandler(
-                    *io_handler, *parsed_input);
-                auto res = io_handler.get();
-                s.initSeries(std::move(io_handler), std::move(parsed_input));
-                json::warnGlobalUnusedOptions(tracing_json);
-                return res;
-            };
+            auto &writable = s.get()->m_writable;
+            if (!writable.IOHandler)
+            {
+                throw error::Internal(
+                    "Temporary IOHandler should be present at this point.");
+            }
+            auto [parsed_input, tracing_json] =
+                s.prepareIOHandlerArguments<json::TracingJSON>(
+                    ***writable.IOHandler,
+                    filepath,
+                    options,
+                    true,
+                    std::forward<MPI_Communicator>(comm)...);
+
+            auto io_handler = createIOHandler(
+                internal::AbstractIOHandlerInitFrom(
+                    (**writable.IOHandler).get()),
+                parsed_input->format,
+                parsed_input->filenameExtension.value_or(std::string()),
+                comm...,
+                tracing_json,
+                filepath);
+            auto res = io_handler.get();
+            s.initSeries(std::move(io_handler), std::move(parsed_input));
+            json::warnGlobalUnusedOptions(tracing_json);
+            return res;
+        };
     };
 
+    internal::GlobalParameters global_parameters{at};
     switch (at)
     {
     case Access::CREATE_RANDOM_ACCESS:
     case Access::READ_WRITE:
     case Access::READ_ONLY: {
-        auto [parsed_input, tracing_json] = initIOHandler<json::TracingJSON>(
-            filepath,
-            options,
-            at,
-            true,
-            std::forward<MPI_Communicator>(comm)...);
-        init_directly(std::move(parsed_input), std::move(tracing_json));
+        auto [parsed_input, tracing_json] =
+            prepareIOHandlerArguments<json::TracingJSON>(
+                global_parameters,
+                filepath,
+                options,
+                true,
+                std::forward<MPI_Communicator>(comm)...);
+        init_directly(
+            std::move(parsed_input),
+            std::move(tracing_json),
+            std::move(global_parameters));
     }
     break;
     case Access::CREATE_LINEAR:
@@ -1041,16 +1027,18 @@ void Series::init(
     case Access::APPEND_RANDOM_ACCESS:
     case Access::APPEND_LINEAR: {
         auto [first_parsed_input, first_tracing_json] =
-            initIOHandler<json::TracingJSON>(
+            prepareIOHandlerArguments<json::TracingJSON>(
+                global_parameters,
                 filepath,
                 options,
-                at,
                 false,
                 std::forward<MPI_Communicator>(comm)...);
         if (first_parsed_input->filenameExtension.has_value())
         {
             init_directly(
-                std::move(first_parsed_input), std::move(first_tracing_json));
+                std::move(first_parsed_input),
+                std::move(first_tracing_json),
+                std::move(global_parameters));
         }
         else
         {
@@ -1060,7 +1048,7 @@ void Series::init(
              * -> Defer the proper initialization of the IO handler up to the
              * point when we actually need it.
              */
-            init_deferred(first_parsed_input->path);
+            init_deferred(std::move(global_parameters));
         }
     }
     break;
@@ -1068,21 +1056,25 @@ void Series::init(
 }
 
 template <typename TracingJSON, typename... MPI_Communicator>
-auto Series::initIOHandler(
+auto Series::prepareIOHandlerArguments(
+    internal::GlobalParameters &gp,
     std::string const &filepath,
     std::string const &options,
-    Access at,
     bool resolve_generic_extension,
     MPI_Communicator &&...comm)
     -> std::tuple<std::unique_ptr<ParsedInput>, TracingJSON>
 {
     auto &series = get();
+    auto at = gp.m_frontendAccess;
 
+    // This resolves the JSON config from string/file, but does not evaluate it
+    // yet
     json::TracingJSON optionsJson = json::parseOptions(
         options,
         std::forward<MPI_Communicator>(comm)...,
         /* considerFiles = */ true);
     auto input = parseInput(filepath);
+    gp.directory = input->path;
     if (resolve_generic_extension && input->format == Format::GENERIC &&
         !access::create(at))
     {
@@ -1148,7 +1140,8 @@ auto Series::initIOHandler(
     series.m_parseLazily = at == Access::READ_LINEAR;
 
     // now check for user-specified options
-    parseJsonOptions(optionsJson, *input);
+    // this actually parses the JSON contents resolved previously
+    parseJsonOptions(optionsJson, *input, gp);
 
     if (resolve_generic_extension && !input->filenameExtension.has_value())
     {
@@ -3152,7 +3145,8 @@ namespace
 } // namespace
 
 template <typename TracingJSON>
-void Series::parseJsonOptions(TracingJSON &options, ParsedInput &input)
+void Series::parseJsonOptions(
+    TracingJSON &options, ParsedInput &input, internal::GlobalParameters &gp)
 {
     auto &series = get();
     getJsonOption<bool>(
@@ -3168,8 +3162,13 @@ void Series::parseJsonOptions(TracingJSON &options, ParsedInput &input)
     getJsonOption<bool>(
         options,
         "verify_homogeneous_extents",
-        input.verify_homogeneous_extents,
+        gp.m_verify_homogeneous_extents,
         "OPENPMD_VERIFY_HOMOGENEOUS_EXTENTS");
+    getJsonOption<bool>(
+        options,
+        "flush_immediately",
+        gp.m_flush_immediately,
+        "OPENPMD_FLUSH_IMMEDIATELY");
     internal::SeriesData::SourceSpecifiedViaJSON rankTableSource;
     if (getJsonOptionLowerCase(options, "rank_table", rankTableSource.value))
     {
@@ -3303,6 +3302,14 @@ namespace internal
             !(access::readOnly(IOHandler->m_frontendAccess) &&
               !(*this)->m_writable.written))
         {
+            for (auto &[_, iteration] : iterations)
+            {
+                (void)_;
+                if (!iteration.closed())
+                {
+                    iteration.close(/* flush = */ false);
+                }
+            }
             impl.flush();
             /*
              * In file-based iteration encoding, this must be triggered by
@@ -3542,6 +3549,16 @@ void Series::close()
     m_attri.reset();
 }
 
+bool Series::flushImmediately() const
+{
+    auto ioHandler = IOHandler();
+    if (!ioHandler)
+    {
+        return false;
+    }
+    return ioHandler->m_flush_immediately;
+}
+
 auto Series::currentSnapshot() -> std::optional<std::vector<IterationIndex_t>>
 {
     using vec_t = std::vector<IterationIndex_t>;
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/src/backend/Attributable.cpp b/src/backend/Attributable.cpp
index ce1c2936cb..cb4a4a15bb 100644
--- a/src/backend/Attributable.cpp
+++ b/src/backend/Attributable.cpp
@@ -72,6 +72,36 @@ Attributable::Attributable()
 Attributable::Attributable(NoInit) noexcept
 {}
 
+bool Attributable::setAttribute(std::string const &key, Attribute attribute)
+{
+    auto &attri = get();
+    if (IOHandler() &&
+        IOHandler()->m_seriesStatus == internal::SeriesStatus::Default &&
+        Access::READ_ONLY == IOHandler()->m_frontendAccess)
+    {
+        auxiliary::OutOfRangeMsg const out_of_range_msg(
+            "Attribute", "can not be set (read-only).");
+        error::throwNoSuchAttribute(out_of_range_msg(key));
+    }
+
+    setDirty(true);
+    auto it = attri.m_attributes.lower_bound(key);
+    if (it != attri.m_attributes.end() &&
+        !attri.m_attributes.key_comp()(key, it->first))
+    {
+        // key already exists in map, just replace the value
+        it->second = std::move(attribute);
+        return true;
+    }
+    else
+    {
+        // emplace a new map element for an unknown key
+        attri.m_attributes.emplace_hint(
+            it, std::make_pair(key, std::move(attribute)));
+        return false;
+    }
+}
+
 Attribute Attributable::getAttribute(std::string const &key) const
 {
     auto &attri = get();
@@ -282,15 +312,9 @@ Attributable::seriesFlush_impl<false>(internal::FlushParams const &flushParams);
 
 void Attributable::flushAttributes(internal::FlushParams const &flushParams)
 {
-    switch (flushParams.flushLevel)
+    if (!flush_level::write_attributes(flushParams.flushLevel))
     {
-    case FlushLevel::SkeletonOnly:
-    case FlushLevel::CreateOrOpenFiles:
         return;
-    case FlushLevel::InternalFlush:
-    case FlushLevel::UserFlush:
-        // pass
-        break;
     }
     if (dirty())
     {
@@ -304,10 +328,7 @@ void Attributable::flushAttributes(internal::FlushParams const &flushParams)
         }
     }
     // Do this outside the if branch to also setDirty to dirtyRecursive
-    if (flushParams.flushLevel != FlushLevel::SkeletonOnly)
-    {
-        setDirty(false);
-    }
+    determineUnsetDirty(flushParams.flushLevel);
 }
 
 void Attributable::readAttributes(ReadMode mode)
diff --git a/src/backend/Attribute.cpp b/src/backend/Attribute.cpp
index 1106ed6301..7dfc8a37b9 100644
--- a/src/backend/Attribute.cpp
+++ b/src/backend/Attribute.cpp
@@ -52,6 +52,10 @@ constexpr auto eligible_conversions() -> std::array<bool, num_datatypes>
     {
         return eligible_conversions<typename TargetType::value_type>();
     }
+    else if constexpr (std::is_same_v<std::string, TargetType>)
+    {
+        return eligible_conversions<char>();
+    }
     else
     {
         std::array<bool, num_datatypes> res = {};
@@ -63,12 +67,15 @@ constexpr auto eligible_conversions() -> std::array<bool, num_datatypes>
     res[datatypeIndex<type>()] = res[datatypeIndex<type::value_type>()];
         OPENPMD_FOREACH_VECTOR_DATATYPE(OPENPMD_ENUMERATE_TYPES)
 #undef OPENPMD_ENUMERATE_TYPES
+        res[datatypeIndex<std::string>()] = res[datatypeIndex<char>()];
+        res[datatypeIndex<std::vector<std::string>>()] =
+            res[datatypeIndex<char>()];
         return res;
     }
 }
 
 template <typename U>
-auto Attribute::get_impl() const -> std::variant<U, std::runtime_error>
+auto Attribute::getOrError() const -> std::variant<U, std::runtime_error>
 {
     constexpr std::array<bool, num_datatypes> conversions =
         eligible_conversions<U>();
@@ -104,7 +111,7 @@ auto Attribute::get_impl() const -> std::variant<U, std::runtime_error>
 template <typename U>
 U Attribute::get() const
 {
-    auto res = get_impl<U>();
+    auto res = getOrError<U>();
 
     return std::visit(
         [](auto &&containedValue) -> U {
@@ -124,7 +131,7 @@ U Attribute::get() const
 template <typename U>
 std::optional<U> Attribute::getOptional() const
 {
-    auto res = get_impl<U>();
+    auto res = getOrError<U>();
 
     return std::visit(
         [](auto &&containedValue) -> std::optional<U> {
@@ -141,6 +148,107 @@ std::optional<U> Attribute::getOptional() const
         std::move(res));
 }
 
+template <typename is_type>
+std::variant<Attribute, std::runtime_error>
+requireVector_impl(Attribute const &attr, attribute_types const &variant)
+{
+    using res_t = std::variant<Attribute, std::runtime_error>;
+    if constexpr (auxiliary::IsVector_v<is_type>)
+    {
+        return attr;
+    }
+    else if constexpr (auxiliary::IsArray_v<is_type>)
+    {
+        using target_type = auxiliary::VectorType_t<is_type>;
+        auto maybe_res = detail::doConvert<is_type, target_type>(
+            &std::get<is_type>(variant));
+        return std::visit(
+            auxiliary::overloaded{
+                [](target_type val) -> res_t {
+                    return Attribute(std::move(val));
+                },
+                [](std::runtime_error err) -> res_t { return err; }},
+            maybe_res);
+    }
+    else if constexpr (std::is_same_v<is_type, bool>)
+    {
+        return std::runtime_error("Cannot cast bool to a vector is_type.");
+    }
+    else
+    {
+        return Attribute(std::vector<is_type>{std::get<is_type>(variant)});
+    }
+}
+
+std::variant<Attribute, std::runtime_error> Attribute::requireVector() const
+{
+    auto variant = Variant::getVariant<attribute_types>();
+    size_t index = variant.index();
+
+#define OPENPMD_ENUMERATE_TYPES(type)                                          \
+    case datatypeIndex<type>(): {                                              \
+        return requireVector_impl<type>(*this, variant);                       \
+        break;                                                                 \
+    }
+
+    switch (index)
+    {
+        OPENPMD_FOREACH_DATATYPE(OPENPMD_ENUMERATE_TYPES)
+    default:
+        return {std::runtime_error("Unreachable!")};
+    }
+#undef OPENPMD_ENUMERATE_TYPES
+
+    return {std::runtime_error("Unreachable!")};
+}
+
+template <typename is_type>
+std::variant<Attribute, std::runtime_error>
+requireScalar_impl(Attribute const &attr, attribute_types const &variant)
+{
+    using res_t = std::variant<Attribute, std::runtime_error>;
+    if constexpr (
+        auxiliary::IsVector_v<is_type> || auxiliary::IsArray_v<is_type>)
+    {
+        using target_type = auxiliary::ScalarType_t<is_type>;
+        auto maybe_res = detail::doConvert<is_type, target_type>(
+            &std::get<is_type>(variant));
+        return std::visit(
+            auxiliary::overloaded{
+                [](target_type val) -> res_t {
+                    return Attribute(std::move(val));
+                },
+                [](std::runtime_error err) -> res_t { return err; }},
+            maybe_res);
+    }
+    else
+    {
+        return attr;
+    }
+}
+
+std::variant<Attribute, std::runtime_error> Attribute::requireScalar() const
+{
+    auto variant = Variant::getVariant<attribute_types>();
+    size_t index = variant.index();
+
+#define OPENPMD_ENUMERATE_TYPES(type)                                          \
+    case datatypeIndex<type>(): {                                              \
+        return requireScalar_impl<type>(*this, variant);                       \
+        break;                                                                 \
+    }
+
+    switch (index)
+    {
+        OPENPMD_FOREACH_DATATYPE(OPENPMD_ENUMERATE_TYPES)
+    default:
+        return {std::runtime_error("Unreachable!")};
+    }
+#undef OPENPMD_ENUMERATE_TYPES
+
+    return {std::runtime_error("Unreachable!")};
+}
+
 #define OPENPMD_INSTANTIATE(type)                                              \
     template type Attribute::get() const;                                      \
     template std::optional<type> Attribute::getOptional() const;
diff --git a/src/backend/BaseRecord.cpp b/src/backend/BaseRecord.cpp
index 9c2161be0a..2594888032 100644
--- a/src/backend/BaseRecord.cpp
+++ b/src/backend/BaseRecord.cpp
@@ -34,14 +34,7 @@ namespace openPMD
 namespace internal
 {
     template <typename T_elem, typename T_RecordComponentData>
-    BaseRecordData<T_elem, T_RecordComponentData>::BaseRecordData()
-    {
-        Attributable impl;
-        impl.setData({this, [](auto const *) {}});
-        impl.setAttribute(
-            "unitDimension",
-            std::array<double, 7>{{0., 0., 0., 0., 0., 0., 0.}});
-    }
+    BaseRecordData<T_elem, T_RecordComponentData>::BaseRecordData() = default;
 
 #define OPENPMD_INSTANTIATE(recordcomponenttype)                               \
     template class BaseRecordData<                                             \
@@ -772,44 +765,6 @@ inline bool BaseRecord<T_elem>::scalar() const
     return this->datasetDefined();
 }
 
-template <typename T_elem>
-inline void BaseRecord<T_elem>::readBase()
-{
-    using DT = Datatype;
-    Parameter<Operation::READ_ATT> aRead;
-
-    aRead.name = "unitDimension";
-    this->IOHandler()->enqueue(IOTask(this, aRead));
-    this->IOHandler()->flush(internal::defaultFlushParams);
-    if (auto val = Attribute(Attribute::from_any, *aRead.m_resource)
-                       .getOptional<std::array<double, 7>>();
-        val.has_value())
-        this->setAttribute("unitDimension", val.value());
-    else
-        throw std::runtime_error(
-            "Unexpected Attribute datatype for 'unitDimension'");
-
-    aRead.name = "timeOffset";
-    this->IOHandler()->enqueue(IOTask(this, aRead));
-    this->IOHandler()->flush(internal::defaultFlushParams);
-    if (*aRead.dtype == DT::FLOAT)
-        this->setAttribute(
-            "timeOffset",
-            Attribute(Attribute::from_any, *aRead.m_resource).get<float>());
-    else if (*aRead.dtype == DT::DOUBLE)
-        this->setAttribute(
-            "timeOffset",
-            Attribute(Attribute::from_any, *aRead.m_resource).get<double>());
-    // conversion cast if a backend reports an integer type
-    else if (auto val = Attribute(Attribute::from_any, *aRead.m_resource)
-                            .getOptional<double>();
-             val.has_value())
-        this->setAttribute("timeOffset", val.value());
-    else
-        throw std::runtime_error(
-            "Unexpected Attribute datatype for 'timeOffset'");
-}
-
 template <typename T_elem>
 inline void BaseRecord<T_elem>::flush(
     std::string const &name, internal::FlushParams const &flushParams)
@@ -820,10 +775,10 @@ inline void BaseRecord<T_elem>::flush(
     }
 
     if (!this->written() && this->empty() && !this->datasetDefined())
-        throw std::runtime_error(
-            "A Record can not be written without any contained "
-            "RecordComponents: " +
-            name);
+        // Verify upon ScientificDefaults::finalize() that the Record has been
+        // populized. For now, we will assume that data will come later; ignore
+        // this Record at the moment.
+        return;
 
     /*
      * Defensive programming. Normally, this error should yield as soon as
@@ -837,10 +792,7 @@ inline void BaseRecord<T_elem>::flush(
     }
 
     this->flush_impl(name, flushParams);
-    if (flushParams.flushLevel != FlushLevel::SkeletonOnly)
-    {
-        this->setDirty(false);
-    }
+    this->determineUnsetDirty(flushParams.flushLevel);
     // flush_impl must take care to correctly set the dirty() flag so this
     // method doesn't do it
 }
diff --git a/src/backend/MeshRecordComponent.cpp b/src/backend/MeshRecordComponent.cpp
index 8298a8abbd..788ac1738c 100644
--- a/src/backend/MeshRecordComponent.cpp
+++ b/src/backend/MeshRecordComponent.cpp
@@ -20,6 +20,7 @@
  */
 #include "openPMD/backend/MeshRecordComponent.hpp"
 #include "openPMD/backend/BaseRecord.hpp"
+#include "openPMD/backend/ScientificDefaults.hpp"
 
 namespace openPMD
 {
@@ -38,35 +39,10 @@ MeshRecordComponent::MeshRecordComponent(
 
 void MeshRecordComponent::read()
 {
-    using DT = Datatype;
-    Parameter<Operation::READ_ATT> aRead;
+    internal::ScientificDefaults<MeshRecordComponent>::readDefaults(
+        IOHandler()->m_standard);
 
-    aRead.name = "position";
-    IOHandler()->enqueue(IOTask(this, aRead));
-    IOHandler()->flush(internal::defaultFlushParams);
-    Attribute a = Attribute(Attribute::from_any, *aRead.m_resource);
-    if (*aRead.dtype == DT::VEC_FLOAT || *aRead.dtype == DT::FLOAT)
-        setPosition(a.get<std::vector<float> >());
-    else if (*aRead.dtype == DT::VEC_DOUBLE || *aRead.dtype == DT::DOUBLE)
-        setPosition(a.get<std::vector<double> >());
-    else if (
-        *aRead.dtype == DT::VEC_LONG_DOUBLE || *aRead.dtype == DT::LONG_DOUBLE)
-        setPosition(a.get<std::vector<long double> >());
-    // conversion cast if a backend reports an integer type
-    else if (auto val = a.getOptional<std::vector<double> >(); val.has_value())
-        setPosition(val.value());
-    else
-        throw error::ReadError(
-            error::AffectedObject::Attribute,
-            error::Reason::UnexpectedContent,
-            {},
-            "Unexpected Attribute datatype for 'position' (expected a vector "
-            "of any floating point type, found " +
-                datatypeToString(
-                    Attribute(Attribute::from_any, *aRead.m_resource).dtype) +
-                ")");
-
-    readBase(/* require_unit_si = */ true);
+    readBase();
 }
 
 void MeshRecordComponent::flush(
@@ -76,11 +52,6 @@ void MeshRecordComponent::flush(
     {
         return;
     }
-    if (access::write(IOHandler()->m_frontendAccess) &&
-        !containsAttribute("position"))
-    {
-        setPosition(std::vector<double>{0});
-    }
     RecordComponent::flush(name, params);
 }
 
diff --git a/src/backend/PatchRecord.cpp b/src/backend/PatchRecord.cpp
index 3080523d24..8d3b5f381b 100644
--- a/src/backend/PatchRecord.cpp
+++ b/src/backend/PatchRecord.cpp
@@ -20,23 +20,32 @@
  */
 #include "openPMD/backend/PatchRecord.hpp"
 #include "openPMD/auxiliary/Memory.hpp"
+#include "openPMD/backend/ScientificDefaults.hpp"
 
 #include <iostream>
 
 namespace openPMD
 {
 PatchRecord &
-PatchRecord::setUnitDimension(std::map<UnitDimension, double> const &udim)
+PatchRecord::setUnitDimension(unit_representations::AsMap const &udim)
 {
     if (!udim.empty())
     {
-        std::array<double, 7> tmpUnitDimension = this->unitDimension();
+        std::array<double, 7> tmpUnitDimension =
+            this->containsAttribute("unitDimension") ? this->unitDimension()
+                                                     : std::array<double, 7>{};
         for (auto const &entry : udim)
             tmpUnitDimension[static_cast<uint8_t>(entry.first)] = entry.second;
         setAttribute("unitDimension", tmpUnitDimension);
     }
     return *this;
 }
+PatchRecord &
+PatchRecord::setUnitDimension(unit_representations::AsArray const &udim)
+{
+    setAttribute("unitDimension", udim);
+    return *this;
+}
 
 void PatchRecord::flush_impl(
     std::string const &path, internal::FlushParams const &flushParams)
@@ -56,33 +65,13 @@ void PatchRecord::flush_impl(
     }
     else
         T_RecordComponent::flush(path, flushParams);
-    if (flushParams.flushLevel != FlushLevel::SkeletonOnly)
-    {
-        setDirty(false);
-    }
+    determineUnsetDirty(flushParams.flushLevel);
 }
 
 void PatchRecord::read()
 {
-    Parameter<Operation::READ_ATT> aRead;
-    aRead.name = "unitDimension";
-    IOHandler()->enqueue(IOTask(this, aRead));
-    IOHandler()->flush(internal::defaultFlushParams);
-
-    if (auto val = Attribute(Attribute::from_any, *aRead.m_resource)
-                       .getOptional<std::array<double, 7> >();
-        val.has_value())
-        this->setAttribute("unitDimension", val.value());
-    else
-        throw error::ReadError(
-            error::AffectedObject::Attribute,
-            error::Reason::UnexpectedContent,
-            {},
-            "Unexpected Attribute datatype for 'unitDimension' (expected an "
-            "array of seven floating point numbers, found " +
-                datatypeToString(
-                    Attribute(Attribute::from_any, *aRead.m_resource).dtype) +
-                ")");
+    internal::ScientificDefaults<PatchRecord>::readDefaults(
+        IOHandler()->m_standard);
 
     Parameter<Operation::LIST_DATASETS> dList;
     IOHandler()->enqueue(IOTask(this, dList));
@@ -101,7 +90,7 @@ void PatchRecord::read()
         prc.setWritten(true, Attributable::EnqueueAsynchronously::No);
         try
         {
-            prc.read(/* require_unit_si = */ false);
+            prc.read();
         }
         catch (error::ReadError const &err)
         {
diff --git a/src/backend/PatchRecordComponent.cpp b/src/backend/PatchRecordComponent.cpp
index 03c873111d..5bb32ae98d 100644
--- a/src/backend/PatchRecordComponent.cpp
+++ b/src/backend/PatchRecordComponent.cpp
@@ -22,6 +22,7 @@
 #include "openPMD/RecordComponent.hpp"
 #include "openPMD/auxiliary/Memory.hpp"
 #include "openPMD/backend/BaseRecord.hpp"
+#include "openPMD/backend/ScientificDefaults.hpp"
 
 #include <algorithm>
 
@@ -59,10 +60,16 @@ PatchRecordComponent::PatchRecordComponent(
     static_cast<RecordComponent &>(*this).operator=(baseRecord);
 }
 
+void PatchRecordComponent::read()
+{
+    readBase();
+    internal::ScientificDefaults<PatchRecordComponent>::readDefaults(
+        IOHandler()->m_standard);
+}
+
 PatchRecordComponent::PatchRecordComponent() : RecordComponent(NoInit())
 {
     setData(std::make_shared<Data_t>());
-    setUnitSI(1);
 }
 
 PatchRecordComponent::PatchRecordComponent(NoInit) : RecordComponent(NoInit())
diff --git a/src/backend/ScientificDefaults.cpp b/src/backend/ScientificDefaults.cpp
new file mode 100644
index 0000000000..ccf8706cdb
--- /dev/null
+++ b/src/backend/ScientificDefaults.cpp
@@ -0,0 +1,829 @@
+#include "openPMD/backend/ScientificDefaults.hpp"
+#include "openPMD/Datatype.hpp"
+#include "openPMD/IO/AbstractIOHandler.hpp"
+#include "openPMD/ThrowError.hpp"
+#include "openPMD/auxiliary/Variant.hpp"
+#include "openPMD/backend/Attribute.hpp"
+#include "openPMD/backend/ScientificDefaults_internal.hpp"
+
+#include "openPMD/Datatype.hpp"
+#include "openPMD/Error.hpp"
+#include "openPMD/IO/AbstractIOHandler.hpp"
+#include "openPMD/Iteration.hpp"
+#include "openPMD/Mesh.hpp"
+#include "openPMD/ParticleSpecies.hpp"
+#include "openPMD/Record.hpp"
+#include "openPMD/UnitDimension.hpp"
+#include "openPMD/auxiliary/StringManip.hpp"
+#include "openPMD/auxiliary/TypeTraits.hpp"
+#include "openPMD/backend/BaseRecord.hpp"
+#include "openPMD/backend/Container.hpp"
+#include "openPMD/backend/MeshRecordComponent.hpp"
+#include "openPMD/backend/PatchRecord.hpp"
+#include "openPMD/backend/PatchRecordComponent.hpp"
+#include "openPMD/backend/Variant_internal.hpp"
+#include "openPMD/backend/Writable.hpp"
+#include <functional>
+
+#include <iostream>
+#include <optional>
+#include <stdexcept>
+#include <type_traits>
+#include <utility>
+
+namespace openPMD::internal
+{
+// 1. Helper functions in anonymous namespace (from header)
+namespace
+{
+    template <typename T>
+    auto write_val_to_stderr(T const &val) -> std::ostream &
+    {
+        if constexpr (auxiliary::IsVector_v<T> || auxiliary::IsArray_v<T>)
+        {
+            auxiliary::write_vec_to_stream(std::cerr, val);
+        }
+        else if constexpr (std::is_same_v<T, unit_representations::AsMap>)
+        {
+            std::cerr << "Unit_Map";
+        }
+        else
+        {
+            std::cerr << val;
+        }
+        return std::cerr;
+    }
+    auto write_to_stderr(Attribute const &a) -> std::ostream &
+    {
+        std::visit(
+            [](auto const &val) { write_val_to_stderr(val); },
+            a.getVariant<attribute_types>());
+        return std::cerr;
+    }
+
+    // Helper function to set geometry based on string value
+    auto setMeshGeometryFromString(Mesh &mesh, std::string val)
+        -> std::optional<error::ReadError>
+    {
+        if ("cartesian" == val)
+            mesh.setGeometry(Mesh::Geometry::cartesian);
+        else if ("thetaMode" == val)
+            mesh.setGeometry(Mesh::Geometry::thetaMode);
+        else if ("cylindrical" == val)
+            mesh.setGeometry(Mesh::Geometry::cylindrical);
+        else if ("spherical" == val)
+            mesh.setGeometry(Mesh::Geometry::spherical);
+        else
+            mesh.setGeometry(std::move(val));
+        return std::nullopt;
+    }
+
+    // Helper function to set data order based on char value
+    auto setMeshDataOrderFromChar(Mesh &mesh, char val)
+        -> std::optional<error::ReadError>
+    {
+        if (val == 'C' || val == 'F')
+        {
+            mesh.setDataOrder(static_cast<Mesh::DataOrder>(val));
+            return std::nullopt;
+        }
+        else
+        {
+            return error::ReadError(
+                error::AffectedObject::Attribute,
+                error::Reason::UnexpectedContent,
+                std::nullopt,
+                "Data order must be either C or F.");
+        }
+    }
+
+    // Helper function to create default axis labels based on dimensionality
+    auto createDefaultAxisLabels(uint64_t dimensionality)
+        -> std::vector<std::string>
+    {
+        switch (dimensionality)
+        {
+        case 0:
+        case 1:
+            return {"x"};
+        case 2:
+            return {"x", "y"};
+        case 3:
+            return {"x", "y", "z"};
+        default:
+            if (dimensionality < 100)
+            {
+                // x1, x2, x3, x4, ...
+                std::vector<std::string> res;
+                res.reserve(dimensionality);
+                for (uint64_t i = 0; i < dimensionality; ++i)
+                {
+                    res.emplace_back("x" + std::to_string(i));
+                }
+                return res;
+            }
+            else
+            {
+                std::string msg =
+                    "Please verify dimensionality. Was inferred as '";
+                msg += std::to_string(dimensionality);
+                msg += "'. Seems a bit much.";
+                return {std::move(msg)};
+            }
+        }
+        return std::vector<std::string>{"x", "y", "z"};
+    }
+
+    // Helper function to create default vector based on dimensionality
+    auto createDefaultVector(uint64_t dimensionality, double defaultValue)
+        -> std::vector<double>
+    {
+        if (dimensionality < 100)
+        {
+            return std::vector<double>(dimensionality, defaultValue);
+        }
+        else
+        {
+            return std::vector<double>{defaultValue};
+        }
+    }
+} // namespace
+
+// 2. Template implementations from header
+// Template implementations from header
+template <typename T, typename RecordType>
+PostProcessConvertedAttributeImpl<T, RecordType>::
+    PostProcessConvertedAttributeImpl(RecordType record_in, handler_t reader_in)
+    : record(std::move(record_in)), reader(reader_in)
+{}
+
+template <typename T, typename RecordType>
+auto PostProcessConvertedAttributeImpl<T, RecordType>::operator()(T val)
+    -> std::optional<error::ReadError>
+{
+    return (*reader)(record, std::move(val));
+}
+
+template <typename T, typename RecordType>
+auto makePostProcessConvertedAttribute(
+    RecordType &&record,
+    std::optional<error::ReadError> (*handler)(
+        std::remove_reference_t<RecordType> &, T))
+    -> std::shared_ptr<PostProcessConvertedAttribute<T>>
+{
+    return std::make_shared<PostProcessConvertedAttributeImpl<
+        T,
+        std::remove_reference_t<RecordType>>>(
+        std::forward<RecordType>(record), handler);
+}
+
+template <typename T>
+template <typename RecordType>
+RequireType<T>::RequireType(
+    RecordType &&record,
+    std::optional<error::ReadError> (*handler)(
+        std::remove_reference_t<RecordType> &, T))
+    : postProcess(makePostProcessConvertedAttribute(
+          std::forward<RecordType>(record), handler))
+{}
+
+// 3. AttributeReader class implementations
+AttributeReader::AttributeReader(
+    std::deque<Datatype> eligibleDatatypes_in,
+    std::optional<std::shared_ptr<ProcessAttribute>> processAttribute_in)
+    : eligibleDatatypes(std::move(eligibleDatatypes_in))
+    , processAttribute(std::move(processAttribute_in))
+{}
+
+auto AttributeReader::operator()(
+    Attributable &record,
+    char const *attrName,
+    Attribute const &a,
+    std::deque<Datatype> unmatched_so_far) -> AttributeReadResult
+{
+    if (std::find(
+            eligibleDatatypes.begin(), eligibleDatatypes.end(), a.dtype) ==
+        eligibleDatatypes.end())
+    {
+        auto res =
+            attribute_read_result::TypeUnmatched{std::move(unmatched_so_far)};
+        for (auto dt : this->eligibleDatatypes)
+        {
+            res.expectedDatatypes.push_back(dt);
+        }
+        return res;
+    }
+    if (processAttribute.has_value())
+    {
+        auto maybe_error = (**processAttribute)(record, attrName, a);
+        if (maybe_error.has_value())
+        {
+            return *maybe_error;
+        }
+    }
+    return attribute_read_result::Success{};
+}
+
+namespace
+{
+    // Need SFINAE for this since MSVC doesnt understand if constexpr
+    template <typename GetDefaultValue, typename SFINAE = void>
+    struct CallGetDefaultValue
+    {
+        GetDefaultValue val;
+        CallGetDefaultValue(GetDefaultValue val_in) : val(std::move(val_in))
+        {}
+        auto operator()() && -> GetDefaultValue
+        {
+            return std::move(val);
+        }
+    };
+
+    template <typename GetDefaultValue>
+    struct CallGetDefaultValue<
+        GetDefaultValue,
+        std::void_t<std::invoke_result_t<GetDefaultValue>>>
+    {
+        GetDefaultValue val;
+        CallGetDefaultValue(GetDefaultValue val_in) : val(std::move(val_in))
+        {}
+        auto operator()() && -> std::invoke_result_t<GetDefaultValue>
+        {
+            return std::move(val)();
+        }
+    };
+} // namespace
+
+// 4. ConfigAttribute class implementations
+ConfigAttribute::ConfigAttribute(
+    Attributable &child_in, char const *attrName_in)
+    : child(child_in), attrName(attrName_in)
+{}
+
+template <typename RecordType, typename S, typename GetDefaultValue>
+auto ConfigAttribute::withSetter(
+    GetDefaultValue &&getDefaultVal,
+    set_default_val_t<
+        RecordType,
+        std::conditional_t<
+            std::is_void_v<S>,
+            detail::CallResult_t<GetDefaultValue>,
+            S>> setDefaultVal) -> ConfigAttribute &
+{
+    initDefaultAttribute =
+        [callDefaultValue =
+             CallGetDefaultValue<std::remove_reference_t<GetDefaultValue>>(
+                 std::forward<GetDefaultValue>(getDefaultVal)),
+         setDefaultVal](Attributable &attr) mutable {
+            RecordType *record = dynamic_cast<RecordType *>(&attr);
+            if (!record)
+            {
+                throw error::Internal("dynamic cast failure");
+            }
+            ((*record).*setDefaultVal)(std::move(callDefaultValue)());
+        };
+    return *this;
+}
+
+template <typename DefaultValue>
+auto ConfigAttribute::withGenericSetter(DefaultValue &&defaultVal)
+    -> ConfigAttribute &
+{
+    initDefaultAttribute =
+        [this, defaultVal_lambda = std::forward<DefaultValue &&>(defaultVal)](
+            Attributable &attr) {
+            attr.setAttribute(this->attrName, std::move(defaultVal_lambda));
+        };
+    return *this;
+}
+
+auto ConfigAttribute::withReader(
+    std::deque<Datatype> eligibleDatatypes,
+    std::optional<std::shared_ptr<ProcessAttribute>> processAttribute)
+    -> ConfigAttribute &
+{
+    this->attributeReaders.emplace_back(
+        std::move(eligibleDatatypes), std::move(processAttribute));
+    return *this;
+}
+
+void ConfigAttribute::write()
+{
+    if (this->child.containsAttribute(this->attrName) ||
+        !this->initDefaultAttribute.has_value())
+    {
+        return;
+    }
+    this->initDefaultAttribute.operator*()(this->child);
+}
+
+void ConfigAttribute::read()
+{
+    if (attributeReaders.empty())
+    {
+        // No readers emplaced for this attribute
+        return;
+    }
+    AttributeReadResult res = attribute_read_result::TypeUnmatched{};
+    Parameter<Operation::READ_ATT> aRead;
+    aRead.name = this->attrName;
+    auto IOHandler = this->child.IOHandler();
+    IOHandler->enqueue(IOTask(&this->child, aRead));
+    try
+    {
+        IOHandler->flush(defaultFlushParams);
+    }
+    catch (error::ReadError const &e)
+    {
+        std::cerr << "Could not read expected attribute '" << this->attrName
+                  << "' in '" << this->child.myPath().openPMDPath() << ".";
+        if (this->initDefaultAttribute.has_value())
+        {
+            std::cerr << " Will initialize it with a default value.";
+            this->initDefaultAttribute.operator*()(this->child);
+        }
+        std::cerr << " Original error: " << e.what() << std::endl;
+        return;
+    }
+
+    Attribute attribute(Attribute::from_any, std::move(*aRead.m_resource));
+    for (auto &attributeReader : attributeReaders)
+    {
+
+        if (auto *not_matched =
+                std::get_if<attribute_read_result::TypeUnmatched>(&res))
+        {
+            res = attributeReader(
+                this->child,
+                this->attrName,
+                attribute,
+                std::move(not_matched->expectedDatatypes));
+        }
+        else
+        {
+            break;
+        }
+    }
+    auto dt = attribute.dtype;
+    std::visit(
+        auxiliary::overloaded{
+            [&](attribute_read_result::TypeUnmatched &&type_unmatched) {
+                std::cerr << "Unexpected type '" << dt << "' for attribute '"
+                          << this->attrName << "' in '"
+                          << this->child.myPath().openPMDPath()
+                          << "' with value '";
+                write_to_stderr(attribute) << "'. Expected one of ";
+                auxiliary::write_vec_to_stream(
+                    std::cerr, type_unmatched.expectedDatatypes)
+                    << " or convertible to such a type." << std::endl;
+            },
+            [&](error::ReadError const &err) {
+                std::cerr << "Unexpected error while trying to read "
+                             "attribute '"
+                          << this->attrName << "' in '"
+                          << this->child.myPath().openPMDPath()
+                          << "'' with value '";
+                write_to_stderr(attribute) << "': " << err.what() << std::endl;
+            },
+            [](attribute_read_result::Success) { /* no-op */ }},
+        std::move(res));
+}
+
+void ConfigAttribute::operator()(WriteOrRead wor)
+{
+    switch (wor)
+    {
+    case WriteOrRead::Write:
+        write();
+        break;
+    case WriteOrRead::Read:
+        read();
+        break;
+    }
+}
+
+// 5. ProcessAttribute implementations (RequireScalar, RequireVector,
+// RequireType) 2, 0.0976562
+auto RequireScalar::operator()(
+    Attributable &record, char const *attrName, Attribute const &attr)
+    -> std::optional<error::ReadError>
+{
+    auto res = attr.requireScalar();
+    using res_t = std::optional<error::ReadError>;
+    return std::visit(
+        auxiliary::overloaded{
+            [](std::runtime_error const &err) -> res_t {
+                std::string msg = "Expected a scalar type: ";
+                msg += err.what();
+                return error::ReadError(
+                    error::AffectedObject::Attribute,
+                    error::Reason::UnexpectedContent,
+                    std::nullopt,
+                    std::move(msg));
+            },
+            [&](Attribute converted_attr) -> res_t {
+                record.setAttribute(attrName, std::move(converted_attr));
+                return std::nullopt;
+            }},
+        std::move(res));
+}
+
+// 1, 0.113281
+auto RequireVector::operator()(
+    Attributable &record, char const *attrName, Attribute const &attr)
+    -> std::optional<error::ReadError>
+{
+    auto res = attr.requireVector();
+    using res_t = std::optional<error::ReadError>;
+    return std::visit(
+        auxiliary::overloaded{
+            [](std::runtime_error const &err) -> res_t {
+                std::string msg = "Expected a vector type: ";
+                msg += err.what();
+                return error::ReadError(
+                    error::AffectedObject::Attribute,
+                    error::Reason::UnexpectedContent,
+                    std::nullopt,
+                    std::move(msg));
+            },
+            [&](Attribute converted_attr) -> res_t {
+                record.setAttribute(attrName, std::move(converted_attr));
+                return std::nullopt;
+            }},
+        std::move(res));
+}
+
+// 3, 0.0117188
+template <typename T>
+auto RequireType<T>::operator()(
+    Attributable &record, char const *attrName, Attribute const &attr)
+    -> std::optional<error::ReadError>
+{
+    auto converted_or_error = attr.getOrError<T>();
+    return std::visit(
+        auxiliary::overloaded{
+            [&](T casted_val) -> std::optional<error::ReadError> {
+                if (this->postProcess.has_value())
+                {
+                    return (**this->postProcess)(std::move(casted_val));
+                }
+                else
+                {
+                    record.setAttribute<T>(attrName, std::move(casted_val));
+                    return std::nullopt;
+                }
+            },
+            [](std::runtime_error const &err)
+                -> std::optional<error::ReadError> {
+                std::string msg = "Expected a scalar type: ";
+                msg += err.what();
+                return error::ReadError(
+                    error::AffectedObject::Attribute,
+                    error::Reason::UnexpectedContent,
+                    std::nullopt,
+                    std::move(msg));
+            }},
+        converted_or_error);
+}
+
+// 6. Helper functions in anonymous namespace (require_scalar, require_vector,
+// require_type, etc.)
+namespace
+{
+    std::shared_ptr<ProcessAttribute> require_scalar =
+        std::make_shared<RequireScalar>();
+    // try converting to vectors (e.g. when a scalar or an array is given)
+    std::shared_ptr<ProcessAttribute> require_vector =
+        std::make_shared<RequireVector>();
+
+    template <typename T, typename RecordType>
+    auto require_type(
+        RecordType &&record,
+        std::optional<error::ReadError> (*handler)(
+            std::remove_reference_t<RecordType> &, T))
+        -> std::shared_ptr<ProcessAttribute>
+    {
+        return std::make_shared<RequireType<T>>(
+            std::forward<RecordType>(record), handler);
+    }
+
+    template <typename T>
+    auto require_type() -> std::shared_ptr<ProcessAttribute>
+    {
+        return std::make_shared<RequireType<T>>();
+    }
+
+    auto get_float_types() -> std::deque<Datatype>
+    {
+        std::deque<Datatype> res;
+        for (auto dt : openPMD_Datatypes())
+        {
+            if (isFloatingPoint(dt))
+            {
+                res.push_back(dt);
+            }
+        }
+        res.push_back(Datatype::ARR_DBL_7);
+        return res;
+    }
+
+    auto get_string_types() -> std::deque<Datatype>
+    {
+        return {
+            Datatype::STRING,
+            Datatype::VEC_STRING,
+            Datatype::CHAR,
+            Datatype::VEC_CHAR,
+            Datatype::UCHAR,
+            Datatype::VEC_UCHAR,
+            Datatype::SCHAR,
+            Datatype::VEC_SCHAR};
+    }
+} // namespace
+
+// 7. ScientificDefaults template implementations
+template <typename Child>
+auto ScientificDefaults<Child>::asChild() -> Child &
+{
+    return *static_cast<Child *>(this);
+}
+
+template <typename Child>
+auto ScientificDefaults<Child>::asChild() const -> Child const &
+{
+    return *static_cast<Child const *>(this);
+}
+
+template <typename Child>
+[[nodiscard]] auto
+ScientificDefaults<Child>::defaultAttribute(char const *attrName)
+    -> ConfigAttribute
+{
+    return ConfigAttribute{asChild(), attrName};
+}
+
+template <typename Child>
+template <typename Parent, bool write>
+void ScientificDefaults<Child>::addParentDefaults(OpenpmdStandard standard)
+{
+    // Cannot directly call read_impl as it is private
+    if constexpr (write)
+    {
+        asChild().ScientificDefaults<Parent>::addDefaults(standard);
+    }
+    else
+    {
+        asChild().ScientificDefaults<Parent>::readDefaults(standard);
+    }
+}
+
+template <typename Child>
+void ScientificDefaults<Child>::addDefaultsRecursively(OpenpmdStandard standard)
+{
+    addDefaults(standard);
+    if constexpr (IsContainer_v<Child>)
+    {
+        using Container_t = AsContainer_t<Child>;
+        using mapped_type = typename Container_t::mapped_type;
+        if constexpr (HasScientificDefaults_v<mapped_type>)
+        {
+            for (auto &[_, right] : asChild())
+            {
+                (void)_;
+                right.ScientificDefaults<mapped_type>::addDefaultsRecursively(
+                    standard);
+            }
+        }
+    }
+    // sic! no else
+
+    if constexpr (std::is_same_v<Child, Iteration>)
+    {
+        for (auto &[_, right] : asChild().meshes)
+        {
+            (void)_;
+            right.ScientificDefaults<Mesh>::addDefaultsRecursively(standard);
+        }
+        for (auto &[_, right] : asChild().particles)
+        {
+            (void)_;
+            right.ScientificDefaults<ParticleSpecies>::addDefaultsRecursively(
+                standard);
+        }
+    }
+    else if constexpr (std::is_same_v<Child, ParticleSpecies>)
+    {
+        for (auto &[_, right] : asChild().particlePatches)
+        {
+            (void)_;
+            right.ScientificDefaults<PatchRecord>::addDefaultsRecursively(
+                standard);
+        }
+    }
+}
+
+template <typename Child>
+template <bool write>
+void ScientificDefaults<Child>::defaults_impl(OpenpmdStandard standard)
+{
+    auto float_types = get_float_types();
+    auto string_types = get_string_types();
+
+    constexpr auto const wor = write ? WriteOrRead::Write : WriteOrRead::Read;
+
+    // First some verifications
+    if constexpr (write && auxiliary::IsTemplateBaseOf_v<BaseRecord, Child>)
+    {
+        if (asChild().empty() && !asChild().datasetDefined())
+        {
+            std::cerr
+                << "Cannot flush Record without any contained components: '"
+                << asChild().myPath().openPMDPath() << "'. Will ignore.";
+            if (asChild().written())
+            {
+                std::cerr << "\n(Note: The Record seems to have been written "
+                             "previously?)";
+            }
+            std::cerr << std::endl;
+            return;
+        }
+    }
+
+    if constexpr (std::is_same_v<Child, Iteration>)
+    {
+        defaultAttribute("time")
+            .template withSetter<Iteration>(0., &Iteration::setTime)
+            .withReader(float_types, require_scalar)(wor);
+        defaultAttribute("dt")
+            .template withSetter<Iteration>(1., &Iteration::setDt)
+            .withReader(float_types, require_scalar)(wor);
+        defaultAttribute("timeUnitSI")
+            .template withSetter<Iteration>(1.0, &Iteration::setTimeUnitSI)
+            .withReader(float_types, require_type<double>())(wor);
+    }
+    else if constexpr (std::is_same_v<Child, Mesh>)
+    {
+        auto dimensionality = asChild().retrieveDimensionality();
+
+        defaultAttribute("geometry")
+            .template withSetter<Mesh>(
+                Mesh::Geometry::cartesian, &Mesh::setGeometry)
+            .withReader(
+                string_types,
+                require_type(asChild(), &setMeshGeometryFromString))(wor);
+
+        defaultAttribute("dataOrder")
+            .template withSetter<Mesh>(Mesh::DataOrder::C, &Mesh::setDataOrder)
+            .withReader(
+                string_types,
+                require_type(asChild(), &setMeshDataOrderFromChar))(wor);
+
+        defaultAttribute("axisLabels")
+            .template withSetter<Mesh, std::vector<std::string> const &>(
+                [&]() -> std::vector<std::string> {
+                    return createDefaultAxisLabels(dimensionality);
+                },
+                &Mesh::setAxisLabels)
+            .withReader(string_types, require_vector)(wor);
+
+        defaultAttribute("gridSpacing")
+            .template withSetter<Mesh, std::vector<double> const &>(
+                [&]() { return createDefaultVector(dimensionality, 1.0); },
+                &Mesh::setGridSpacing)
+            .withReader(float_types, require_vector)(wor);
+
+        defaultAttribute("gridGlobalOffset")
+            .template withSetter<Mesh, std::vector<double> const &>(
+                [&]() { return createDefaultVector(dimensionality, 0.0); },
+                &Mesh::setGridGlobalOffset)
+            .withReader(float_types, require_type<std::vector<double>>())(wor);
+
+        defaultAttribute("timeOffset")
+            .template withSetter<Mesh>(0.f, &Mesh::setTimeOffset)
+            .withReader(float_types, require_scalar)(wor);
+
+        if (standard >= OpenpmdStandard::v_2_0_0)
+        {
+            defaultAttribute("gridUnitSI")
+                .template withSetter<Mesh, std::vector<double> const &>(
+                    [&]() { return createDefaultVector(dimensionality, 1.); },
+                    &Mesh::setGridUnitSIPerDimension)
+                .withReader(float_types, require_type<std::vector<double>>())(
+                    wor);
+        }
+        else
+        {
+            defaultAttribute("gridUnitSI")
+                .template withSetter<Mesh>(1.0, &Mesh::setGridUnitSI)
+                .withReader(float_types, require_type<std::vector<double>>())(
+                    wor);
+        }
+
+        addParentDefaults<BaseRecord<MeshRecordComponent>, write>(standard);
+    }
+    else if constexpr (std::is_same_v<Child, Record>)
+    {
+        defaultAttribute("timeOffset")
+            .template withSetter<Record>(0.f, &Record::setTimeOffset)
+            .withReader(float_types, require_scalar)(wor);
+
+        auto const &keyInParent = asChild().writable().ownKeyWithinParent;
+        if (keyInParent == "position" || keyInParent == "positionOffset")
+        {
+            defaultAttribute("unitDimension")
+                .template withSetter<
+                    Record,
+                    unit_representations::AsMap const &>(
+                    []() {
+                        return unit_representations::AsMap{
+                            {UnitDimension::L, 1.0}};
+                    },
+                    &Record::setUnitDimension)(wor);
+        }
+
+        defaultAttribute("timeOffset")
+            .template withSetter<Record>(0.f, &Record::setTimeOffset)
+            .withReader(float_types, require_scalar)(wor);
+
+        addParentDefaults<BaseRecord<RecordComponent>, write>(standard);
+    }
+    else if constexpr (std::is_same_v<Child, PatchRecord>)
+    {
+        addParentDefaults<BaseRecord<PatchRecordComponent>, write>(standard);
+    }
+    else if constexpr (std::is_same_v<Child, RecordComponent>)
+    {
+        defaultAttribute("unitSI")
+            .template withSetter<RecordComponent>(
+                1.0, &RecordComponent::setUnitSI)
+            .withReader(float_types, require_type<double>())(wor);
+    }
+    else if constexpr (std::is_same_v<Child, MeshRecordComponent>)
+    {
+        auto dimensionality = asChild().getDimensionality();
+
+        defaultAttribute("position")
+            .template withSetter<MeshRecordComponent>(
+                [&]() { return createDefaultVector(dimensionality, 0.5); },
+                &MeshRecordComponent::setPosition)
+            .withReader(float_types, require_vector)(wor);
+
+        addParentDefaults<RecordComponent, write>(standard);
+    }
+    else if constexpr (std::is_same_v<Child, PatchRecordComponent>)
+    {
+        // We don't require unitSI for PatchRecordComponent
+        //
+        // addParentDefaults<RecordComponent, write>();
+        //
+        // But we still set it when writing. Doesnt hurt and some readers might
+        // expect it.
+        defaultAttribute("unitSI").template withSetter<PatchRecordComponent>(
+            1.0, &PatchRecordComponent::setUnitSI)
+            // Do NOT add a reader here.
+            // .withReader(float_types, require_type<double>())
+            (wor);
+    }
+    else if constexpr (detail::IsBaseRecord_v<Child>)
+    {
+        defaultAttribute("unitDimension")
+            .withGenericSetter(unit_representations::AsArray{})
+            .withReader(
+                float_types,
+                require_type<unit_representations::AsArray>())(wor);
+    }
+    else if constexpr (std::is_same_v<Child, ParticleSpecies>)
+    {
+        // no-op
+    }
+    else
+    {
+        static_assert(auxiliary::dependent_false_v<Child>, "Unknown class");
+    }
+}
+
+template <typename Child>
+void ScientificDefaults<Child>::addDefaults(OpenpmdStandard standard)
+{
+    defaults_impl</* write = */ true>(standard);
+}
+
+template <typename Child>
+void ScientificDefaults<Child>::readDefaults(OpenpmdStandard standard)
+{
+    defaults_impl</* write = */ false>(standard);
+}
+
+// 8. Template instantiations
+template class ScientificDefaults<Iteration>;
+template class ScientificDefaults<Mesh>;
+template class ScientificDefaults<MeshRecordComponent>;
+template class ScientificDefaults<RecordComponent>;
+template class ScientificDefaults<PatchRecordComponent>;
+template class ScientificDefaults<ParticleSpecies>;
+template class ScientificDefaults<Record>;
+template class ScientificDefaults<BaseRecord<MeshRecordComponent>>;
+template class ScientificDefaults<BaseRecord<PatchRecordComponent>>;
+template class ScientificDefaults<BaseRecord<RecordComponent>>;
+template class ScientificDefaults<PatchRecord>;
+} // namespace openPMD::internal
diff --git a/src/binding/python/PatchRecord.cpp b/src/binding/python/PatchRecord.cpp
index 2157735ce3..c3de55f64c 100644
--- a/src/binding/python/PatchRecord.cpp
+++ b/src/binding/python/PatchRecord.cpp
@@ -28,6 +28,8 @@
 #include "openPMD/binding/python/Container.H"
 #include "openPMD/binding/python/UnitDimension.hpp"
 
+#include <variant>
+
 void init_PatchRecord(py::module &m)
 {
     auto py_pr_cnt = declare_container<PyPatchRecordContainer, Attributable>(
@@ -38,11 +40,23 @@ void init_PatchRecord(py::module &m)
         .def_property(
             "unit_dimension",
             &PatchRecord::unitDimension,
-            &PatchRecord::setUnitDimension,
+            [](PatchRecord &self,
+               std::variant<
+                   unit_representations::AsMap,
+                   unit_representations::AsArray> const &arg) -> PatchRecord & {
+                return std::visit(
+                    [&](auto const &arg_resolved) -> PatchRecord & {
+                        return self.setUnitDimension(arg_resolved);
+                    },
+                    arg);
+            },
             python::doc_unit_dimension)
 
         // TODO remove in future versions (deprecated)
-        .def("set_unit_dimension", &PatchRecord::setUnitDimension);
+        .def(
+            "set_unit_dimension",
+            py::overload_cast<unit_representations::AsMap const &>(
+                &PatchRecord::setUnitDimension));
 
     finalize_container<PyPatchRecordContainer>(py_pr_cnt);
 }
diff --git a/test/AuxiliaryTest.cpp b/test/AuxiliaryTest.cpp
index e3b4635185..9055706576 100644
--- a/test/AuxiliaryTest.cpp
+++ b/test/AuxiliaryTest.cpp
@@ -19,6 +19,7 @@
  * If not, see <http://www.gnu.org/licenses/>.
  */
 // expose private and protected members for invasive testing
+#include "openPMD/IO/AbstractIOHandler_internal.hpp"
 #if openPMD_USE_INVASIVE_TESTS
 #define OPENPMD_private public:
 #define OPENPMD_protected public:
@@ -49,6 +50,12 @@
 
 using namespace openPMD;
 
+auto wrapAccess(openPMD::Access at)
+    -> openPMD::internal::AbstractIOHandlerInitFrom
+{
+    return openPMD::internal::GlobalParameters{at};
+}
+
 namespace openPMD::test
 {
 struct TestHelper : public Attributable
@@ -58,7 +65,7 @@ struct TestHelper : public Attributable
         writable().IOHandler =
             std::make_shared<std::optional<std::unique_ptr<AbstractIOHandler>>>(
                 createIOHandler(
-                    std::nullopt, ".", Access::CREATE, Format::JSON, ".json"));
+                    wrapAccess(Access::CREATE), Format::JSON, ".json"));
     }
 };
 } // namespace openPMD::test
@@ -173,8 +180,7 @@ TEST_CASE("container_default_test", "[auxiliary]")
     Container<openPMD::test::S> c = Container<openPMD::test::S>();
     c.writable().IOHandler =
         std::make_shared<std::optional<std::unique_ptr<AbstractIOHandler>>>(
-            createIOHandler(
-                std::nullopt, ".", Access::CREATE, Format::JSON, ".json"));
+            createIOHandler(wrapAccess(Access::CREATE), Format::JSON, ".json"));
 
     REQUIRE(c.empty());
     REQUIRE(c.erase("nonExistentKey") == false);
@@ -214,8 +220,7 @@ TEST_CASE("container_retrieve_test", "[auxiliary]")
     Container<structure> c = Container<structure>();
     c.writable().IOHandler =
         std::make_shared<std::optional<std::unique_ptr<AbstractIOHandler>>>(
-            createIOHandler(
-                std::nullopt, ".", Access::CREATE, Format::JSON, ".json"));
+            createIOHandler(wrapAccess(Access::CREATE), Format::JSON, ".json"));
 
     structure s;
     std::string text =
@@ -289,8 +294,7 @@ TEST_CASE("container_access_test", "[auxiliary]")
     Container<Widget> c = Container<Widget>();
     c.writable().IOHandler =
         std::make_shared<std::optional<std::unique_ptr<AbstractIOHandler>>>(
-            createIOHandler(
-                std::nullopt, ".", Access::CREATE, Format::JSON, ".json"));
+            createIOHandler(wrapAccess(Access::CREATE), Format::JSON, ".json"));
 
     c["1firstWidget"] = Widget(0);
     REQUIRE(c.size() == 1);
diff --git a/test/CoreTest.cpp b/test/CoreTest.cpp
index ad22ae1cf8..9a7fa15969 100644
--- a/test/CoreTest.cpp
+++ b/test/CoreTest.cpp
@@ -618,6 +618,9 @@ TEST_CASE("iteration_default_test", "[core]")
 
     Iteration &i = o.iterations[42];
 
+    REQUIRE(i.numAttributes() == 0);
+
+    i.close();
     REQUIRE(i.time<double>() == static_cast<double>(0));
     REQUIRE(i.dt<double>() == static_cast<double>(1));
     REQUIRE(i.timeUnitSI() == static_cast<double>(1));
@@ -663,13 +666,15 @@ TEST_CASE("particleSpecies_modification_test", "[core]")
     REQUIRE(0 == patches.numAttributes());
     auto &offset = patches["offset"];
     REQUIRE(0 == offset.size());
-    REQUIRE(1 == offset.numAttributes()); // unitDimension
-    std::array<double, 7> zeros{{0., 0., 0., 0., 0., 0., 0.}};
-    REQUIRE(zeros == offset.unitDimension());
 
     auto &off_x = offset["x"];
     off_x.resetDataset(dset);
+
+    o.iterations[42].close();
+    REQUIRE(1 == offset.numAttributes()); // unitDimension
     REQUIRE(1 == off_x.unitSI());
+    std::array<double, 7> zeros{{0., 0., 0., 0., 0., 0., 0.}};
+    REQUIRE(zeros == offset.unitDimension());
 }
 
 TEST_CASE("record_constructor_test", "[core]")
@@ -689,11 +694,16 @@ TEST_CASE("record_constructor_test", "[core]")
     REQUIRE(r["y"].resetDataset(dset).numAttributes() == 0); /* unitSI */
     // REQUIRE(r["z"].unitSI() == 1);
     REQUIRE(r["z"].resetDataset(dset).numAttributes() == 0); /* unitSI */
+    REQUIRE(r.numAttributes() == 0);
+    // TODO: unitSI
+    // REQUIRE(r["x"].numAttributes() == 0);
+    // REQUIRE(r["y"].numAttributes() == 0);
+    // REQUIRE(r["z"].numAttributes() == 0);
+    o.iterations[42].close();
     std::array<double, 7> zeros{{0., 0., 0., 0., 0., 0., 0.}};
     REQUIRE(r.unitDimension() == zeros);
     REQUIRE(r.timeOffset<float>() == static_cast<float>(0));
     REQUIRE(r.numAttributes() == 2); /* timeOffset, unitDimension */
-    o.flush();
     REQUIRE(r["x"].unitSI() == 1);
     REQUIRE(r["y"].unitSI() == 1);
     REQUIRE(r["z"].unitSI() == 1);
@@ -754,12 +764,15 @@ TEST_CASE("mesh_constructor_test", "[core]")
 
     Mesh &m = o.iterations[42].meshes["E"];
 
-    std::vector<double> pos{0};
-    /* unitSI and position are set to default values upon flushing */
+    std::vector<double> pos{0.5};
+    /* unitSI and position are set to default values upon closing */
     REQUIRE(m["x"].resetDataset(globalDataset).numAttributes() == 0);
     REQUIRE(m["y"].resetDataset(globalDataset).numAttributes() == 0);
     REQUIRE(m["z"].resetDataset(globalDataset).numAttributes() == 0);
 
+    REQUIRE(m.numAttributes() == 0);
+    o.iterations[42].close();
+
     REQUIRE(m.geometry() == Mesh::Geometry::cartesian);
     REQUIRE(m.dataOrder() == Mesh::DataOrder::C);
     std::vector<std::string> al{"x"};
@@ -768,12 +781,12 @@ TEST_CASE("mesh_constructor_test", "[core]")
     REQUIRE(m.gridSpacing<double>() == gs);
     std::vector<double> ggo{0};
     REQUIRE(m.gridGlobalOffset() == ggo);
+    auxiliary::write_vec_to_stream(std::cout, m.attributes()) << std::endl;
     REQUIRE(
         m.numAttributes() ==
-        7); /* axisLabels, dataOrder, geometry, gridGlobalOffset, gridSpacing,
-               timeOffset, unitDimension */
+        8); /* axisLabels, dataOrder, geometry, gridGlobalOffset, gridSpacing,
+               timeOffset, unitDimension, gridUnitSI */
 
-    o.flush();
     REQUIRE(m["x"].unitSI() == 1);
     REQUIRE(m["x"].numAttributes() == 2); /* unitSI, position */
     REQUIRE(m["x"].position<double>() == pos);
@@ -794,24 +807,27 @@ TEST_CASE("mesh_modification_test", "[core]")
     m["y"].resetDataset(globalDataset);
     m["z"].resetDataset(globalDataset);
 
+    o.iterations[42].close(); // trigger writing for defaults
+    o.iterations[42].open();
+
     m.setGeometry(Mesh::Geometry::spherical);
     REQUIRE(m.geometry() == Mesh::Geometry::spherical);
-    REQUIRE(m.numAttributes() == 7);
+    REQUIRE(m.numAttributes() == 8);
     m.setDataOrder(Mesh::DataOrder::F);
     REQUIRE(m.dataOrder() == Mesh::DataOrder::F);
-    REQUIRE(m.numAttributes() == 7);
+    REQUIRE(m.numAttributes() == 8);
     std::vector<std::string> al{"z_", "y_", "x_"};
     m.setAxisLabels({"z_", "y_", "x_"});
     REQUIRE(m.axisLabels() == al);
-    REQUIRE(m.numAttributes() == 7);
+    REQUIRE(m.numAttributes() == 8);
     std::vector<double> gs{1e-5, 2e-5, 3e-5};
     m.setGridSpacing(gs);
     REQUIRE(m.gridSpacing<double>() == gs);
-    REQUIRE(m.numAttributes() == 7);
+    REQUIRE(m.numAttributes() == 8);
     std::vector<double> ggo{1e-10, 2e-10, 3e-10};
     m.setGridGlobalOffset({1e-10, 2e-10, 3e-10});
     REQUIRE(m.gridGlobalOffset() == ggo);
-    REQUIRE(m.numAttributes() == 7);
+    REQUIRE(m.numAttributes() == 8);
     m.setGridUnitSI(42.0);
     REQUIRE(m.gridUnitSI() == static_cast<double>(42));
     REQUIRE(m.numAttributes() == 8);
@@ -1127,8 +1143,10 @@ TEST_CASE("wrapper_test", "[core]")
     std::shared_ptr<double> storeData = std::make_shared<double>(44);
     o.iterations[5].meshes["E"]["y"].storeChunk(storeData, {0}, {1});
 #if openPMD_USE_INVASIVE_TESTS
-    REQUIRE(o.iterations[5].meshes["E"]["y"].get().m_chunks.size() == 1);
-    REQUIRE(mrc3.get().m_chunks.size() == 1);
+    size_t num_chunks = o.IOHandler()->m_flush_immediately ? 0 : 1;
+    REQUIRE(
+        o.iterations[5].meshes["E"]["y"].get().m_chunks.size() == num_chunks);
+    REQUIRE(mrc3.get().m_chunks.size() == num_chunks);
 #endif
     o.flush();
 #if openPMD_USE_INVASIVE_TESTS
@@ -1181,9 +1199,10 @@ TEST_CASE("wrapper_test", "[core]")
             .particles["electrons"]
             .particlePatches["numParticles"][RecordComponent::SCALAR]
             .get()
-            .m_chunks.size() == 1);
+            .m_chunks.size() == num_chunks);
     REQUIRE(
-        pp["numParticles"][RecordComponent::SCALAR].get().m_chunks.size() == 1);
+        pp["numParticles"][RecordComponent::SCALAR].get().m_chunks.size() ==
+        num_chunks);
 #endif
     std::stringstream u64str;
     u64str << determineDatatype<uint64_t>();
@@ -1205,9 +1224,10 @@ TEST_CASE("wrapper_test", "[core]")
             .particles["electrons"]
             .particlePatches["numParticles"][RecordComponent::SCALAR]
             .get()
-            .m_chunks.size() == 2);
+            .m_chunks.size() == num_chunks * 2);
     REQUIRE(
-        pp["numParticles"][RecordComponent::SCALAR].get().m_chunks.size() == 2);
+        pp["numParticles"][RecordComponent::SCALAR].get().m_chunks.size() ==
+        num_chunks * 2);
 #endif
     o.flush();
 #if openPMD_USE_INVASIVE_TESTS
@@ -1250,11 +1270,13 @@ TEST_CASE("use_count_test", "[core]")
     std::shared_ptr<uint16_t> storeData = std::make_shared<uint16_t>(44);
     REQUIRE(storeData.use_count() == 1);
     mrc.storeChunk(storeData, {0}, {1});
-    REQUIRE(storeData.use_count() == 2);
+#if openPMD_USE_INVASIVE_TESTS
+    long additional_internal_use_count =
+        o.IOHandler()->m_flush_immediately ? 0 : 1;
+    REQUIRE(storeData.use_count() == (1 + additional_internal_use_count));
     o.flush();
     REQUIRE(storeData.use_count() == 1);
 
-#if openPMD_USE_INVASIVE_TESTS
     PatchRecordComponent pprc =
         o.iterations[6]
             .particles["electrons"]
@@ -1268,12 +1290,19 @@ TEST_CASE("use_count_test", "[core]")
         .resetDataset(dset);
     pprc.resetDataset(Dataset(determineDatatype<uint64_t>(), {4}));
     pprc.store(0, static_cast<uint64_t>(1));
-    REQUIRE(
-        std::get<std::shared_ptr<void const>>(
-            static_cast<Parameter<Operation::WRITE_DATASET> *>(
-                pprc.get().m_chunks.front().parameter.get())
-                ->data.as_variant<auxiliary::WriteBufferTypes>())
-            .use_count() == 1);
+    if (o.IOHandler()->m_flush_immediately)
+    {
+        REQUIRE(pprc.get().m_chunks.empty());
+    }
+    else
+    {
+        REQUIRE(
+            std::get<std::shared_ptr<void const>>(
+                static_cast<Parameter<Operation::WRITE_DATASET> *>(
+                    pprc.get().m_chunks.front().parameter.get())
+                    ->data.as_variant<auxiliary::WriteBufferTypes>())
+                .use_count() == 1);
+    }
 #endif
 }
 
@@ -1283,16 +1312,14 @@ TEST_CASE("empty_record_test", "[core]")
 
     o.iterations[1].meshes["E"].setComment(
         "No assumption about contained RecordComponents will be made");
-    REQUIRE_THROWS_WITH(
-        o.flush(),
-        Catch::Equals(
-            "A Record can not be written without any contained "
-            "RecordComponents: E"));
-    o.iterations[1].meshes["E"][RecordComponent::SCALAR].resetDataset(
-        Dataset(Datatype::DOUBLE, {1}));
     auto B = o.iterations[1].meshes["B"];
     B.resetDataset(Dataset(Datatype::DOUBLE, {1}));
-    o.flush();
+    auto sneakily_keep_meshes_alive = o.iterations[1].meshes;
+    o.close();
+#if openPMD_USE_INVASIVE_TESTS
+    REQUIRE(!sneakily_keep_meshes_alive["E"].written());
+    REQUIRE(sneakily_keep_meshes_alive["B"].written());
+#endif
 }
 
 TEST_CASE("zero_extent_component", "[core]")
diff --git a/test/Files_ParallelIO/bug_1655_bp5_writer_hangup.cpp b/test/Files_ParallelIO/bug_1655_bp5_writer_hangup.cpp
index 5b62949e62..855e152766 100644
--- a/test/Files_ParallelIO/bug_1655_bp5_writer_hangup.cpp
+++ b/test/Files_ParallelIO/bug_1655_bp5_writer_hangup.cpp
@@ -39,6 +39,11 @@ auto worker(std::string const &ext) -> void
     std::string filename = "../samples/ptl_%T." + ext;
 
     Series series = Series(filename, Access::CREATE_LINEAR, MPI_COMM_WORLD);
+    if (series.flushImmediately())
+    {
+        // Cannot run this test in immediate flush mode
+        return;
+    }
 
     Datatype datatype = determineDatatype<float>();
 
diff --git a/test/ParallelIOTest.cpp b/test/ParallelIOTest.cpp
index b05c778244..a48aad2c1d 100644
--- a/test/ParallelIOTest.cpp
+++ b/test/ParallelIOTest.cpp
@@ -147,6 +147,12 @@ void write_test_zero_extent(
         Access::CREATE_LINEAR,
         MPI_COMM_WORLD);
 
+    if (o.flushImmediately() && !writeAllChunks)
+    {
+        // immediate flushing makes storeChunk collective, cannot do this
+        return;
+    }
+
     int const max_step = 100;
 
     for (int step = 0; step <= max_step; step += 20)
@@ -453,18 +459,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 +530,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);
+        }
     }
 }
 
@@ -841,8 +916,25 @@ void close_iteration_test(std::string const &file_ending)
         {
             REQUIRE(data[i % 4] == chunk.get()[i]);
         }
-        auto read_again = E_x_read.loadChunk<int>({0, 0}, {mpi_size, 4});
-        // REQUIRE_THROWS(read.flush());
+        // Cannot write/read chunks to/from closed Iterations.
+        if (read.flushImmediately())
+        {
+#if openPMD_USE_INVASIVE_TESTS
+            REQUIRE_THROWS_WITH(
+                E_x_read.loadChunk<int>({0, 0}, {mpi_size, 4}),
+                "Cannot write/read chunks to/from closed Iterations.");
+#else
+            REQUIRE_THROWS_WITH(
+                E_x_read.loadChunk<int>({0, 0}, {mpi_size, 4}),
+                "Wrong API usage: [Series] Closed iteration (idx=1) must be "
+                "open()ed explicitly before interacting with it again.");
+#endif
+        }
+        else
+        {
+            auto read_again = E_x_read.loadChunk<int>({0, 0}, {mpi_size, 4});
+            // REQUIRE_THROWS(read.flush());
+        }
     }
 
     chunk_assignment::RankMeta compare;
diff --git a/test/SerialIOTest.cpp b/test/SerialIOTest.cpp
index b81339944f..db99be8ea6 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)
@@ -4342,6 +4350,7 @@ void adios2_bp5_flush(std::string const &cfg, FlushDuringStep flushDuringStep)
     Datatype dtype = determineDatatype<int32_t>();
     {
         Series write("../samples/bp5_flush.bp", Access::CREATE_LINEAR, cfg);
+        bool flushImmediately = write.flushImmediately();
 
         {
             auto component =
@@ -4378,8 +4387,16 @@ void adios2_bp5_flush(std::string const &cfg, FlushDuringStep flushDuringStep)
         if (flushDuringStep == FlushDuringStep::Default_Yes ||
             flushDuringStep == FlushDuringStep::Always)
         {
-            // should still be roughly within 1% of 4Mb
-            REQUIRE(std::abs(1 - double(currentSize) / (4 * size)) <= 0.01);
+            if (flushImmediately)
+            {
+                // should still be roughly within 1% of 8Mb
+                REQUIRE(std::abs(1 - double(currentSize) / (8 * size)) <= 0.01);
+            }
+            else
+            {
+                // should still be roughly within 1% of 4Mb
+                REQUIRE(std::abs(1 - double(currentSize) / (4 * size)) <= 0.01);
+            }
         }
         else
         {
@@ -4419,8 +4436,17 @@ void adios2_bp5_flush(std::string const &cfg, FlushDuringStep flushDuringStep)
         }
         else if (flushDuringStep == FlushDuringStep::Default_Yes)
         {
-            // should now be roughly within 1% of 8Mb
-            REQUIRE(std::abs(1 - double(currentSize) / (8 * size)) <= 0.01);
+            if (flushImmediately)
+            {
+                // should now be roughly within 1% of 12Mb
+                REQUIRE(
+                    std::abs(1 - double(currentSize) / (12 * size)) <= 0.01);
+            }
+            else
+            {
+                // should now be roughly within 1% of 8Mb
+                REQUIRE(std::abs(1 - double(currentSize) / (8 * size)) <= 0.01);
+            }
         }
         else
         {