diff --git a/include/openPMD/Datatype.hpp b/include/openPMD/Datatype.hpp
index f9661b60e8..24e60c1d22 100644
--- a/include/openPMD/Datatype.hpp
+++ b/include/openPMD/Datatype.hpp
@@ -651,6 +651,41 @@ inline bool isSameInteger(Datatype d)
         return false;
 }
 
+/**
+ * Determines if d represents a char type.
+ *
+ * @param d An openPMD datatype.
+ * @return true If d is a scalar char, signed char or unsigned char.
+ * @return false Otherwise.
+ */
+constexpr bool isChar(Datatype d)
+{
+    switch (d)
+    {
+    case Datatype::CHAR:
+    case Datatype::SCHAR:
+    case Datatype::UCHAR:
+        return true;
+    default:
+        return false;
+    }
+}
+
+/**
+ * Determines if d and T_Char are char types of same representation.
+ *
+ * Same representation means that on platforms with signed `char` type, `char`
+ * and `signed char` are considered to be eqivalent, similarly on platforms
+ * with unsigned `char` type.
+ *
+ * @tparam T_Char A type, as template parameter.
+ * @param d A type, as openPMD datatype.
+ * @return true If both types are chars of the same representation.
+ * @return false Otherwise.
+ */
+template <typename T_Char>
+constexpr bool isSameChar(Datatype d);
+
 /** Comparison for two Datatypes
  *
  * Besides returning true for the same types, identical implementations on
@@ -710,6 +745,43 @@ void warnWrongDtype(std::string const &key, Datatype store, Datatype request);
 
 std::ostream &operator<<(std::ostream &, openPMD::Datatype const &);
 
+/**
+ * Generalizes switching over an openPMD datatype.
+ *
+ * Will call the function template found at Action::call< T >(), instantiating T
+ * with the C++ internal datatype corresponding to the openPMD datatype.
+ *
+ * @tparam ReturnType The function template's return type.
+ * @tparam Action The struct containing the function template.
+ * @tparam Args The function template's argument types.
+ * @param dt The openPMD datatype.
+ * @param args The function template's arguments.
+ * @return Passes on the result of invoking the function template with the given
+ *     arguments and with the template parameter specified by dt.
+ */
+template <typename Action, typename... Args>
+constexpr auto switchType(Datatype dt, Args &&...args)
+    -> decltype(Action::template call<char>(std::forward<Args>(args)...));
+
+/**
+ * Generalizes switching over an openPMD datatype.
+ *
+ * Will call the function template found at Action::call< T >(), instantiating T
+ * with the C++ internal datatype corresponding to the openPMD datatype.
+ * Ignores vector and array types.
+ *
+ * @tparam ReturnType The function template's return type.
+ * @tparam Action The struct containing the function template.
+ * @tparam Args The function template's argument types.
+ * @param dt The openPMD datatype.
+ * @param args The function template's arguments.
+ * @return Passes on the result of invoking the function template with the given
+ *     arguments and with the template parameter specified by dt.
+ */
+template <typename Action, typename... Args>
+constexpr auto switchNonVectorType(Datatype dt, Args &&...args)
+    -> decltype(Action::template call<char>(std::forward<Args>(args)...));
+
 } // namespace openPMD
 
 #if !defined(_MSC_VER)
@@ -737,3 +809,5 @@ inline bool operator!=(openPMD::Datatype d, openPMD::Datatype e)
 /** @}
  */
 #endif
