diff --git a/backend/src/Systems/common/Access.hpp b/backend/src/Systems/common/Access.hpp
new file mode 100644
index 00000000..58ab1969
--- /dev/null
+++ b/backend/src/Systems/common/Access.hpp
@@ -0,0 +1,118 @@
+#pragma once
+
+//******************************************************************************
+// Includes
+//******************************************************************************
+#include <cstddef>  // size_t
+
+namespace elastica {
+
+  //============================================================================
+  //
+  //  ACCESS API FUNCTIONS
+  //
+  //============================================================================
+
+  //****************************************************************************
+  /*!\brief Any physical system adhering to elastica::protocols::PhysicalSystem
+  // \ingroup systems
+  */
+  struct AnyPhysicalSystem {};
+  //****************************************************************************
+
+  //**Position functions********************************************************
+  /*!\name Position functions */
+  //@{
+  /*!\brief Retrieves position from the systems
+   * \ingroup systems
+   */
+  inline constexpr decltype(auto) position(AnyPhysicalSystem& t) noexcept;
+  inline constexpr decltype(auto) position(AnyPhysicalSystem const& t) noexcept;
+  inline constexpr decltype(auto) position(AnyPhysicalSystem& t,
+                                           std::size_t index) noexcept;
+  inline constexpr decltype(auto) position(AnyPhysicalSystem const& t,
+                                           std::size_t index) noexcept;
+  //@}
+  //****************************************************************************
+
+  //**Director functions********************************************************
+  /*!\name Director functions */
+  //@{
+  /*!\brief Retrieves directors from the systems
+   * \ingroup systems
+   */
+  inline constexpr decltype(auto) director(AnyPhysicalSystem& t) noexcept;
+  inline constexpr decltype(auto) director(AnyPhysicalSystem const& t) noexcept;
+  inline constexpr decltype(auto) director(AnyPhysicalSystem& t,
+                                           std::size_t index) noexcept;
+  inline constexpr decltype(auto) director(AnyPhysicalSystem const& t,
+                                           std::size_t index) noexcept;
+  //@}
+  //****************************************************************************
+
+  //**Velocity functions********************************************************
+  /*!\name Velocity functions */
+  //@{
+  /*!\brief Retrieves velocities from the systems
+   * \ingroup systems
+   */
+  inline constexpr decltype(auto) velocity(AnyPhysicalSystem& t) noexcept;
+  inline constexpr decltype(auto) velocity(AnyPhysicalSystem const& t) noexcept;
+  inline constexpr decltype(auto) velocity(AnyPhysicalSystem& t,
+                                           std::size_t index) noexcept;
+  inline constexpr decltype(auto) velocity(AnyPhysicalSystem const& t,
+                                           std::size_t index) noexcept;
+  //@}
+  //****************************************************************************
+
+  //**Angular Velocity functions************************************************
+  /*!\name Angular Velocity functions */
+  //@{
+  /*!\brief Retrieves angular velocities from the systems
+   * \ingroup systems
+   */
+  inline constexpr decltype(auto) angular_velocity(
+      AnyPhysicalSystem& t) noexcept;
+  inline constexpr decltype(auto) angular_velocity(
+      AnyPhysicalSystem const& t) noexcept;
+  inline constexpr decltype(auto) angular_velocity(AnyPhysicalSystem& t,
+                                                   std::size_t index) noexcept;
+  inline constexpr decltype(auto) angular_velocity(AnyPhysicalSystem const& t,
+                                                   std::size_t index) noexcept;
+  //@}
+  //****************************************************************************
+
+  //**External loads functions**************************************************
+  /*!\name External loads functions */
+  //@{
+  /*!\brief Retrieves external loads of a given system
+   * \ingroup systems
+   */
+  inline constexpr decltype(auto) external_loads(AnyPhysicalSystem& t) noexcept;
+  inline constexpr decltype(auto) external_loads(
+      AnyPhysicalSystem const& t) noexcept;
+  inline constexpr decltype(auto) external_loads(AnyPhysicalSystem& t,
+                                                 std::size_t index) noexcept;
+  inline constexpr decltype(auto) external_loads(AnyPhysicalSystem const& t,
+                                                 std::size_t index) noexcept;
+  //@}
+  //****************************************************************************
+
+  //**External torques functions************************************************
+  /*!\name External torques functions */
+  //@{
+  /*!\brief Retrieves external torques of a given system
+   * \ingroup systems
+   */
+  inline constexpr decltype(auto) external_torques(
+      AnyPhysicalSystem& t) noexcept;
+  inline constexpr decltype(auto) external_torques(
+      AnyPhysicalSystem const& t) noexcept;
+  inline constexpr decltype(auto) external_torques(AnyPhysicalSystem& t,
+                                                   std::size_t index) noexcept;
+  inline constexpr decltype(auto) external_torques(AnyPhysicalSystem const& t,
+                                                   std::size_t index) noexcept;
+  //@}
+  //****************************************************************************
+
+}  // namespace elastica
diff --git a/backend/src/Systems/common/CMakeLists.txt b/backend/src/Systems/common/CMakeLists.txt
new file mode 100644
index 00000000..1bef0074
--- /dev/null
+++ b/backend/src/Systems/common/CMakeLists.txt
@@ -0,0 +1,42 @@
+# Distributed under the MIT License. See LICENSE.txt for details.
+
+set(LIBRARY SystemsCommon)
+
+add_elastica_library(${LIBRARY} INTERFACE)
+
+set(TARGET_SOURCES
+        Access.hpp
+        Cardinality.hpp
+        Components.hpp
+        IndexCheck.hpp
+        Initialization.hpp
+        Protocols.hpp
+        SymplecticStepperAdapter.hpp
+        Tags.hpp
+        Types.hpp
+        )
+
+elastica_target_headers(
+        ${LIBRARY}
+        INCLUDE_DIRECTORY ${CMAKE_SOURCE_DIR}/elastica
+        ${TARGET_SOURCES}
+)
+
+elastica_target_sources(
+        ${LIBRARY}
+        INTERFACE
+        ${TARGET_SOURCES}
+)
+
+add_subdirectory(Components)
+add_subdirectory(Warnings)
+add_subdirectory(Python)
+add_subdirectory(Traits)
+
+target_link_libraries(
+        ${LIBRARY}
+        INTERFACE
+        Components
+        SystemsWarnings
+        SystemsCommonTraits
+)
diff --git a/backend/src/Systems/common/Cardinality.hpp b/backend/src/Systems/common/Cardinality.hpp
new file mode 100644
index 00000000..8ae16038
--- /dev/null
+++ b/backend/src/Systems/common/Cardinality.hpp
@@ -0,0 +1,75 @@
+#pragma once
+
+//******************************************************************************
+// Includes
+//******************************************************************************
+#include "Systems/common/Components/Types.hpp"
+//
+
+namespace elastica {
+
+  //============================================================================
+  //
+  //  CLASS DEFINITION
+  //
+  //============================================================================
+
+  //****************************************************************************
+  /*!\brief Tag representing unit cardinality
+   * \ingroup systems
+   *
+   * \details
+   * Indicates that one system of a plugin has only one Lagrangian degree
+   * of freedom.
+   */
+  struct UnitCardinality {
+    //! Index for unit cardinality
+    static constexpr auto index() noexcept -> std::size_t { return 0UL; }
+  };
+  //****************************************************************************
+
+  //****************************************************************************
+  /*!\brief Tag representing multiple cardinality
+   * \ingroup systems
+   *
+   * \details
+   * Indicates that one system of a plugin has multiple Lagrangian degrees
+   * of freedom.
+   *
+   */
+  struct MultipleCardinality {};
+  //****************************************************************************
+
+  //****************************************************************************
+  /*!\brief Indicates unit cardinality of a plugin.
+   * \ingroup systems
+   *
+   * \tparam Plugin A system plugin.
+   * \see UnitCardinality
+   */
+  template <typename Plugin>
+  struct HasUnitCardinality {
+    //**Type definitions********************************************************
+    //! Type of cardinality
+    using cardinality = UnitCardinality;
+    //**************************************************************************
+  };
+  //****************************************************************************
+
+  //****************************************************************************
+  /*!\brief Indicates multiple cardinality of a plugin.
+   * \ingroup systems
+   *
+   * \tparam Plugin A system plugin.
+   * \see MultipleCardinality
+   */
+  template <typename Plugin>
+  struct HasMultipleCardinality {
+    //**Type definitions********************************************************
+    //! Type of cardinality
+    using cardinality = MultipleCardinality;
+    //**************************************************************************
+  };
+  //****************************************************************************
+
+}  // namespace elastica
diff --git a/backend/src/Systems/common/Components.hpp b/backend/src/Systems/common/Components.hpp
new file mode 100644
index 00000000..64f6fea0
--- /dev/null
+++ b/backend/src/Systems/common/Components.hpp
@@ -0,0 +1,13 @@
+#pragma once
+
+//******************************************************************************
+// Includes
+//******************************************************************************
+
+///
+#include "Systems/common/Components/Types.hpp"
+///
+#include "Systems/common/Components/Component.hpp"
+#include "Systems/common/Components/GeometryComponent.hpp"
+#include "Systems/common/Components/KinematicsComponent.hpp"
+#include "Systems/common/Components/TypeTraits.hpp"
diff --git a/backend/src/Systems/common/Components/CMakeLists.txt b/backend/src/Systems/common/Components/CMakeLists.txt
new file mode 100644
index 00000000..806b16a5
--- /dev/null
+++ b/backend/src/Systems/common/Components/CMakeLists.txt
@@ -0,0 +1,35 @@
+# Distributed under the MIT License. See LICENSE.txt for details.
+
+set(LIBRARY Components)
+
+add_elastica_library(${LIBRARY} INTERFACE)
+
+elastica_target_headers(
+        ${LIBRARY}
+        INCLUDE_DIRECTORY ${CMAKE_SOURCE_DIR}/elastica
+        Component.hpp
+        GeometryComponent.hpp
+        KinematicsComponent.hpp
+        NameComponent.hpp
+        NameAdapter.hpp
+        Types.hpp
+        TypeTraits.hpp
+)
+
+elastica_target_sources(
+        ${LIBRARY}
+        INTERFACE
+        Component.hpp
+        GeometryComponent.hpp
+        KinematicsComponent.hpp
+        NameComponent.hpp
+        NameAdapter.hpp
+        Types.hpp
+        TypeTraits.hpp
+)
+
+target_link_libraries(
+        ${LIBRARY}
+        INTERFACE
+        Utilities
+)
diff --git a/backend/src/Systems/common/Components/Component.hpp b/backend/src/Systems/common/Components/Component.hpp
new file mode 100644
index 00000000..0af1f591
--- /dev/null
+++ b/backend/src/Systems/common/Components/Component.hpp
@@ -0,0 +1,51 @@
+#pragma once
+
+//******************************************************************************
+// Includes
+//******************************************************************************
+#include "Systems/common/Components/Types.hpp"
+
+namespace elastica {
+
+  //============================================================================
+  //
+  //  CLASS DEFINITION
+  //
+  //============================================================================
+
+  //****************************************************************************
+  /*!\brief Base class for all component templates.
+   * \ingroup systems
+   *
+   * \details
+   * The Component class is the base class for all component templates
+   * used in programming systems within \elastica. All classes that represent a
+   * component and that are used within the @ref blocks environment of \elastica
+   * library have to derive publicly from this class in order to qualify as a
+   * component.
+   *
+   * Only in case a class is derived publicly from the Component base
+   * class, the IsComponent type trait recognizes the class as valid
+   * component.
+   *
+   * \tparam DerivedComponent A downstream component that derives from
+   * the Component class using the CRTP pattern.
+   */
+  template <typename DerivedComponent>
+  struct Component;
+  //****************************************************************************
+
+  //****************************************************************************
+  /*! \cond ELASTICA_INTERNAL */
+  /*!\brief Specialized of Component for Cosserat Rod components
+   * \ingroup systems
+   */
+  template <template <typename, typename, typename...> class DerivedComponent,
+            typename Traits, typename InstantiatedBlock,
+            typename... DerivedComponentMetaArgs>
+  struct Component<DerivedComponent<Traits, InstantiatedBlock,
+                                    DerivedComponentMetaArgs...>> {};
+  /*! \endcond */
+  //****************************************************************************
+
+}  // namespace elastica
diff --git a/backend/src/Systems/common/Components/GeometryComponent.hpp b/backend/src/Systems/common/Components/GeometryComponent.hpp
new file mode 100644
index 00000000..dbb32474
--- /dev/null
+++ b/backend/src/Systems/common/Components/GeometryComponent.hpp
@@ -0,0 +1,45 @@
+#pragma once
+
+//******************************************************************************
+// Includes
+//******************************************************************************
+#include "Systems/common/Components/Types.hpp"
+//
+#include "Systems/common/Components/Component.hpp"
+
+namespace elastica {
+
+  //============================================================================
+  //
+  //  CLASS DEFINITION
+  //
+  //============================================================================
+
+  //****************************************************************************
+  /*!\brief Base class for all geometry components.
+   * \ingroup systems
+   *
+   * \details
+   * The Geometry component is the base class for all geometry components
+   * used in programming systems within \elastica. All classes that represent a
+   * geometry component and that are used within the @ref blocks environment of
+   * \elastica library have to derive publicly from this class in order to
+   * qualify as a component.
+   *
+   * Only in case a class is derived publicly from the Component base class, the
+   * IsComponent type trait recognizes the class as valid component.
+   *
+   * \tparam DerivedGeometryComponent A downstream component that derives from
+   * the Component class using the CRTP pattern.
+   */
+  template <typename DerivedGeometryComponent>
+  struct GeometryComponent : public Component<DerivedGeometryComponent> {
+    // for ease in programming, ideally we shouldnt need it
+    //**Type definitions********************************************************
+    //! Type of geometry component
+    using geometry_component = DerivedGeometryComponent;
+    //**************************************************************************
+  };
+  //****************************************************************************
+
+}  // namespace elastica
diff --git a/backend/src/Systems/common/Components/KinematicsComponent.hpp b/backend/src/Systems/common/Components/KinematicsComponent.hpp
new file mode 100644
index 00000000..8a094640
--- /dev/null
+++ b/backend/src/Systems/common/Components/KinematicsComponent.hpp
@@ -0,0 +1,44 @@
+#pragma once
+
+//******************************************************************************
+// Includes
+//******************************************************************************
+#include "Systems/common/Components/Types.hpp"
+//
+#include "Systems/common/Components/Component.hpp"
+
+namespace elastica {
+
+  //============================================================================
+  //
+  //  CLASS DEFINITION
+  //
+  //============================================================================
+
+  //****************************************************************************
+  /*!\brief Base class for all kinematics components.
+   * \ingroup systems
+   *
+   * \details
+   * The Kinematics component is the base class for all kinematics components
+   * used in programming systems within \elastica. All classes that represent a
+   * kinematics component and that are used within the @ref blocks environment
+   * of \elastica library have to derive publicly from this class in order to
+   * qualify as a component.
+   *
+   * Only in case a class is derived publicly from the Component base class, the
+   * IsComponent type trait recognizes the class as valid component.
+   *
+   * \tparam DerivedKinematicsComponent A downstream component that derives from
+   * the Component class using the CRTP pattern.
+   */
+  template <typename DerivedKinematicsComponent>
+  struct KinematicsComponent : public Component<DerivedKinematicsComponent> {
+    //**Type definitions********************************************************
+    //! Type of kinematics component
+    using kinematics_component = DerivedKinematicsComponent;
+    //**************************************************************************
+  };
+  //****************************************************************************
+
+}  // namespace elastica
diff --git a/backend/src/Systems/common/Components/NameAdapter.hpp b/backend/src/Systems/common/Components/NameAdapter.hpp
new file mode 100644
index 00000000..b360fe2c
--- /dev/null
+++ b/backend/src/Systems/common/Components/NameAdapter.hpp
@@ -0,0 +1,62 @@
+#pragma once
+
+//******************************************************************************
+// Includes
+//******************************************************************************
+
+#include "Systems/common/Components/NameComponent.hpp"
+//
+#include "Utilities/TMPL.hpp"
+
+namespace elastica {
+
+  namespace detail {
+
+    //==========================================================================
+    //
+    //  CLASS DEFINITION
+    //
+    //==========================================================================
+
+    //**************************************************************************
+    /*!\brief Provides a name to a System
+     * \ingroup systems
+     */
+    template <typename /* Traits */, typename /* Block */, typename NameImpl>
+    struct NameAdapter : public NameImpl {
+     protected:
+      //**Type definitions******************************************************
+      //! List of computed variables
+      using ComputedVariables = tmpl::list<>;
+      //! List of initialized variables
+      using InitializedVariables = tmpl::list<>;
+      //! List of all variables
+      using Variables = tmpl::list<>;
+      //************************************************************************
+
+      //************************************************************************
+      /*!\brief Initialize method for the current component
+       *
+       * \tparam DownstreamBlock The final block-like object which is
+       * derived from the current component
+       * \tparam CosseratInitializer An Initializer corresponding to the
+       * Cosserat rod hierarchy
+       */
+      template <typename DownstreamBlock, typename Initializer>
+      static void initialize(DownstreamBlock&, Initializer&&) noexcept {}
+      //************************************************************************
+
+     public:
+      //************************************************************************
+      /*!\brief Human-readable name of the current plugin and all derivates
+       *
+       * \note This is intended to work with pretty_type::name<>
+       */
+      using NameImpl::name;
+      //************************************************************************
+    };
+    //**************************************************************************
+
+  }  // namespace detail
+
+}  // namespace elastica
diff --git a/backend/src/Systems/common/Components/NameComponent.hpp b/backend/src/Systems/common/Components/NameComponent.hpp
new file mode 100644
index 00000000..5b6811ae
--- /dev/null
+++ b/backend/src/Systems/common/Components/NameComponent.hpp
@@ -0,0 +1,45 @@
+#pragma once
+
+//******************************************************************************
+// Includes
+//******************************************************************************
+#include "Systems/common/Components/Types.hpp"
+//
+#include "Systems/common/Components/Component.hpp"
+
+namespace elastica {
+
+  //============================================================================
+  //
+  //  CLASS DEFINITION
+  //
+  //============================================================================
+
+  //****************************************************************************
+  /*!\brief Base class for all name components.
+   * \ingroup systems
+   *
+   * \details
+   * The Name component is the base class for all name components
+   * used in programming systems within \elastica. All classes that represent a
+   * name component and that are used within the @ref blocks environment of
+   * \elastica library have to derive publicly from this class in order to
+   * qualify as a component.
+   *
+   * Only in case a class is derived publicly from the Component base class, the
+   * IsComponent type trait recognizes the class as valid component.
+   *
+   * \tparam DerivedNameComponent A downstream component that derives from
+   * the Component class using the CRTP pattern.
+   */
+  template <typename DerivedNameComponent>
+  struct NameComponent : public Component<DerivedNameComponent> {
+    // for ease in programming, ideally we shouldnt need it
+    //**Type definitions********************************************************
+    //! Type of name component
+    using name_component = DerivedNameComponent;
+    //**************************************************************************
+  };
+  //****************************************************************************
+
+}  // namespace elastica
diff --git a/backend/src/Systems/common/Components/TypeTraits.hpp b/backend/src/Systems/common/Components/TypeTraits.hpp
new file mode 100644
index 00000000..07328c29
--- /dev/null
+++ b/backend/src/Systems/common/Components/TypeTraits.hpp
@@ -0,0 +1,158 @@
+#pragma once
+
+//******************************************************************************
+// Includes
+//******************************************************************************
+#include "Utilities/TypeTraits/IsCRTP.hpp"
+#include "Utilities/TypeTraits/IsDetected.hpp"
+
+///
+#include "Systems/common/Components/Types.hpp"
+///
+#include "Systems/common/Components/Component.hpp"
+
+namespace elastica {
+
+  namespace tt {
+
+    //==========================================================================
+    //
+    //  CLASS DEFINITION
+    //
+    //==========================================================================
+
+    //**************************************************************************
+    /*!\brief Check whether a given type `C` is a valid Component
+     * \ingroup systems
+     *
+     * \details
+     * Inherits from std::true_type if `C` is a valid component template,
+     * deriving from Component, otherwise inherits from std::false_type.
+     *
+     * \usage
+     * For any type `C`,
+     * \code
+     * using result = IsComponent<C>;
+     * \endcode
+     *
+     * \metareturns
+     * cpp17::bool_constant
+     *
+     * \semantics
+     * If the type `C` is derived from Component<C>, then
+     * \code
+     * typename result::type = std::true_type;
+     * \endcode
+     * otherwise
+     * \code
+     * typename result::type = std::false_type;
+     * \endcode
+     *
+     * \example
+     * \snippet Test_Components.cpp is_component_example
+     *
+     * \tparam C : the type to check
+     *
+     * \see Component
+     */
+    template <typename C>
+    struct IsComponent : public ::tt::IsCRTP<::elastica::Component, C> {};
+    //**************************************************************************
+
+    //**************************************************************************
+    /*!\brief Check whether a given type `C` is a valid GeometryComponent
+     * \ingroup systems
+     *
+     * \details
+     * Inherits from std::true_type if `C` is a valid geometry component
+     * template, deriving from GeometryComponent, otherwise inherits from
+     * std::false_type.
+     *
+     * \usage
+     * For any type `C`,
+     * \code
+     * using result = IsGeometryComponent<C>;
+     * \endcode
+     *
+     * \metareturns
+     * cpp17::bool_constant
+     *
+     * \semantics
+     * If the type `C` is derived from GeometryComponent<C>, then
+     * \code
+     * typename result::type = std::true_type;
+     * \endcode
+     * otherwise
+     * \code
+     * typename result::type = std::false_type;
+     * \endcode
+     *
+     * \example
+     * \snippet Test_Components.cpp is_geometry_component_example
+     *
+     * \tparam C : the type to check
+     *
+     * \see GeometryComponent
+     */
+    template <typename C>
+    struct IsGeometryComponent
+        : public ::tt::IsCRTP<::elastica::GeometryComponent, C> {};
+    //**************************************************************************
+
+    //**************************************************************************
+    /*!\brief Check whether a given type `C` is a valid KinematicsComponent
+     * \ingroup systems
+     *
+     * \details
+     * Inherits from std::true_type if `C` is a valid kinematics component
+     * template, deriving from KinematicsComponent, otherwise inherits from
+     * std::false_type.
+     *
+     * \usage
+     * For any type `C`,
+     * \code
+     * using result = IsKinematicsComponent<C>;
+     * \endcode
+     *
+     * \metareturns
+     * cpp17::bool_constant
+     *
+     * \semantics
+     * If the type `C` is derived from KinematicsComponent<C>, then
+     * \code
+     * typename result::type = std::true_type;
+     * \endcode
+     * otherwise
+     * \code
+     * typename result::type = std::false_type;
+     * \endcode
+     *
+     * \example
+     * \snippet Test_Components.cpp is_kinematics_component_example
+     *
+     * \tparam C : the type to check
+     *
+     * \see KinematicsComponent
+     */
+    template <typename C>
+    struct IsKinematicsComponent
+        : public ::tt::IsCRTP<::elastica::KinematicsComponent, C> {};
+    //**************************************************************************
+
+    template <typename T>
+    using geometry_component_t = typename T::geometry_component;
+
+    template <typename T>
+    struct GeometryComponentTrait
+        : public ::tt::detected_or<NoSuchType, geometry_component_t, T> {};
+
+    template <typename T>
+    using kinematics_component_t = typename T::kinematics_component;
+
+    template <typename T>
+    struct KinematicsComponentTrait
+        : public ::tt::detected_or<NoSuchType, kinematics_component_t, T> {};
+
+  }  // namespace tt
+
+}  // namespace elastica
diff --git a/backend/src/Systems/common/IndexCheck.hpp b/backend/src/Systems/common/IndexCheck.hpp
new file mode 100644
index 00000000..76aa783f
--- /dev/null
+++ b/backend/src/Systems/common/IndexCheck.hpp
@@ -0,0 +1,64 @@
+#pragma once
+
+//******************************************************************************
+// Includes
+//******************************************************************************
+#include "Utilities/End.hpp"  // from_end
+//
+#include <cstddef>  // size_t
+#include <stdexcept>
+
+namespace elastica {
+
+  //============================================================================
+  //
+  //  ACCESS API FUNCTIONS
+  //
+  //============================================================================
+
+  // Defined in Access.hpp
+  struct AnyPhysicalSystem;
+
+  //**Index check functions*****************************************************
+  /*!\name Index check functions */
+  //@{
+  /*!\brief Checks that an index is valid for a system
+   * \ingroup systems
+   */
+  auto index_check(AnyPhysicalSystem& t, std::size_t index) -> std::size_t;
+  auto index_check(AnyPhysicalSystem& t, from_end index) -> std::size_t;
+  //@}
+  //****************************************************************************
+
+  //**Index check helpers*******************************************************
+  /*!\name Index check helpers */
+  //@{
+  /*!\brief Helpers to validate indices for a system
+   * \ingroup systems
+   */
+  inline auto index_check_helper(std::size_t max_index,
+                                 std::size_t index_to_be_sliced)
+      -> std::size_t {
+    if (index_to_be_sliced < max_index) {
+      return index_to_be_sliced;
+    } else {
+      throw std::out_of_range(
+          "Index to be sliced (from the start) exceeds the number of dofs!");
+    }
+  }
+
+  inline auto index_check_helper(std::size_t max_index,
+                                 elastica::from_end index_to_be_sliced)
+      -> std::size_t {
+    const auto fe = index_to_be_sliced.i;
+    if (fe <= max_index) {
+      return max_index - fe;
+    } else {
+      throw std::out_of_range(
+          "Index to be sliced (from the end) exceeds the number of dofs!");
+    }
+  }
+  //@}
+  //****************************************************************************
+
+}  // namespace elastica
diff --git a/backend/src/Systems/common/Initialization.hpp b/backend/src/Systems/common/Initialization.hpp
new file mode 100644
index 00000000..fac3add0
--- /dev/null
+++ b/backend/src/Systems/common/Initialization.hpp
@@ -0,0 +1,103 @@
+#pragma once
+
+//******************************************************************************
+// Includes
+//******************************************************************************
+
+#include "Systems/Block/Block.hpp"
+#include "Systems/Types.hpp"
+#include "Systems/common/Cardinality.hpp"
+#include "Systems/common/Tags.hpp"
+#include "Utilities/AsConst.hpp"
+#include "Utilities/TMPL.hpp"
+//
+#include <utility>  // forward
+
+namespace elastica {
+
+  //****************************************************************************
+  /*!\brief Generic component initializer for system with unit-cardinality.
+   * \ingroup systems
+   *
+   * \tparam Variables Typelist of `BlockVariables` to initialize
+   * \param block_like Data-structure conforming to the block concept.
+   * \param initializer Initializer object conforming to block initialization.
+   */
+  template <typename Variables, typename BlockLike, typename Initializer>
+  void initialize_component(BlockLike& block_like, Initializer&& initializer,
+                            UnitCardinality /*meta*/
+  ) {
+    struct {
+      Initializer value;
+    } cap{std::forward<Initializer>(initializer)};
+    // Note : need a mutable lambda as we can now "move" from cap
+    tmpl::for_each<Variables>([&block_like, &cap](auto v) mutable -> void {
+      using Variable = tmpl::type_from<decltype(v)>;
+      using Tag = blocks::initializer_t<Variable>;
+
+      // && since get() may be lazy and so can return either
+      // lvalue of rvalue reference.
+      auto&& variable(blocks::get<Tag>(block_like));
+      // We may not need a ref here as it will be moved, but keep it for
+      // symmetry.
+      auto&& variable_initializer(blocks::get<Tag>(std::move(cap.value)));
+      Variable::slice(variable, UnitCardinality::index()) = variable_initializer();
+    });
+  }
+  //****************************************************************************
+
+  //****************************************************************************
+  /*!\brief Generic component initializer for system with multiple-cardinality.
+   * \ingroup systems
+   *
+   * \tparam Variables Typelist of `BlockVariables` to initialize
+   * \param block_like Data-structure conforming to the block concept.
+   * \param initializer Initializer object conforming to block initialization.
+   */
+  template <typename Variables, typename BlockLike, typename Initializer>
+  void initialize_component(BlockLike& block_like, Initializer&& initializer,
+                            MultipleCardinality /*meta*/
+  ) {
+    // Note : need a mutable lambda as we can now "move" from cap
+    // Make a copy of the initializer as there is no guarantee to the number of
+    // times it will be called.
+    auto const n_elem =
+        blocks::get<::elastica::tags::NElement>(cpp17::as_const(initializer))();
+    struct {
+      Initializer value;
+    } cap{std::forward<Initializer>(initializer)};
+    tmpl::for_each<Variables>(
+        [n_elem, &block_like, &cap](auto v) mutable -> void {
+          using Variable = tmpl::type_from<decltype(v)>;
+          using Tag = blocks::initializer_t<Variable>;
+
+          // && since get() may be lazy and so can return either
+          // lvalue of rvalue reference.
+          auto&& variable(blocks::get<Tag>(block_like));
+          // We may not need a ref here as it will be moved, but keep
+          // it for symmetry.
+          auto&& variable_initializer(blocks::get<Tag>(std::move(cap.value)));
+
+          const auto dofs = Variable::get_dofs(n_elem);
+          for (std::size_t i = 0; i < dofs; ++i) {
+            // TODO : This doesn't work on slices, consider having the
+            // slice member in the variable_initializer itself
+            Variable::slice(variable, i) = variable_initializer(i);
+          }
+        });
+  }
+  //****************************************************************************
+
+  namespace detail {
+
+    template <typename Variables, typename BlockLike, typename Initializer>
+    inline void initialize_component(BlockLike& block_like,
+                                     Initializer&& initializer) {
+      initialize_component<Variables>(block_like,
+                                      std::forward<Initializer>(initializer),
+                                      typename BlockLike::cardinality{});
+    }
+
+  }  // namespace detail
+
+}  // namespace elastica
diff --git a/backend/src/Systems/common/Protocols.hpp b/backend/src/Systems/common/Protocols.hpp
new file mode 100644
index 00000000..27cb98b6
--- /dev/null
+++ b/backend/src/Systems/common/Protocols.hpp
@@ -0,0 +1,230 @@
+#pragma once
+
+//******************************************************************************
+// Includes
+//******************************************************************************
+#include <cstddef>  // std::size_t
+///
+#include "Systems/common/Access.hpp"
+#include "Systems/common/IndexCheck.hpp"
+///
+#include "Utilities/End.hpp"
+#include "Utilities/TypeTraits/Cpp17.hpp"
+#include "Utilities/TypeTraits/IsDetected.hpp"
+
+namespace elastica {
+
+  namespace protocols {
+
+    namespace detail {
+      using elastica::angular_velocity;
+      using elastica::director;
+      using elastica::external_loads;
+      using elastica::external_torques;
+      using elastica::index_check;
+      using elastica::position;
+      using elastica::velocity;
+
+      struct Signatures {
+        // [signatures]
+        using index = std::size_t;
+        using index_from_end = elastica::from_end;
+        template <typename ConformingType>
+        using index_check_from_start_result = decltype(index_check(
+            std::declval<ConformingType const&>(), std::declval<index>()));
+        template <typename ConformingType>
+        using index_check_from_end_result =
+            decltype(index_check(std::declval<ConformingType const&>(),
+                                 std::declval<index_from_end>()));
+        template <typename ConformingType>
+        using position_result =
+            decltype(position(std::declval<ConformingType&>()));
+        template <typename ConformingType>
+        using const_position_result =
+            decltype(position(std::declval<ConformingType const&>()));
+        template <typename ConformingType>
+        using director_result =
+            decltype(director(std::declval<ConformingType&>()));
+        template <typename ConformingType>
+        using const_director_result =
+            decltype(director(std::declval<ConformingType const&>()));
+        template <typename ConformingType>
+        using velocity_result =
+            decltype(velocity(std::declval<ConformingType&>()));
+        template <typename ConformingType>
+        using const_velocity_result =
+            decltype(velocity(std::declval<ConformingType const&>()));
+        template <typename ConformingType>
+        using angular_velocity_result =
+            decltype(angular_velocity(std::declval<ConformingType&>()));
+        template <typename ConformingType>
+        using const_angular_velocity_result =
+            decltype(angular_velocity(std::declval<ConformingType const&>()));
+        template <typename ConformingType>
+        using external_loads_result =
+            decltype(external_loads(std::declval<ConformingType&>()));
+        template <typename ConformingType>
+        using const_external_loads_result =
+            decltype(external_loads(std::declval<ConformingType const&>()));
+        template <typename ConformingType>
+        using external_torques_result =
+            decltype(external_torques(std::declval<ConformingType&>()));
+        template <typename ConformingType>
+        using const_external_torques_result =
+            decltype(external_torques(std::declval<ConformingType const&>()));
+        // [signatures]
+      };
+
+    }  // namespace detail
+
+    //==========================================================================
+    //
+    //  CLASS DEFINITION
+    //
+    //==========================================================================
+
+    //**************************************************************************
+    /*!\brief Protocol for (physical) Systems
+     * \ingroup systems
+     *
+     * Class to enforce adherence to a PhysicalSystems protocol. Any valid
+     * system within the \elastica library (such as a CosseratRod, RigidBody)
+     * should (publicly) inherit from this class to indicate it qualifies as a
+     * valid System. Only in case a class is derived publicly from
+     * this base class, the tt::conforms_to and tt::assert_conforms_to
+     * type traits recognizes the class as valid System .
+     *
+     * Requires that a conforming type `ConformingType` has these member
+     * functions
+     * \snippet this expected_functions
+     * and these free functions
+     * \snippet this signatures
+     *
+     * \example
+     * \snippet Systems/common/Test_Protocols.cpp systems_protocol_eg
+     */
+    struct PhysicalSystem {
+      //************************************************************************
+      /*! \cond ELASTICA_INTERNAL */
+      /*!\brief Auxiliary helper struct for enforcing protocols.
+       * \ingroup systems
+       */
+      template <typename ConformingType>
+      struct test {
+        /// [expected_types]
+        /// [expected_types]
+
+        /// [expected_functions]
+        /// [expected_functions]
+
+        /// [expected_free_functions]
+        using expected_return_type = std::size_t;
+
+        static_assert(
+            cpp17::is_same_v<detail::Signatures::index_check_from_start_result<
+                                 ConformingType>,
+                             expected_return_type>,
+            R"error(
+Not a conforming PhysicalSystem, doesn't have a free-function
+`std::size_t index_check(ConformingType const&, std::size_t index_from_start)`
+)error");
+        static_assert(
+            cpp17::is_same_v<
+                detail::Signatures::index_check_from_end_result<ConformingType>,
+                expected_return_type>,
+            R"error(
+Not a conforming PhysicalSystem, doesn't properly implement function
+`std::size_t index_check(ConformingType const&, elastica::from_end index_from_end)`
+)error");
+
+        static_assert(::tt::is_detected_v<detail::Signatures::position_result,
+                                          ConformingType>,
+                      R"error(
+Not a conforming PhysicalSystem, doesn't have a free-function
+`decltype(auto) ::elastica::position(ConformingType&) noexcept`
+)error");
+        static_assert(
+            ::tt::is_detected_v<detail::Signatures::const_position_result,
+                                ConformingType>,
+            R"error(
+Not a conforming PhysicalSystem, doesn't have a free-function
+`decltype(auto) ::elastica::position(ConformingType const&) noexcept`
+)error");
+        static_assert(::tt::is_detected_v<detail::Signatures::director_result,
+                                          ConformingType>,
+                      R"error(
+Not a conforming PhysicalSystem, doesn't have a free-function
+`decltype(auto) ::elastica::director(ConformingType&) noexcept`
+)error");
+        static_assert(
+            ::tt::is_detected_v<detail::Signatures::const_director_result,
+                                ConformingType>,
+            R"error(
+Not a conforming PhysicalSystem, doesn't have a free-function
+`decltype(auto) ::elastica::director(ConformingType const&) noexcept`
+)error");
+        static_assert(::tt::is_detected_v<detail::Signatures::velocity_result,
+                                          ConformingType>,
+                      R"error(
+Not a conforming PhysicalSystem, doesn't have a free-function
+`decltype(auto) ::elastica::velocity(ConformingType&) noexcept`
+)error");
+        static_assert(
+            ::tt::is_detected_v<detail::Signatures::const_velocity_result,
+                                ConformingType>,
+            R"error(
+Not a conforming PhysicalSystem, doesn't have a free-function
+`decltype(auto) ::elastica::velocity(ConformingType const&) noexcept`
+)error");
+        static_assert(
+            ::tt::is_detected_v<detail::Signatures::angular_velocity_result,
+                                ConformingType>,
+            R"error(
+Not a conforming PhysicalSystem, doesn't have a free-function
+`decltype(auto) ::elastica::angular_velocity(ConformingType&) noexcept`
+)error");
+        static_assert(::tt::is_detected_v<
+                          detail::Signatures::const_angular_velocity_result,
+                          ConformingType>,
+                      R"error(
+Not a conforming PhysicalSystem, doesn't have a free-function
+`decltype(auto) ::elastica::angular_velocity(ConformingType const&) noexcept`
+)error");
+        static_assert(
+            ::tt::is_detected_v<detail::Signatures::external_loads_result,
+                                ConformingType>,
+            R"error(
+Not a conforming PhysicalSystem, doesn't have a free-function
+`decltype(auto) ::elastica::external_loads(ConformingType&) noexcept`
+)error");
+        static_assert(
+            ::tt::is_detected_v<detail::Signatures::const_external_loads_result,
+                                ConformingType>,
+            R"error(
+Not a conforming PhysicalSystem, doesn't have a free-function
+`decltype(auto) ::elastica::external_loads(ConformingType const&) noexcept`
+)error");
+        static_assert(
+            ::tt::is_detected_v<detail::Signatures::external_torques_result,
+                                ConformingType>,
+            R"error(
+Not a conforming PhysicalSystem, doesn't have a free-function
+`decltype(auto) ::elastica::external_torques(ConformingType&) noexcept`
+)error");
+        static_assert(::tt::is_detected_v<
+                          detail::Signatures::const_external_torques_result,
+                          ConformingType>,
+                      R"error(
+Not a conforming PhysicalSystem, doesn't have a free-function
+`decltype(auto) ::elastica::external_torques(ConformingType const&) noexcept`
+)error");
+        /// [expected_free_functions]
+      };
+      /*! \endcond */
+      //************************************************************************
+    };
+    //**************************************************************************
+
+  }  // namespace protocols
+
+}  // namespace elastica
diff --git a/backend/src/Systems/common/Python/CMakeLists.txt b/backend/src/Systems/common/Python/CMakeLists.txt
new file mode 100644
index 00000000..f3bfa5f3
--- /dev/null
+++ b/backend/src/Systems/common/Python/CMakeLists.txt
@@ -0,0 +1,4 @@
+# Distributed under the MIT License.
+# See LICENSE.txt for details.
+
+add_subdirectory(Generators)
diff --git a/backend/src/Systems/common/Python/Generators/BindMemberAccess.hpp b/backend/src/Systems/common/Python/Generators/BindMemberAccess.hpp
new file mode 100644
index 00000000..4f0abf75
--- /dev/null
+++ b/backend/src/Systems/common/Python/Generators/BindMemberAccess.hpp
@@ -0,0 +1,136 @@
+#pragma once
+
+//******************************************************************************
+// Includes
+//******************************************************************************
+//
+#include "Systems/Block/Block.hpp"
+#include "Systems/Block/TypeTraits.hpp"
+//
+// TODO : refactor rank, and traits should belong to systems common
+#include "Systems/CosseratRods/Traits/DataType/Rank.hpp"
+//
+#include "Systems/CosseratRods/common/Generators/BoundChecks.hpp"
+#include "Systems/CosseratRods/common/Generators/VariableFilter.hpp"
+//
+#include "Utilities/ConvertCase/ConvertCase.hpp"
+#include "Utilities/IgnoreUnused.hpp"
+#include "Utilities/MakeString.hpp"
+#include "Utilities/Overloader.hpp"
+#include "Utilities/PrettyType.hpp"
+#include "Utilities/TMPL.hpp"
+//
+#include <pybind11/pybind11.h>
+//
+#include <string>
+
+namespace py_bindings {
+
+  namespace detail {
+    // TODO : concept check?
+    template <typename UnwantedVariableTags, typename ModelsBlock>
+    void bind_member_access(pybind11::class_<ModelsBlock>& system) {
+      using type = ModelsBlock;
+      using Variables = ::blocks::variables_t<type>;
+      using VariablesToBeBound = tmpl::remove_if<
+          Variables,
+          tmpl::bind<tt::VariableFilter<UnwantedVariableTags>::template type,
+                     tmpl::_1>>;
+
+      using ::elastica::cosserat_system::Rank;
+      auto rank_doc_generator = make_overloader(
+          [](Rank<1U> /*scalar*/) -> std::string { return "1D"; },
+          [](Rank<2U> /*vector*/) -> std::string { return "2D"; },
+          [](Rank<3U> /*tensor*/) -> std::string { return "3D"; });
+
+      auto dim_doc_generator = make_overloader(
+          [](Rank<1U> /*scalar*/) -> std::string { return ""; },
+          [](Rank<2U> /*vector*/) -> std::string { return "3, "; },
+          [](Rank<3U> /*tensor*/) -> std::string { return "3, 3, "; });
+
+      // __getitem__ and __setitem__ are the subscript operators (M[*,*]).
+      tmpl::for_each<VariablesToBeBound>([=, &system](auto v) {
+        namespace cc = convert_case;
+        using Variable = tmpl::type_from<decltype(v)>;
+        using VariableTag = ::blocks::parameter_t<Variable>;
+        using VariableRank = ::blocks::rank_t<Variable>;
+        // system, node, element, voronoi
+        using VariableStagger = typename Variable::Stagger;
+        // Rank in case of a CosseratRod is Vector, Matrix, or Tensor, each of
+        // which has a rank type-def, which we query
+
+        std::string variable_name = pretty_type::short_name<Variable>();
+        // cam use
+        std::string tag_name = pretty_type::get_name<VariableTag>();
+        std::string method_prefix = "get_";
+        std::string method_name =
+            method_prefix +
+            cc::convert(variable_name, cc::FromPascalCase{}, cc::ToSnakeCase{});
+
+        /*
+         * Generate a docstring with the format:
+         *
+         * Gets the variable corresponding to the C++ tag
+         * ::elastica::tags::AngularAcceleration. Returns a 2D (3, ) array
+         * containing data of double type. See documentation of
+         * AngularAcceleration for more details.
+         */
+        std::string method_doc =
+            (MakeString{} << "Gets the variable corresponding to the C++ tag "
+                          << tag_name << ". Returns a "
+                          << rank_doc_generator(typename VariableRank::rank{})
+                          // clang-format off
+                              << " (" << dim_doc_generator(typename VariableRank::rank{}) << ") "
+                          // clang-format on
+                          << "array containing data of "
+                          << pretty_type::short_name<::elastica::real_t>()
+                          << " type. See documentation of " << tag_name
+                          << " for more details.");
+
+        system.def(
+            method_name.c_str(),
+            +[](type& self) {
+              // roundabout
+              return ::blocks::get<VariableTag>(self);
+            },
+            method_doc.c_str());
+      });
+    }
+
+  }  // namespace detail
+
+  //****************************************************************************
+  /*!\brief Helps bind accessors to a CosseratRod in \elastica
+   * \ingroup python_bindings
+   *
+   * \details
+   * Binds member functions to access system members.The convention for the
+   * member function is `get_{name}` where `{name}` is the
+   * tag name in small letters. For example, to access the variable
+   * elastica::tags::Position above, you can invoke the `get_position()` member
+   * function from Python.
+   *
+   * \tparam UnwantedVariableTags Tags that should not be bound/exposed to the
+   * python side
+   * \param a Pybind11 class of a CosseratRod
+   */
+  template <typename UnwantedVariableTags, typename Plugin>
+  void bind_member_access(
+      pybind11::class_<::blocks::BlockSlice<Plugin>>& system) {  // NOLINT
+    detail::bind_member_access<UnwantedVariableTags>(system);
+  }
+  //****************************************************************************
+
+  //****************************************************************************
+  /*!\brief Helps bind accessors to a system block in \elastica
+   * \ingroup python_bindings
+   * \see bind_member_access
+   */
+  template <typename UnwantedVariableTags, typename Plugin>
+  void bind_member_access(
+      pybind11::class_<::blocks::Block<Plugin>>& system) {  // NOLINT
+    detail::bind_member_access<UnwantedVariableTags>(system);
+  }
+  //****************************************************************************
+
+}  // namespace py_bindings
diff --git a/backend/src/Systems/common/Python/Generators/BindVariableLocator.hpp b/backend/src/Systems/common/Python/Generators/BindVariableLocator.hpp
new file mode 100644
index 00000000..b54a8454
--- /dev/null
+++ b/backend/src/Systems/common/Python/Generators/BindVariableLocator.hpp
@@ -0,0 +1,164 @@
+#pragma once
+
+//******************************************************************************
+// Includes
+//******************************************************************************
+//
+#include "Systems/Block/TypeTraits.hpp"
+//
+#include "Systems/common/Python/Generators/VariableFilter.hpp"
+#include "Systems/common/Python/Generators/VariableLocator.hpp"
+//
+#include "Utilities/PrettyType.hpp"
+//
+#include <pybind11/pybind11.h>
+//
+#include <type_traits>
+
+namespace py_bindings {
+
+  //****************************************************************************
+  /*! \cond ELASTICA_INTERNAL */
+  // TODO : concept check?
+  template <typename UnwantedVariableTags>
+  struct BindVariableLocator {
+    using This = BindVariableLocator<UnwantedVariableTags>;
+
+    template <typename ModelsBlock>
+    static void bind_variable_tags_as_property(
+        pybind11::class_<ModelsBlock>& context) {
+      using Arg = std::remove_reference_t<decltype(context)>;
+      using type = typename Arg::type;
+
+      using Variables = ::blocks::variables_t<type>;
+      using VariablesToBeBound = tmpl::remove_if<
+          Variables,
+          tmpl::bind<tt::VariableFilter<UnwantedVariableTags>::template type,
+                     tmpl::_1>>;
+
+      namespace py = pybind11;
+
+      // the tags are registered globally in the systems.tags module
+      auto register_property = [](auto& bound_class_, auto tag) {
+        using VariableTag = decltype(tag);
+        std::string tag_name = pretty_type::short_name<VariableTag>();
+        bound_class_.def_property_readonly_static(
+            tag_name.c_str(),
+            [](py::object /* self */) { return VariableTag{}; });
+      };
+
+      // first define variables as a read only property for named evaluation
+      tmpl::for_each<VariablesToBeBound>([=, &context](auto v) {
+        using Variable = tmpl::type_from<decltype(v)>;
+        using VariableTag = ::blocks::parameter_t<Variable>;
+        register_property(context, VariableTag{});
+      });
+    }
+
+    template <typename ModelsBlock>
+    static void bind_locator(pybind11::class_<ModelsBlock>& context) {
+      using Arg = std::remove_reference_t<decltype(context)>;
+      using type = typename Arg::type;
+      using Locator = VariableLocator<type>;
+
+      using Variables = ::blocks::variables_t<type>;
+      using VariablesToBeBound = tmpl::remove_if<
+          Variables,
+          tmpl::bind<tt::VariableFilter<UnwantedVariableTags>::template type,
+                     tmpl::_1>>;
+
+      namespace py = pybind11;
+
+      // Define getters and setters for loc_indexer
+      auto indexer = py::class_<Locator>(context, "VariableLocator");
+
+      indexer
+          .def(
+              "__str__", +[](Locator const&) { return "Variable indexer"; })
+          .def(
+              "__repr__", +[](Locator const&) { return "Variable indexer"; });
+
+      // first define variables as a read only property for named evaluation
+      tmpl::for_each<VariablesToBeBound>([&indexer](auto v) {
+        using Variable = tmpl::type_from<decltype(v)>;
+        using VariableTag = ::blocks::parameter_t<Variable>;
+
+        indexer
+            .def(
+                "__getitem__",
+                +[](Locator& t, VariableTag /*meta*/) {
+                  return ::blocks::get<VariableTag>(t.data());
+                },
+                py::arg("tag"))
+            .def(
+                "__setitem__", +[](Locator& t, VariableTag /*meta*/,
+                                   typename Variable::type value) {
+                  ::blocks::get<VariableTag>(t.data()) = value;
+                });
+      });
+
+      constexpr const char* variable_loc_doc = R"doc(
+Access a variable by its tag. Similar in utility to pandas.DataFrame.loc from
+the pandas module. Allowed tags are accessed from the context.
+)doc";
+
+      // Loc indexer is bound to class as a loc[] method
+      context.def_property_readonly(
+          "loc", [](type& self) { return Locator{self}; }, variable_loc_doc,
+          // Keep object alive while indexer exists
+          py::keep_alive<0, 1>());
+    }
+
+    template <typename ModelsBlock>
+    static void apply(pybind11::class_<ModelsBlock>& system) {
+      This::bind_variable_tags_as_property(system);
+      This::bind_locator(system);
+    }
+  };
+  //****************************************************************************
+
+  //****************************************************************************
+  /*!\brief Helps bind tags to a CosseratRod in \elastica
+   * \ingroup python_bindings
+   *
+   * \details
+   * Tags are bound as static properties and can be used to obtain member
+   * functions using the `loc` method, similar to pandas. The typical use is
+   * to process multiple data-members simultaneously
+   *
+   * \tparam UnwantedVariableTags Tags that should not be bound/exposed to the
+   * python side
+   * \param a Pybind11 class of a CosseratRod
+   */
+  template <typename UnwantedVariableTags, typename Plugin>
+  void bind_variable_locator(
+      pybind11::class_<::blocks::BlockSlice<Plugin>>& system) {
+    BindVariableLocator<UnwantedVariableTags>::apply(system);
+  }
+  //****************************************************************************
+
+  //****************************************************************************
+  /*!\brief Helps bind tags to a system BlockView in \elastica
+   * \ingroup python_bindings
+   * \see bind_variable_locator
+   */
+  template <typename UnwantedVariableTags, typename Plugin>
+  void bind_variable_locator(
+      pybind11::class_<::blocks::BlockView<Plugin>>& system) {
+    BindVariableLocator<UnwantedVariableTags>::apply(system);
+  }
+  //****************************************************************************
+
+  //****************************************************************************
+  /*!\brief Helps bind tags to a system block in \elastica
+   * \ingroup python_bindings
+   * \see bind_variable_locator
+   */
+  template <typename UnwantedVariableTags, typename Plugin>
+  void bind_variable_locator(
+      pybind11::class_<::blocks::Block<Plugin>>& system) {
+    BindVariableLocator<UnwantedVariableTags>::apply(system);
+  }
+  //****************************************************************************
+
+}  // namespace py_bindings
diff --git a/backend/src/Systems/common/Python/Generators/CMakeLists.txt b/backend/src/Systems/common/Python/Generators/CMakeLists.txt
new file mode 100644
index 00000000..9acaa3e2
--- /dev/null
+++ b/backend/src/Systems/common/Python/Generators/CMakeLists.txt
@@ -0,0 +1,34 @@
+# Distributed under the MIT License.
+# See LICENSE.txt for details.
+
+set(LIBRARY "PySystemsCommon")
+
+add_elastica_library(${LIBRARY} INTERFACE)
+
+elastica_target_headers(
+        ${LIBRARY}
+        INCLUDE_DIRECTORY ${CMAKE_SOURCE_DIR}
+        BindVariableLocator.hpp
+        BindMemberAccess.hpp
+        BoundChecks.hpp
+        VariableFilter.hpp
+        VariableLocator.hpp
+)
+
+elastica_target_sources(
+        ${LIBRARY}
+        INTERFACE
+        BindVariableLocator.hpp
+        BindMemberAccess.hpp
+        VariableFilter.hpp
+        VariableLocator.hpp
+)
+
+# this library is needed only if bindings are built
+elastica_python_link_libraries(
+        ${LIBRARY}
+        INTERFACE
+        Utilities
+        ConvertCase #
+        pybind11::module
+)
diff --git a/backend/src/Systems/common/Python/Generators/VariableFilter.hpp b/backend/src/Systems/common/Python/Generators/VariableFilter.hpp
new file mode 100644
index 00000000..ec23d793
--- /dev/null
+++ b/backend/src/Systems/common/Python/Generators/VariableFilter.hpp
@@ -0,0 +1,32 @@
+#pragma once
+
+//******************************************************************************
+// Includes
+//******************************************************************************
+#include "Systems/Block/TypeTraits.hpp"
+#include "Utilities/TMPL.hpp"
+//
+#include <type_traits>
+
+namespace py_bindings {
+
+  namespace tt {
+
+    //**************************************************************************
+    /*!\brief Filters out variables based on UnwantedVariableTags
+     * \ingroup python_bindings
+     *
+     * \tparam UnwantedVariableTags Tags that should not be bound/exposed to the
+     * python side
+     */
+    template <typename UnwantedVariableTags>
+    struct VariableFilter {
+      template <typename T>
+      using type = tmpl::any<UnwantedVariableTags,
+                             std::is_same<tmpl::_1, ::blocks::parameter_t<T>>>;
+    };
+    //**************************************************************************
+
+  }  // namespace tt
+
+}  // namespace py_bindings
diff --git a/backend/src/Systems/common/Python/Generators/VariableLocator.hpp b/backend/src/Systems/common/Python/Generators/VariableLocator.hpp
new file mode 100644
index 00000000..271475dc
--- /dev/null
+++ b/backend/src/Systems/common/Python/Generators/VariableLocator.hpp
@@ -0,0 +1,18 @@
+#pragma once
+
+//******************************************************************************
+// Includes
+//******************************************************************************
+#include <pybind11/pybind11.h>
+//
+
+namespace py_bindings {
+
+  template <typename T>
+  struct VariableLocator {
+    constexpr auto data() & noexcept -> T& { return item_; }
+    constexpr auto data() const& noexcept -> T const& { return item_; }
+    T& item_;
+  };
+
+}  // namespace py_bindings
diff --git a/backend/src/Systems/common/SymplecticStepperAdapter.hpp b/backend/src/Systems/common/SymplecticStepperAdapter.hpp
new file mode 100644
index 00000000..089bdcc4
--- /dev/null
+++ b/backend/src/Systems/common/SymplecticStepperAdapter.hpp
@@ -0,0 +1,384 @@
+#pragma once
+
+#include <type_traits>
+
+//
+#include "Systems/Block/Block/TypeTraits.hpp"
+#include "Systems/States/States.hpp"
+#include "Systems/common/Tags.hpp"
+#include "Systems/common/Types.hpp"
+//
+#include "Time/SimulationTime.hpp"
+//
+#include "Utilities/TMPL.hpp"
+
+namespace elastica {
+
+  //============================================================================
+  //
+  //  CLASS DEFINITION
+  //
+  //============================================================================
+
+  namespace detail {
+
+    template <typename... X>
+    struct Inherit : public X... {
+      //**Block type definitions************************************************
+      //! List of computed variables
+      using ComputedVariables = tmpl::append<typename X::ComputedVariables...>;
+      //! List of initialized variables
+      using InitializedVariables =
+          tmpl::append<typename X::InitializedVariables...>;
+      //! List of all variables
+      using Variables = tmpl::append<typename X::Variables...>;
+      //************************************************************************
+
+      template <class DownstreamBlock, class SystemInitializer>
+      static void initialize(DownstreamBlock& downstream_block,
+                             SystemInitializer&& initializers) {
+        EXPAND_PACK_LEFT_TO_RIGHT(X::initialize(
+            downstream_block, std::forward<SystemInitializer>(initializers)));
+      }
+    };
+
+    struct DataCache {
+      template <typename Var>
+      struct AsCachedVariable {
+        using type = std::add_lvalue_reference_t<typename Var::type>;
+        using data_type = typename Var::type;
+      };
+    };
+    struct ViewCache {
+      template <typename Var>
+      struct AsCachedVariable {
+        using type = typename Var::SliceType::type;
+        using data_type = type;
+      };
+    };
+    struct ConstViewCache {
+      template <typename Var>
+      struct AsCachedVariable {
+        using type = typename Var::ConstSliceType::type;
+        using data_type = type;
+      };
+    };
+
+    template <typename CacheType>
+    struct Wrapped : public CacheType {
+      template <typename Var>
+      struct ToCachedVariable {
+        using type = typename CacheType::template AsCachedVariable<Var>;
+      };
+    };
+
+    template <typename B>
+    using ChooseCacheView =
+        std::conditional_t<::blocks::IsBlockSlice<B>::value ||
+                               ::blocks::IsBlockView<B>::value,
+                           ViewCache, ConstViewCache>;
+
+    // The state mechanism relies on pointer semantics, so a pointer to a valid
+    // address is necessary. This conflicts with the lazy slicing mechanism
+    // used in block slices and views. To WAR this, we store the data here as
+    // 1. Lvalue References in case of a block (which returns lvalue references
+    // via get())
+    // 2. Values in case of block slice/views (which returns rvalue references)
+    // And use this cache store address to refer into the states mechanism.
+    // It's a somewhat long-winded solution, but it has the benefit of not
+    // modifying any state/SE3/SO3-logic.
+
+    // TODO : can be optimized and refactored
+    template <typename B>
+    using ChooseCache =
+        Wrapped<std::conditional_t<::blocks::IsBlock<B>::value, DataCache,
+                                   ChooseCacheView<B>>>;
+
+  }  // namespace detail
+
+  //****************************************************************************
+  /*!\brief Adapter for enabling symplectic temporal integration
+   * \ingroup systems
+   *
+   * \details
+   * Adapter for system block hierarchies (i.e. conforming to
+   * protocols::PhysicalSystem) to interface with symplectic time integrators
+   * steppers
+   *
+   * \tparam BlockCache The block (along with data)
+   *
+   * \example
+   * \snippet Test_SymplecticStepperAdapter.cpp
+   */
+  template <typename Traits, typename BlockLike,
+            template <typename, typename> class... OtherComponents>
+  class SymplecticPolicy
+      : public detail::Inherit<OtherComponents<Traits, BlockLike>...> {
+   private:
+    //**Type definitions********************************************************
+    //! Parent type
+    using P = detail::Inherit<OtherComponents<Traits, BlockLike>...>;
+    //! This type
+    using This = SymplecticPolicy<Traits, BlockLike, OtherComponents...>;
+    //**************************************************************************
+
+   private:
+    //**************************************************************************
+    // CRTP section
+    // \note : cant use CRTP helper because it does not expect template
+    // template parameters
+    //! Type of the bottom level derived class
+    using Self = BlockLike;
+    //! Reference type of the bottom level derived class
+    using Reference = Self&;
+    //! const reference type of the bottom level derived class
+    using ConstReference = Self const&;
+    //**************************************************************************
+
+   protected:
+    //**Type definitions********************************************************
+    //! List of computed variables
+    using typename P::ComputedVariables;
+    //! List of initialized variables
+    using typename P::InitializedVariables;
+    //! List of all variables
+    using typename P::Variables;
+    //**************************************************************************
+
+    //**************************************************************************
+    /*!\name Variable data */
+    //@{
+    using typename P::Acceleration;
+    using typename P::AngularAcceleration;
+    using typename P::AngularVelocity;
+    using typename P::Director;
+    using typename P::Position;
+    using typename P::Velocity;
+    //@}
+    //**************************************************************************
+
+   private:
+    //**************************************************************************
+    /*!\name State types */
+    //@{
+    using CacheChoice = detail::ChooseCache<BlockLike>;
+    using StateVariables =
+        tmpl::list<Position, Velocity, Acceleration, Director, AngularVelocity,
+                   AngularAcceleration>;
+
+    using CachedData = tmpl::as_tagged_tuple<tmpl::transform<
+        StateVariables,
+        typename CacheChoice::template ToCachedVariable<tmpl::_1>>>;
+
+    using PositionData =
+        typename CacheChoice::template AsCachedVariable<Position>::data_type;
+    // std::remove_reference_t<decltype(std::declval<P>().get_position())>;
+    using PositionState =
+        ::elastica::states::SE3<PositionData,
+                                ::elastica::states::tags::PrimitiveTag>;
+    using VelocityData =
+        typename CacheChoice::template AsCachedVariable<Velocity>::data_type;
+    using VelocityState =
+        ::elastica::states::SE3<VelocityData,
+                                ::elastica::states::tags::DerivativeTag>;
+    using AccelerationData = typename CacheChoice::template AsCachedVariable<
+        Acceleration>::data_type;
+    using AccelerationState =
+        ::elastica::states::SE3<AccelerationData,
+                                ::elastica::states::tags::DoubleDerivativeTag>;
+
+    using DirectorData =
+        typename CacheChoice::template AsCachedVariable<Director>::data_type;
+    using DirectorState =
+        ::elastica::states::SO3<DirectorData,
+                                ::elastica::states::tags::PrimitiveTag>;
+    using AngularVelocityData = typename CacheChoice::template AsCachedVariable<
+        AngularVelocity>::data_type;
+    using AngularVelocityState =
+        ::elastica::states::SO3<AngularVelocityData,
+                                ::elastica::states::tags::DerivativeTag>;
+
+    using AngularAccelerationData =
+        typename CacheChoice::template AsCachedVariable<
+            AngularAcceleration>::data_type;
+    using AngularAccelerationState =
+        ::elastica::states::SO3<AngularAccelerationData,
+                                ::elastica::states::tags::DoubleDerivativeTag>;
+
+    //! Collection of all kinematic states
+    using KinematicState =
+        ::elastica::states::States<PositionState, DirectorState>;
+    //! Collection of all dynamic states
+    using DynamicState =
+        ::elastica::states::States<VelocityState, AngularVelocityState>;
+    //! Collection of all dynamic rates
+    using DynamicRate =
+        ::elastica::states::States<AccelerationState, AngularAccelerationState>;
+
+    //@}
+    //**************************************************************************
+
+   protected:
+    template <typename... Vars>
+    static auto fill(Reference ref,
+                     tmpl::list<Vars...> = StateVariables{}) noexcept {
+      return CachedData(::blocks::get<::blocks::parameter_t<Vars>>(ref)...);
+    }
+
+    template <typename Var>
+    inline constexpr decltype(auto) get_cached_variable() & noexcept {
+      return tuples::get<typename CacheChoice::template AsCachedVariable<Var>>(
+          cached_data_);
+    }
+
+    template <typename Var>
+    inline constexpr decltype(auto) get_cached_variable() const& noexcept {
+      return tuples::get<typename CacheChoice::template AsCachedVariable<Var>>(
+          cached_data_);
+    }
+
+    static auto initialize_kinematic_states(This& dis) {
+      return KinematicState(
+          PositionState(&dis.template get_cached_variable<Position>()),
+          DirectorState(&dis.template get_cached_variable<Director>()));
+    }
+
+    static auto initialize_dynamic_states(This& dis) {
+      return DynamicState(
+          VelocityState(&dis.template get_cached_variable<Velocity>()),
+          AngularVelocityState(
+              &dis.template get_cached_variable<AngularVelocity>()));
+    }
+
+    static auto initialize_dynamic_rates(This& dis) {
+      return DynamicRate(
+          AccelerationState(&dis.template get_cached_variable<Acceleration>()),
+          AngularAccelerationState(
+              &dis.template get_cached_variable<AngularAcceleration>()));
+    }
+
+    SymplecticPolicy()
+        : P(),
+          cached_data_(fill(self(), StateVariables{})),
+          kinematic_states_(initialize_kinematic_states(*this)),
+          dynamic_states_(initialize_dynamic_states(*this)),
+          dynamic_rates_(initialize_dynamic_rates(*this)) {}
+
+    SymplecticPolicy(SymplecticPolicy const& other)
+        : P(other),
+          cached_data_(fill(self(), StateVariables{})),
+          kinematic_states_(initialize_kinematic_states(*this)),
+          dynamic_states_(initialize_dynamic_states(*this)),
+          dynamic_rates_(initialize_dynamic_rates(*this)) {}
+
+    SymplecticPolicy(SymplecticPolicy&& other) noexcept
+        : P(std::move(other)),
+          cached_data_(fill(self(), StateVariables{})),
+          kinematic_states_(initialize_kinematic_states(*this)),
+          dynamic_states_(initialize_dynamic_states(*this)),
+          dynamic_rates_(initialize_dynamic_rates(*this)) {}
+
+   public:
+    //**************************************************************************
+    /*!\name CRTP methods */
+    //@{
+
+    //**Self method*************************************************************
+    /*!\brief Access to the underlying derived
+     *
+     * \return Mutable reference to the underlying derived
+     *
+     * Safely down-casts this module to the underlying derived type, using
+     * the Curiously Recurring Template Pattern (CRTP).
+     */
+    inline constexpr auto self() & noexcept -> Reference {
+      return static_cast<Reference>(*this);
+    }
+    //**************************************************************************
+
+    //**Self method*************************************************************
+    /*!\brief Access to the underlying derived
+     *
+     * \return Const reference to the underlying derived
+     *
+     * Safely down-casts this module to the underlying derived type, using
+     * the Curiously Recurring Template Pattern (CRTP).
+     */
+    inline constexpr auto self() const& noexcept -> ConstReference {
+      return static_cast<ConstReference>(*this);
+    }
+    //**************************************************************************
+
+    //@}
+    //**************************************************************************
+
+   public:
+    // Do not need const overloads : const here should be a hard compile error
+    //**************************************************************************
+    /*!\name State functions */
+    //@{
+
+    //**************************************************************************
+    /*!\brief Access to kinematic states
+     */
+    inline auto kinematic_states() & noexcept -> KinematicState& {
+      return kinematic_states_;
+    }
+    //**************************************************************************
+
+    //**************************************************************************
+    /*!\brief Access to kinematic rates
+     */
+    inline auto kinematic_rates(::elastica::Time /*time_v*/) const noexcept
+        -> DynamicState const& {
+      return dynamic_states();
+    }
+    //**************************************************************************
+
+    //**************************************************************************
+    /*!\brief Access to dynamic states
+     */
+    inline auto dynamic_states() & noexcept -> DynamicState& {
+      return dynamic_states_;
+    }
+    //**************************************************************************
+
+    //**************************************************************************
+    /*!\brief Access to immutable dynamic states
+     */
+    inline auto dynamic_states() const& noexcept -> DynamicState const& {
+      return dynamic_states_;
+    }
+    //**************************************************************************
+
+    //**************************************************************************
+    /*!\brief Access to dynamic rates
+     */
+    inline auto dynamic_rates(::elastica::Time /*time_v*/) /*const*/ noexcept(
+        noexcept(update_acceleration(self()))) -> DynamicRate const& {
+      /* To be truly lazy, one should only compute acceleration
+       * data and internal dynamics here.
+       * but the cosserat rods need precomputing to account
+       * for environment effects etc. so we can skip that here
+       */
+      update_acceleration(self());
+      return dynamic_rates_;
+    }
+    //**************************************************************************
+
+    //@}
+    //**************************************************************************
+
+   private:
+    //! Cache information of the system to populate the states below.
+    CachedData cached_data_;
+    //! Kinematic state information of the system.
+    KinematicState kinematic_states_;
+    //! Dynamic state information of the system.
+    DynamicState dynamic_states_;
+    //! Dynamic rate information of the system.
+    DynamicRate dynamic_rates_;
+  };
+  //****************************************************************************
+
+}  // namespace elastica
diff --git a/backend/src/Systems/common/Warnings/CMakeLists.txt b/backend/src/Systems/common/Warnings/CMakeLists.txt
new file mode 100644
index 00000000..84fe1d24
--- /dev/null
+++ b/backend/src/Systems/common/Warnings/CMakeLists.txt
@@ -0,0 +1,25 @@
+# Distributed under the MIT License. See LICENSE.txt for details.
+
+set(LIBRARY SystemsWarnings)
+
+add_elastica_library(${LIBRARY} INTERFACE)
+
+elastica_target_headers(
+        ${LIBRARY}
+        INCLUDE_DIRECTORY ${CMAKE_SOURCE_DIR}
+        HEADERS
+        UserWarnings.hpp
+)
+
+elastica_target_sources(
+        ${LIBRARY}
+        INTERFACE
+        UserWarnings.hpp
+)
+
+target_link_libraries(
+        ${LIBRARY}
+        INTERFACE
+        Utilities
+        ModuleSettings
+)
diff --git a/backend/src/Systems/common/Warnings/UserWarnings.hpp b/backend/src/Systems/common/Warnings/UserWarnings.hpp
new file mode 100644
index 00000000..c4386b2b
--- /dev/null
+++ b/backend/src/Systems/common/Warnings/UserWarnings.hpp
@@ -0,0 +1,34 @@
+#pragma once
+
+#include <iostream>
+#include <string>
+
+#include "ModuleSettings/Systems.hpp"
+
+namespace elastica {
+
+  //============================================================================
+  //
+  //  CLASS DEFINITION
+  //
+  //============================================================================
+
+  //****************************************************************************
+  /*! \cond ELASTICA_INTERNAL */
+  template <typename Crit, typename PrintTo>
+  void systems_warning_if(Crit crit, PrintTo print_to) {
+    if (detail::systems_warnings_enabled() and crit()) {
+      std::cerr << "[Systems Warning] ";
+      print_to(std::cerr);
+      std::cerr << "\n"
+                << "To disable this warning, you can set the environment "
+                   "variable "
+                << ENV_ELASTICA_NO_SYSTEM_WARN << " to 1" << std::endl;
+      // Flush the buffer to print the entire message when used from the python
+      // side
+    }
+  }
+  /*! \endcond */
+  //****************************************************************************
+
+}  // namespace elastica