+
+#include "openPMD/Datatype.tpp"
diff --git a/include/openPMD/Datatype.tpp b/include/openPMD/Datatype.tpp
new file mode 100644
index 0000000000..64d6d30d5b
--- /dev/null
+++ b/include/openPMD/Datatype.tpp
@@ -0,0 +1,356 @@
+/* Copyright 2017-2023 Fabian Koller, Franz Poeschel, Axel Huebl
+ *
+ * This file is part of openPMD-api.
+ *
+ * openPMD-api is free software: you can redistribute it and/or modify
+ * it under the terms of of either the GNU General Public License or
+ * the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * openPMD-api is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License and the GNU Lesser General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * and the GNU Lesser General Public License along with openPMD-api.
+ * If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+
+#include "openPMD/Datatype.hpp"
+
+#include <string>
+#include <type_traits> // std::void_t
+#include <utility> // std::forward
+
+namespace openPMD
+{
+namespace detail
+{
+    // std::void_t is C++17
+    template <typename>
+    using void_t = void;
+
+    /*
+     * Check whether class T has a member "errorMsg" convertible
+     * to type std::string.
+     * Used to give helpful compile-time error messages with static_assert
+     * down in CallUndefinedDatatype.
+     */
+    template <typename T, typename = void>
+    struct HasErrorMessageMember
+    {
+        static constexpr bool value = false;
+    };
+
+    template <typename T>
+    struct HasErrorMessageMember<T, void_t<decltype(std::string(T::errorMsg))>>
+    {
+        static constexpr bool value = true;
+    };
+
+    /**
+     * Purpose of this struct is to detect at compile time whether
+     * Action::template operator()\<0\>() exists. If yes, call
+     * Action::template operator()\<n\>() with the passed arguments.
+     * If not, throw an error.
+     *
+     * @tparam n As in switchType().
+     * @tparam ReturnType As in switchType().
+     * @tparam Action As in switchType().
+     * @tparam Args As in switchType().
+     */
+    template <int n, typename ReturnType, typename Action, typename... Args>
+    struct CallUndefinedDatatype
+    {
+        static ReturnType call(Args &&...args)
+        {
+            if constexpr (HasErrorMessageMember<Action>::value)
+            {
+                throw std::runtime_error(
+                    "[" + std::string(Action::errorMsg) +
+                    "] Unknown Datatype.");
+            }
+            else
+            {
+                return Action::template call<n>(std::forward<Args>(args)...);
+            }
+            throw std::runtime_error("Unreachable!");
+        }
+    };
+} // namespace detail
+
+/**
+ * Generalizes switching over an openPMD datatype.
+ *
+ * Will call the function template found at Action::call< T >(), instantiating T
+ * with the C++ internal datatype corresponding to the openPMD datatype.
+ *
+ * @tparam ReturnType The function template's return type.
+ * @tparam Action The struct containing the function template.
+ * @tparam Args The function template's argument types.
+ * @param dt The openPMD datatype.
+ * @param args The function template's arguments.
+ * @return Passes on the result of invoking the function template with the given
+ *     arguments and with the template parameter specified by dt.
+ */
+template <typename Action, typename... Args>
+constexpr auto switchType(Datatype dt, Args &&...args)
+    -> decltype(Action::template call<char>(std::forward<Args>(args)...))
+{
+    using ReturnType =
+        decltype(Action::template call<char>(std::forward<Args>(args)...));
+    switch (dt)
+    {
+    case Datatype::CHAR:
+        return Action::template call<char>(std::forward<Args>(args)...);
+    case Datatype::UCHAR:
+        return Action::template call<unsigned char>(
+            std::forward<Args>(args)...);
+    case Datatype::SCHAR:
+        return Action::template call<signed char>(std::forward<Args>(args)...);
+    case Datatype::SHORT:
+        return Action::template call<short>(std::forward<Args>(args)...);
+    case Datatype::INT:
+        return Action::template call<int>(std::forward<Args>(args)...);
+    case Datatype::LONG:
+        return Action::template call<long>(std::forward<Args>(args)...);
+    case Datatype::LONGLONG:
+        return Action::template call<long long>(std::forward<Args>(args)...);
+    case Datatype::USHORT:
+        return Action::template call<unsigned short>(
+            std::forward<Args>(args)...);
+    case Datatype::UINT:
+        return Action::template call<unsigned int>(std::forward<Args>(args)...);
+    case Datatype::ULONG:
+        return Action::template call<unsigned long>(
+            std::forward<Args>(args)...);
+    case Datatype::ULONGLONG:
+        return Action::template call<unsigned long long>(
+            std::forward<Args>(args)...);
+    case Datatype::FLOAT:
+        return Action::template call<float>(std::forward<Args>(args)...);
+    case Datatype::DOUBLE:
+        return Action::template call<double>(std::forward<Args>(args)...);
+    case Datatype::LONG_DOUBLE:
+        return Action::template call<long double>(std::forward<Args>(args)...);
+    case Datatype::CFLOAT:
+        return Action::template call<std::complex<float>>(
+            std::forward<Args>(args)...);
+    case Datatype::CDOUBLE:
+        return Action::template call<std::complex<double>>(
+            std::forward<Args>(args)...);
+    case Datatype::CLONG_DOUBLE:
+        return Action::template call<std::complex<long double>>(
+            std::forward<Args>(args)...);
+    case Datatype::STRING:
+        return Action::template call<std::string>(std::forward<Args>(args)...);
+    case Datatype::VEC_CHAR:
+        return Action::template call<std::vector<char>>(
+            std::forward<Args>(args)...);
+    case Datatype::VEC_SHORT:
+        return Action::template call<std::vector<short>>(
+            std::forward<Args>(args)...);
+    case Datatype::VEC_INT:
+        return Action::template call<std::vector<int>>(
+            std::forward<Args>(args)...);
+    case Datatype::VEC_LONG:
+        return Action::template call<std::vector<long>>(
+            std::forward<Args>(args)...);
+    case Datatype::VEC_LONGLONG:
+        return Action::template call<std::vector<long long>>(
+            std::forward<Args>(args)...);
+    case Datatype::VEC_UCHAR:
+        return Action::template call<std::vector<unsigned char>>(
+            std::forward<Args>(args)...);
+    case Datatype::VEC_SCHAR:
+        return Action::template call<std::vector<signed char>>(
+            std::forward<Args>(args)...);
+    case Datatype::VEC_USHORT:
+        return Action::template call<std::vector<unsigned short>>(
+            std::forward<Args>(args)...);
+    case Datatype::VEC_UINT:
+        return Action::template call<std::vector<unsigned int>>(
+            std::forward<Args>(args)...);
+    case Datatype::VEC_ULONG:
+        return Action::template call<std::vector<unsigned long>>(
+            std::forward<Args>(args)...);
+    case Datatype::VEC_ULONGLONG:
+        return Action::template call<std::vector<unsigned long long>>(
+            std::forward<Args>(args)...);
+    case Datatype::VEC_FLOAT:
+        return Action::template call<std::vector<float>>(
+            std::forward<Args>(args)...);
+    case Datatype::VEC_DOUBLE:
+        return Action::template call<std::vector<double>>(
+            std::forward<Args>(args)...);
+    case Datatype::VEC_LONG_DOUBLE:
+        return Action::template call<std::vector<long double>>(
+            std::forward<Args>(args)...);
+    case Datatype::VEC_CFLOAT:
+        return Action::template call<std::vector<std::complex<float>>>(
+            std::forward<Args>(args)...);
+    case Datatype::VEC_CDOUBLE:
+        return Action::template call<std::vector<std::complex<double>>>(
+            std::forward<Args>(args)...);
+    case Datatype::VEC_CLONG_DOUBLE:
+        return Action::template call<std::vector<std::complex<long double>>>(
+            std::forward<Args>(args)...);
+    case Datatype::VEC_STRING:
+        return Action::template call<std::vector<std::string>>(
+            std::forward<Args>(args)...);
+    case Datatype::ARR_DBL_7:
+        return Action::template call<std::array<double, 7>>(
+            std::forward<Args>(args)...);
+    case Datatype::BOOL:
+        return Action::template call<bool>(std::forward<Args>(args)...);
+    case Datatype::UNDEFINED:
+        return detail::
+            CallUndefinedDatatype<0, ReturnType, Action, Args &&...>::call(
+                std::forward<Args>(args)...);
+    default:
+        throw std::runtime_error(
+            "Internal error: Encountered unknown datatype (switchType) ->" +
+            std::to_string(static_cast<int>(dt)));
+    }
+}
+
+/**
+ * Generalizes switching over an openPMD datatype.
+ *
+ * Will call the function template found at Action::call< T >(), instantiating T
+ * with the C++ internal datatype corresponding to the openPMD datatype.
+ * Ignores vector and array types.
+ *
+ * @tparam ReturnType The function template's return type.
+ * @tparam Action The struct containing the function template.
+ * @tparam Args The function template's argument types.
+ * @param dt The openPMD datatype.
+ * @param args The function template's arguments.
+ * @return Passes on the result of invoking the function template with the given
+ *     arguments and with the template parameter specified by dt.
+ */
+template <typename Action, typename... Args>
+constexpr auto switchNonVectorType(Datatype dt, Args &&...args)
+    -> decltype(Action::template call<char>(std::forward<Args>(args)...))
+{
+    using ReturnType =
+        decltype(Action::template call<char>(std::forward<Args>(args)...));
+    switch (dt)
+    {
+    case Datatype::CHAR:
+        return Action::template call<char>(std::forward<Args>(args)...);
+    case Datatype::UCHAR:
+        return Action::template call<unsigned char>(
+            std::forward<Args>(args)...);
+    case Datatype::SCHAR:
+        return Action::template call<signed char>(std::forward<Args>(args)...);
+    case Datatype::SHORT:
+        return Action::template call<short>(std::forward<Args>(args)...);
+    case Datatype::INT:
+        return Action::template call<int>(std::forward<Args>(args)...);
+    case Datatype::LONG:
+        return Action::template call<long>(std::forward<Args>(args)...);
+    case Datatype::LONGLONG:
+        return Action::template call<long long>(std::forward<Args>(args)...);
+    case Datatype::USHORT:
+        return Action::template call<unsigned short>(
+            std::forward<Args>(args)...);
+    case Datatype::UINT:
+        return Action::template call<unsigned int>(std::forward<Args>(args)...);
+    case Datatype::ULONG:
+        return Action::template call<unsigned long>(
+            std::forward<Args>(args)...);
+    case Datatype::ULONGLONG:
+        return Action::template call<unsigned long long>(
+            std::forward<Args>(args)...);
+    case Datatype::FLOAT:
+        return Action::template call<float>(std::forward<Args>(args)...);
+    case Datatype::DOUBLE:
+        return Action::template call<double>(std::forward<Args>(args)...);
+    case Datatype::LONG_DOUBLE:
+        return Action::template call<long double>(std::forward<Args>(args)...);
+    case Datatype::CFLOAT:
+        return Action::template call<std::complex<float>>(
+            std::forward<Args>(args)...);
+    case Datatype::CDOUBLE:
+        return Action::template call<std::complex<double>>(
+            std::forward<Args>(args)...);
+    case Datatype::CLONG_DOUBLE:
+        return Action::template call<std::complex<long double>>(
+            std::forward<Args>(args)...);
+    case Datatype::STRING:
+        return Action::template call<std::string>(std::forward<Args>(args)...);
+    case Datatype::BOOL:
+        return Action::template call<bool>(std::forward<Args>(args)...);
+    case Datatype::UNDEFINED:
+        return detail::
+            CallUndefinedDatatype<0, ReturnType, Action, Args &&...>::call(
+                std::forward<Args>(args)...);
+    default:
+        throw std::runtime_error(
+            "Internal error: Encountered unknown datatype (switchType) ->" +
+            std::to_string(static_cast<int>(dt)));
+    }
+}
+
+namespace detail
+{
+    template <typename T>
+    struct is_char
+    {
+        static constexpr bool value = false;
+    };
+    template <>
+    struct is_char<char>
+    {
+        static constexpr bool value = true;
+    };
+    template <>
+    struct is_char<signed char>
+    {
+        static constexpr bool value = true;
+    };
+    template <>
+    struct is_char<unsigned char>
+    {
+        static constexpr bool value = true;
+    };
+    template <typename T>
+    constexpr bool is_char_v = is_char<T>::value;
+
+    template <typename T_Char1, typename T_Char2>
+    inline bool isSameChar()
+    {
+        return
+            // both must be char types
+            is_char_v<T_Char1> && is_char_v<T_Char2> &&
+            // both must have equivalent sign
+            std::is_signed_v<T_Char1> == std::is_signed_v<T_Char2> &&
+            // both must have equivalent size
+            sizeof(T_Char1) == sizeof(T_Char2);
+    }
+
+    template <typename T1>
+    struct IsSameChar
+    {
+        template <typename T2>
+        static bool call()
+        {
+            return isSameChar<T1, T2>();
+        }
+
+        static constexpr char const *errorMsg = "IsSameChar";
+    };
+
+} // namespace detail
+
+template <typename T_Char>
+constexpr inline bool isSameChar(Datatype d)
+{
+    return switchType<detail::IsSameChar<T_Char>>(d);
+}
+} // namespace openPMD
diff --git a/include/openPMD/DatatypeHelpers.hpp b/include/openPMD/DatatypeHelpers.hpp
index 07f3c7fc37..b2e9171754 100644
--- a/include/openPMD/DatatypeHelpers.hpp
+++ b/include/openPMD/DatatypeHelpers.hpp
@@ -1,4 +1,4 @@
-/* Copyright 2017-2021 Fabian Koller, Franz Poeschel, Axel Huebl
+/* Copyright 2023 Franz Poeschel
  *
  * This file is part of openPMD-api.
  *
@@ -18,282 +18,11 @@
  * and the GNU Lesser General Public License along with openPMD-api.
  * If not, see <http://www.gnu.org/licenses/>.
  */
-#pragma once
-
-#include "openPMD/Datatype.hpp"
-
-#include <string>
-#include <type_traits>
-#include <utility> // std::forward
-
-namespace openPMD
-{
-namespace detail
-{
-    // std::void_t is C++17
-    template <typename>
-    using void_t = void;
-
-    /*
-     * Check whether class T has a member "errorMsg" convertible
-     * to type std::string.
-     * Used to give helpful compile-time error messages with static_assert
-     * down in CallUndefinedDatatype.
-     */
-    template <typename T, typename = void>
-    struct HasErrorMessageMember
-    {
-        static constexpr bool value = false;
-    };
-
-    template <typename T>
-    struct HasErrorMessageMember<T, void_t<decltype(std::string(T::errorMsg))> >
-    {
-        static constexpr bool value = true;
-    };
 
-    /**
-     * Purpose of this struct is to detect at compile time whether
-     * Action::template operator()\<0\>() exists. If yes, call
-     * Action::template operator()\<n\>() with the passed arguments.
-     * If not, throw an error.
-     *
-     * @tparam n As in switchType().
-     * @tparam ReturnType As in switchType().
-     * @tparam Action As in switchType().
-     * @tparam Args As in switchType().
-     */
-    template <int n, typename ReturnType, typename Action, typename... Args>
-    struct CallUndefinedDatatype
-    {
-        static ReturnType call(Args &&...args)
-        {
-            if constexpr (HasErrorMessageMember<Action>::value)
-            {
-                throw std::runtime_error(
-                    "[" + std::string(Action::errorMsg) +
-                    "] Unknown Datatype.");
-            }
-            else
-            {
-                return Action::template call<n>(std::forward<Args>(args)...);
-            }
-            throw std::runtime_error("Unreachable!");
-        }
-    };
-} // namespace detail
+#pragma once
 
-/**
- * Generalizes switching over an openPMD datatype.
- *
- * Will call the function template found at Action::call< T >(), instantiating T
- * with the C++ internal datatype corresponding to the openPMD datatype.
- *
- * @tparam ReturnType The function template's return type.
- * @tparam Action The struct containing the function template.
- * @tparam Args The function template's argument types.
- * @param dt The openPMD datatype.
- * @param args The function template's arguments.
- * @return Passes on the result of invoking the function template with the given
- *     arguments and with the template parameter specified by dt.
+/*
+ * Legacy header, its functions are now included directly in Datatype.hpp.
  */
-template <typename Action, typename... Args>
-auto switchType(Datatype dt, Args &&...args)
-    -> decltype(Action::template call<char>(std::forward<Args>(args)...))
-{
-    using ReturnType =
-        decltype(Action::template call<char>(std::forward<Args>(args)...));
-    switch (dt)
-    {
-    case Datatype::CHAR:
-        return Action::template call<char>(std::forward<Args>(args)...);
-    case Datatype::UCHAR:
-        return Action::template call<unsigned char>(
-            std::forward<Args>(args)...);
-    case Datatype::SCHAR:
-        return Action::template call<signed char>(std::forward<Args>(args)...);
-    case Datatype::SHORT:
-        return Action::template call<short>(std::forward<Args>(args)...);
-    case Datatype::INT:
-        return Action::template call<int>(std::forward<Args>(args)...);
-    case Datatype::LONG:
-        return Action::template call<long>(std::forward<Args>(args)...);
-    case Datatype::LONGLONG:
-        return Action::template call<long long>(std::forward<Args>(args)...);
-    case Datatype::USHORT:
-        return Action::template call<unsigned short>(
-            std::forward<Args>(args)...);
-    case Datatype::UINT:
-        return Action::template call<unsigned int>(std::forward<Args>(args)...);
-    case Datatype::ULONG:
-        return Action::template call<unsigned long>(
-            std::forward<Args>(args)...);
-    case Datatype::ULONGLONG:
-        return Action::template call<unsigned long long>(
-            std::forward<Args>(args)...);
-    case Datatype::FLOAT:
-        return Action::template call<float>(std::forward<Args>(args)...);
-    case Datatype::DOUBLE:
-        return Action::template call<double>(std::forward<Args>(args)...);
-    case Datatype::LONG_DOUBLE:
-        return Action::template call<long double>(std::forward<Args>(args)...);
-    case Datatype::CFLOAT:
-        return Action::template call<std::complex<float> >(
-            std::forward<Args>(args)...);
-    case Datatype::CDOUBLE:
-        return Action::template call<std::complex<double> >(
-            std::forward<Args>(args)...);
-    case Datatype::CLONG_DOUBLE:
-        return Action::template call<std::complex<long double> >(
-            std::forward<Args>(args)...);
-    case Datatype::STRING:
-        return Action::template call<std::string>(std::forward<Args>(args)...);
-    case Datatype::VEC_CHAR:
-        return Action::template call<std::vector<char> >(
-            std::forward<Args>(args)...);
-    case Datatype::VEC_SHORT:
-        return Action::template call<std::vector<short> >(
-            std::forward<Args>(args)...);
-    case Datatype::VEC_INT:
-        return Action::template call<std::vector<int> >(
-            std::forward<Args>(args)...);
-    case Datatype::VEC_LONG:
-        return Action::template call<std::vector<long> >(
-            std::forward<Args>(args)...);
-    case Datatype::VEC_LONGLONG:
-        return Action::template call<std::vector<long long> >(
-            std::forward<Args>(args)...);
-    case Datatype::VEC_UCHAR:
-        return Action::template call<std::vector<unsigned char> >(
-            std::forward<Args>(args)...);
-    case Datatype::VEC_SCHAR:
-        return Action::template call<std::vector<signed char> >(
-            std::forward<Args>(args)...);
-    case Datatype::VEC_USHORT:
-        return Action::template call<std::vector<unsigned short> >(
-            std::forward<Args>(args)...);
-    case Datatype::VEC_UINT:
-        return Action::template call<std::vector<unsigned int> >(
-            std::forward<Args>(args)...);
-    case Datatype::VEC_ULONG:
-        return Action::template call<std::vector<unsigned long> >(
-            std::forward<Args>(args)...);
-    case Datatype::VEC_ULONGLONG:
-        return Action::template call<std::vector<unsigned long long> >(
-            std::forward<Args>(args)...);
-    case Datatype::VEC_FLOAT:
-        return Action::template call<std::vector<float> >(
-            std::forward<Args>(args)...);
-    case Datatype::VEC_DOUBLE:
-        return Action::template call<std::vector<double> >(
-            std::forward<Args>(args)...);
-    case Datatype::VEC_LONG_DOUBLE:
-        return Action::template call<std::vector<long double> >(
-            std::forward<Args>(args)...);
-    case Datatype::VEC_CFLOAT:
-        return Action::template call<std::vector<std::complex<float> > >(
-            std::forward<Args>(args)...);
-    case Datatype::VEC_CDOUBLE:
-        return Action::template call<std::vector<std::complex<double> > >(
-            std::forward<Args>(args)...);
-    case Datatype::VEC_CLONG_DOUBLE:
-        return Action::template call<std::vector<std::complex<long double> > >(
-            std::forward<Args>(args)...);
-    case Datatype::VEC_STRING:
-        return Action::template call<std::vector<std::string> >(
-            std::forward<Args>(args)...);
-    case Datatype::ARR_DBL_7:
-        return Action::template call<std::array<double, 7> >(
-            std::forward<Args>(args)...);
-    case Datatype::BOOL:
-        return Action::template call<bool>(std::forward<Args>(args)...);
-    case Datatype::UNDEFINED:
-        return detail::
-            CallUndefinedDatatype<0, ReturnType, Action, Args &&...>::call(
-                std::forward<Args>(args)...);
-    default:
-        throw std::runtime_error(
-            "Internal error: Encountered unknown datatype (switchType) ->" +
-            std::to_string(static_cast<int>(dt)));
-    }
-}
 
-/**
- * Generalizes switching over an openPMD datatype.
- *
- * Will call the function template found at Action::call< T >(), instantiating T
- * with the C++ internal datatype corresponding to the openPMD datatype.
- * Ignores vector and array types.
- *
- * @tparam ReturnType The function template's return type.
- * @tparam Action The struct containing the function template.
- * @tparam Args The function template's argument types.
- * @param dt The openPMD datatype.
- * @param args The function template's arguments.
- * @return Passes on the result of invoking the function template with the given
- *     arguments and with the template parameter specified by dt.
- */
-template <typename Action, typename... Args>
-auto switchNonVectorType(Datatype dt, Args &&...args)
-    -> decltype(Action::template call<char>(std::forward<Args>(args)...))
-{
-    using ReturnType =
-        decltype(Action::template call<char>(std::forward<Args>(args)...));
-    switch (dt)
-    {
-    case Datatype::CHAR:
-        return Action::template call<char>(std::forward<Args>(args)...);
-    case Datatype::UCHAR:
-        return Action::template call<unsigned char>(
-            std::forward<Args>(args)...);
-    case Datatype::SCHAR:
-        return Action::template call<signed char>(std::forward<Args>(args)...);
-    case Datatype::SHORT:
-        return Action::template call<short>(std::forward<Args>(args)...);
-    case Datatype::INT:
-        return Action::template call<int>(std::forward<Args>(args)...);
-    case Datatype::LONG:
-        return Action::template call<long>(std::forward<Args>(args)...);
-    case Datatype::LONGLONG:
-        return Action::template call<long long>(std::forward<Args>(args)...);
-    case Datatype::USHORT:
-        return Action::template call<unsigned short>(
-            std::forward<Args>(args)...);
-    case Datatype::UINT:
-        return Action::template call<unsigned int>(std::forward<Args>(args)...);
-    case Datatype::ULONG:
-        return Action::template call<unsigned long>(
-            std::forward<Args>(args)...);
-    case Datatype::ULONGLONG:
-        return Action::template call<unsigned long long>(
-            std::forward<Args>(args)...);
-    case Datatype::FLOAT:
-        return Action::template call<float>(std::forward<Args>(args)...);
-    case Datatype::DOUBLE:
-        return Action::template call<double>(std::forward<Args>(args)...);
-    case Datatype::LONG_DOUBLE:
-        return Action::template call<long double>(std::forward<Args>(args)...);
-    case Datatype::CFLOAT:
-        return Action::template call<std::complex<float> >(
-            std::forward<Args>(args)...);
-    case Datatype::CDOUBLE:
-        return Action::template call<std::complex<double> >(
-            std::forward<Args>(args)...);
-    case Datatype::CLONG_DOUBLE:
-        return Action::template call<std::complex<long double> >(
-            std::forward<Args>(args)...);
-    case Datatype::STRING:
-        return Action::template call<std::string>(std::forward<Args>(args)...);
-    case Datatype::BOOL:
-        return Action::template call<bool>(std::forward<Args>(args)...);
-    case Datatype::UNDEFINED:
-        return detail::
-            CallUndefinedDatatype<0, ReturnType, Action, Args &&...>::call(
-                std::forward<Args>(args)...);
-    default:
-        throw std::runtime_error(
-            "Internal error: Encountered unknown datatype (switchType) ->" +
-            std::to_string(static_cast<int>(dt)));
-    }
-}
-} // namespace openPMD
+#include "openPMD/Datatype.hpp"
diff --git a/include/openPMD/RecordComponent.tpp b/include/openPMD/RecordComponent.tpp
index 00c67dcf2a..dc796c8180 100644
--- a/include/openPMD/RecordComponent.tpp
+++ b/include/openPMD/RecordComponent.tpp
@@ -100,7 +100,8 @@ RecordComponent::loadChunk(std::shared_ptr<T> data, Offset o, Extent e)
     if (dtype != getDatatype())
         if (!isSameInteger<T>(getDatatype()) &&
             !isSameFloatingPoint<T>(getDatatype()) &&
-            !isSameComplexFloatingPoint<T>(getDatatype()))
+            !isSameComplexFloatingPoint<T>(getDatatype()) &&
+            !isSameChar<T>(getDatatype()))
         {
             std::string const data_type_str = datatypeToString(getDatatype());
             std::string const requ_type_str =
diff --git a/src/IO/HDF5/HDF5Auxiliary.cpp b/src/IO/HDF5/HDF5Auxiliary.cpp
index 3a6c9e7cd4..53fb1fb390 100644
--- a/src/IO/HDF5/HDF5Auxiliary.cpp
+++ b/src/IO/HDF5/HDF5Auxiliary.cpp
@@ -56,15 +56,16 @@ hid_t openPMD::GetH5DataType::operator()(Attribute const &att)
     using DT = Datatype;
     switch (att.dtype)
     {
-    case DT::CHAR:
-    case DT::VEC_CHAR:
-        return H5Tcopy(H5T_NATIVE_CHAR);
     case DT::UCHAR:
     case DT::VEC_UCHAR:
         return H5Tcopy(H5T_NATIVE_UCHAR);
     case DT::SCHAR:
     case DT::VEC_SCHAR:
         return H5Tcopy(H5T_NATIVE_SCHAR);
+    // NOTE: in HDF5, CHAR is actually either UCHAR or SCHAR.
+    case DT::CHAR:
+    case DT::VEC_CHAR:
+        return H5Tcopy(H5T_NATIVE_CHAR);
     case DT::SHORT:
     case DT::VEC_SHORT:
         return H5Tcopy(H5T_NATIVE_SHORT);
diff --git a/src/IO/HDF5/HDF5IOHandler.cpp b/src/IO/HDF5/HDF5IOHandler.cpp
index 00f2f0245e..24aa6cac2d 100644
--- a/src/IO/HDF5/HDF5IOHandler.cpp
+++ b/src/IO/HDF5/HDF5IOHandler.cpp
@@ -987,12 +987,13 @@ void HDF5IOHandlerImpl::openDataset(
     if (dataset_class == H5S_SIMPLE || dataset_class == H5S_SCALAR ||
         dataset_class == H5S_NULL)
     {
-        if (H5Tequal(dataset_type, H5T_NATIVE_CHAR))
-            d = DT::CHAR;
-        else if (H5Tequal(dataset_type, H5T_NATIVE_UCHAR))
+        if (H5Tequal(dataset_type, H5T_NATIVE_UCHAR))
             d = DT::UCHAR;
         else if (H5Tequal(dataset_type, H5T_NATIVE_SCHAR))
             d = DT::SCHAR;
+        // NOTE: in HDF5, CHAR is actually either UCHAR or SCHAR.
+        else if (H5Tequal(dataset_type, H5T_NATIVE_CHAR))
+            d = DT::CHAR;
         else if (H5Tequal(dataset_type, H5T_NATIVE_SHORT))
             d = DT::SHORT;
         else if (H5Tequal(dataset_type, H5T_NATIVE_INT))
diff --git a/test/SerialIOTest.cpp b/test/SerialIOTest.cpp
index ce37e4f352..49e070e312 100644
--- a/test/SerialIOTest.cpp
+++ b/test/SerialIOTest.cpp
@@ -1,4 +1,6 @@
 // expose private and protected members for invasive testing
+#include "openPMD/Datatype.hpp"
+#include "openPMD/IO/Access.hpp"
 #if openPMD_USE_INVASIVE_TESTS
 #define OPENPMD_private public:
 #define OPENPMD_protected public:
@@ -208,6 +210,54 @@ TEST_CASE("adios2_char_portability", "[serial][adios2]")
 }
 #endif
 
+namespace detail
+{
+template <typename Char>
+void writeChar(Series &series, std::string const &component_name)
+{
+    auto component = series.iterations[0].meshes["E"][component_name];
+    std::vector<Char> data(10);
+    component.resetDataset({determineDatatype<Char>(), {10}});
+    component.storeChunk(data, {0}, {10});
+    series.flush();
+}
+template <typename Char>
+void readChar(Series &series, std::string const &component_name)
+{
+    auto component = series.iterations[0].meshes["E"][component_name];
+    std::vector<Char> data(10);
+    auto chunk = component.loadChunk<Char>();
+    series.flush();
+    for (size_t i = 0; i < 10; ++i)
+    {
+        REQUIRE(data[i] == chunk.get()[i]);
+    }
+}
+} // namespace detail
+
+void char_roundtrip(std::string const &extension)
+{
+    Series write("../samples/char_rountrip." + extension, Access::CREATE);
+    ::detail::writeChar<char>(write, "char");
+    ::detail::writeChar<unsigned char>(write, "uchar");
+    ::detail::writeChar<signed char>(write, "schar");
+    write.close();
+
+    Series read("../samples/char_rountrip." + extension, Access::READ_ONLY);
+    ::detail::readChar<char>(read, "char");
+    ::detail::readChar<unsigned char>(read, "uchar");
+    ::detail::readChar<signed char>(read, "schar");
+    read.close();
+}
+
+TEST_CASE("char_roundtrip", "[serial]")
+{
+    for (auto const &t : testedFileExtensions())
+    {
+        char_roundtrip(t);
+    }
+}
+
 void write_and_read_many_iterations(
     std::string const &ext, bool intermittentFlushes)
 {