diff --git a/include/cereal/cereal.hpp b/include/cereal/cereal.hpp
index 72038346..88cc68d2 100644
--- a/include/cereal/cereal.hpp
+++ b/include/cereal/cereal.hpp
@@ -45,6 +45,8 @@
 #include "cereal/details/helpers.hpp"
 #include "cereal/types/base_class.hpp"
 
+#include "cereal/external/ctti/type_id.hpp"
+
 namespace cereal
 {
   // ######################################################################
@@ -269,8 +271,9 @@ namespace cereal
     {                                                                            \
       static std::uint32_t registerVersion()                                     \
       {                                                                          \
-        ::cereal::detail::StaticObject<Versions>::getInstance().mapping.emplace( \
-             std::type_index(typeid(TYPE)).hash_code(), VERSION_NUMBER );        \
+        ::cereal::detail::StaticObject<Versions>::getInstance().mapping          \
+            .emplace(std::hash<ctti::type_id_t>()(ctti::type_id<TYPE>()),        \
+                     VERSION_NUMBER);                                            \
         return VERSION_NUMBER;                                                   \
       }                                                                          \
       static inline const std::uint32_t version = registerVersion();             \
@@ -285,8 +288,9 @@ namespace cereal
       static const std::uint32_t version;                                        \
       static std::uint32_t registerVersion()                                     \
       {                                                                          \
-        ::cereal::detail::StaticObject<Versions>::getInstance().mapping.emplace( \
-             std::type_index(typeid(TYPE)).hash_code(), VERSION_NUMBER );        \
+        ::cereal::detail::StaticObject<Versions>::getInstance().mapping          \
+            .emplace(std::hash<ctti::type_id_t>()(ctti::type_id<TYPE>()),        \
+                     VERSION_NUMBER);                                            \
         return VERSION_NUMBER;                                                   \
       }                                                                          \
       CEREAL_UNUSED_FUNCTION                                                     \
@@ -595,7 +599,7 @@ namespace cereal
       template <class T> inline
       std::uint32_t registerClassVersion()
       {
-        static const auto hash = std::type_index(typeid(T)).hash_code();
+        static const auto hash = std::hash<ctti::type_id_t>()(ctti::type_id<T>());
         const auto insertResult = itsVersionedTypes.insert( hash );
         const auto lock = detail::StaticObject<detail::Versions>::lock();
         const auto version =
@@ -1013,7 +1017,7 @@ namespace cereal
       template <class T> inline
       std::uint32_t loadClassVersion()
       {
-        static const auto hash = std::type_index(typeid(T)).hash_code();
+        static const auto hash = std::hash<ctti::type_id_t>()(ctti::type_id<T>());
         auto lookupResult = itsVersionedTypes.find( hash );
 
         if( lookupResult != itsVersionedTypes.end() ) // already exists
diff --git a/include/cereal/details/traits.hpp b/include/cereal/details/traits.hpp
index e1fda1d9..21db6b45 100644
--- a/include/cereal/details/traits.hpp
+++ b/include/cereal/details/traits.hpp
@@ -42,6 +42,8 @@
 #include "cereal/macros.hpp"
 #include "cereal/access.hpp"
 
+#include "cereal/external/ctti/type_id.hpp"
+
 namespace cereal
 {
   namespace traits
@@ -1146,15 +1148,15 @@ namespace cereal
       {
         template<class T>
           base_class_id(T const * const t) :
-          type(typeid(T)),
+          type(ctti::type_id<T>()),
           ptr(t),
-          hash(std::hash<std::type_index>()(typeid(T)) ^ (std::hash<void const *>()(t) << 1))
+          hash(std::hash<ctti::type_id_t>()(ctti::type_id<T>()) ^ (std::hash<void const *>()(t) << 1))
           { }
 
           bool operator==(base_class_id const & other) const
           { return (type == other.type) && (ptr == other.ptr); }
 
-          std::type_index type;
+          ctti::type_id_t type;
           void const * ptr;
           size_t hash;
       };
diff --git a/include/cereal/external/ctti/LICENSE.md b/include/cereal/external/ctti/LICENSE.md
new file mode 100644
index 00000000..0d5309a2
--- /dev/null
+++ b/include/cereal/external/ctti/LICENSE.md
@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2015 Manuel Sánchez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
\ No newline at end of file
diff --git a/include/cereal/external/ctti/detail/algorithm.hpp b/include/cereal/external/ctti/detail/algorithm.hpp
new file mode 100644
index 00000000..4ad9cc8f
--- /dev/null
+++ b/include/cereal/external/ctti/detail/algorithm.hpp
@@ -0,0 +1,47 @@
+#ifndef CTTI_DETAIL_ALGORITHM_HPP
+#define CTTI_DETAIL_ALGORITHM_HPP
+
+#include <cstdint>
+
+namespace ctti
+{
+
+namespace detail
+{
+
+template<typename T, std::size_t N>
+constexpr const T* begin(const T(&array)[N])
+{
+    return &array[0];
+}
+
+template<typename T, std::size_t N>
+constexpr const T* end(const T(&array)[N])
+{
+    return &array[N];
+}
+
+template<typename LhsIt, typename RhsIt>
+constexpr bool equal_range(LhsIt lhsBegin, LhsIt lhsEnd, RhsIt rhsBegin, RhsIt rhsEnd)
+{
+    return (lhsBegin != lhsEnd && rhsBegin != rhsEnd) ? *lhsBegin == *rhsBegin &&
+        equal_range(lhsBegin + 1, lhsEnd, rhsBegin + 1, rhsEnd) : (lhsBegin == lhsEnd && rhsBegin == rhsEnd);
+}
+
+template<typename T>
+constexpr const T& max(const T& lhs, const T& rhs)
+{
+    return (lhs >= rhs) ? lhs : rhs;
+}
+
+template<typename T>
+constexpr const T& min(const T& lhs, const T& rhs)
+{
+    return (lhs <= rhs) ? lhs : rhs;
+}
+
+}
+
+}
+
+#endif // CTTI_DETAIL_ALGORITHM_HPP
diff --git a/include/cereal/external/ctti/detail/cstring.hpp b/include/cereal/external/ctti/detail/cstring.hpp
new file mode 100644
index 00000000..1c92c694
--- /dev/null
+++ b/include/cereal/external/ctti/detail/cstring.hpp
@@ -0,0 +1,125 @@
+#ifndef CTTI_DETAIL_CSTRING_HPP
+#define CTTI_DETAIL_CSTRING_HPP
+
+#include "hash.hpp"
+#include "algorithm.hpp"
+#include <ostream>
+#include <string>
+
+namespace ctti
+{
+
+namespace detail
+{
+
+class cstring
+{
+public:
+    template<std::size_t N>
+    constexpr cstring(const char (&str)[N]) :
+        cstring{&str[0], N - 1}
+    {}
+
+    constexpr cstring(const char* begin, std::size_t length) :
+        _str{begin},
+        _length{length}
+    {}
+
+    constexpr cstring(const char* begin, const char* end) :
+        cstring{begin, static_cast<std::size_t>(end - begin)}
+    {}
+
+    constexpr cstring(const char* begin) :
+        cstring{begin, length(begin)}
+    {}
+
+    static constexpr std::size_t length(const char* str)
+    {
+        return *str ? 1 + length(str + 1) : 0;
+    }
+
+    constexpr std::size_t length() const
+    {
+        return _length;
+    }
+
+    constexpr std::size_t size() const
+    {
+        return length();
+    }
+
+    constexpr hash_t hash() const
+    {
+        return fnv1a_hash(length(), begin());
+    }
+
+    std::string cppstring() const
+    {
+        return {begin(), end()};
+    }
+
+    std::string str() const
+    {
+        return cppstring();
+    }
+
+    constexpr const char* begin() const
+    {
+        return _str;
+    }
+
+    constexpr const char* end() const
+    {
+        return _str + _length;
+    }
+
+    constexpr char operator[](std::size_t i) const
+    {
+        return _str[i];
+    }
+
+    constexpr const char* operator()(std::size_t i) const
+    {
+        return _str + i;
+    }
+
+    constexpr cstring operator()(std::size_t begin, std::size_t end) const
+    {
+        return {_str + begin, _str + end};
+    }
+
+    constexpr cstring pad(std::size_t begin_offset, std::size_t end_offset) const
+    {
+        return operator()(begin_offset, size() - end_offset);
+    }
+
+    friend std::ostream& operator<<(std::ostream& os, const cstring& str)
+    {
+        for(const char c : str)
+        {
+            os << c;
+        }
+
+        return os;
+    }
+
+private:
+    const char* _str;
+    std::size_t _length;
+};
+
+constexpr bool operator==(const cstring& lhs, const cstring& rhs)
+{
+    return ctti::detail::equal_range(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
+}
+
+constexpr bool operator!=(const cstring& lhs, const cstring& rhs)
+{
+    return !(lhs == rhs);
+}
+
+}
+
+}
+
+#endif // CTTI_DETAIL_CSTRING_HPP
diff --git a/include/cereal/external/ctti/detail/entity_name.hpp b/include/cereal/external/ctti/detail/entity_name.hpp
new file mode 100644
index 00000000..d367df94
--- /dev/null
+++ b/include/cereal/external/ctti/detail/entity_name.hpp
@@ -0,0 +1,46 @@
+#ifndef CTTI_DETAIL_ENTITY_NAME_HPP
+#define CTTI_DETAIL_ENTITY_NAME_HPP
+
+#include "cstring.hpp"
+
+namespace ctti
+{
+
+namespace detail
+{
+
+class entity_name
+{
+public:
+    constexpr entity_name(const ctti::detail::cstring& str) :
+        _str{str}
+    {}
+
+    constexpr ctti::detail::cstring str() const
+    {
+        return _str;
+    }
+
+    constexpr ctti::detail::cstring operator[](std::size_t i) const
+    {
+        return colon_scan(_str.begin(), _str.end(), i);
+    }
+
+private:
+    ctti::detail::cstring _str;
+
+    constexpr ctti::detail::cstring colon_scan(const char* begin, const char* end, std::size_t i) const
+    {
+        return (begin == end) ? {begin, end} :
+            (i == 0) ? {begin, end}
+            (colon_count == 0 && *begin == ':') ? colon_scan(++begin, end, i, ++colon_count) :
+            (colon_count == 1 && *begin == ':') ? colon_scan(++begin, end, i - 1, 0)
+            (
+    }
+};
+
+}
+
+}
+
+#endif // CTTI_DETAIL_ENTITY_NAME_HPP
diff --git a/include/cereal/external/ctti/detail/hash.hpp b/include/cereal/external/ctti/detail/hash.hpp
new file mode 100644
index 00000000..1ecc8f39
--- /dev/null
+++ b/include/cereal/external/ctti/detail/hash.hpp
@@ -0,0 +1,32 @@
+#ifndef CTTI_DETAIL_HASH_HPP
+#define CTTI_DETAIL_HASH_HPP
+
+#include <cstdint>
+
+namespace ctti
+{
+    namespace detail
+    {
+        // From https://github.com/foonathan/string_id. As usually, thanks Jonathan.
+
+        using hash_t = std::uint64_t;
+
+        // See http://www.isthe.com/chongo/tech/comp/fnv/#FNV-param
+        constexpr hash_t fnv_basis = 14695981039346656037ull;
+        constexpr hash_t fnv_prime = 1099511628211ull;
+
+        // FNV-1a 64 bit hash
+        constexpr hash_t fnv1a_hash(std::size_t n, const char *str, hash_t hash = fnv_basis)
+        {
+            return n > 0 ? fnv1a_hash(n - 1, str + 1, (hash ^ *str) * fnv_prime) : hash;
+        }
+
+        template<std::size_t N>
+        constexpr hash_t fnv1a_hash(const char (&array)[N])
+        {
+            return fnv1a_hash(N - 1, &array[0]);
+        }
+    }
+}
+
+#endif /* CTTI_DETAIL_HASH_HPP */
diff --git a/include/cereal/external/ctti/detail/language_features.hpp b/include/cereal/external/ctti/detail/language_features.hpp
new file mode 100644
index 00000000..f262a360
--- /dev/null
+++ b/include/cereal/external/ctti/detail/language_features.hpp
@@ -0,0 +1,18 @@
+#ifndef CTTI_LANGUAGE_FEATURES_HPP
+#define CTTI_LANGUAGE_FEATURES_HPP
+
+#ifdef __cpp_variable_templates
+#define CTTI_HAS_VARIABLE_TEMPLATES
+#endif // __cpp_variable_templates
+
+#define CTTI_HAS_CONSTEXPR_PRETTY_FUNCTION
+
+#if defined(__GCC__) && __GCC__ < 5
+#undef CTTI_HAS_CONSTEXPR_PRETTY_FUNCTION
+#endif // GCC 4.x
+
+#ifdef __clang__
+#define CTTI_HAS_ENUM_AWARE_PRETTY_FUNCTION
+#endif // __clang__
+
+#endif // CTTI_LANGUAGE_FEATURES_HPP
diff --git a/include/cereal/external/ctti/detail/meta.hpp b/include/cereal/external/ctti/detail/meta.hpp
new file mode 100644
index 00000000..a32126a6
--- /dev/null
+++ b/include/cereal/external/ctti/detail/meta.hpp
@@ -0,0 +1,825 @@
+#ifndef CTTI_UTILITY_META_H
+#define CTTI_UTILITY_META_H
+
+#include <type_traits>
+#include <cstddef>
+#include <array>
+#include <cstdint>
+
+namespace ctti
+{
+
+namespace meta
+{
+    template<typename T>
+    using decay_t = typename std::decay<T>::type;
+
+    template<typename... Bs>
+    struct assert;
+
+    template<typename B, typename... Bs>
+    struct assert<B, Bs...> : assert<Bs...>
+    {
+        static_assert(B::value, "Assertion failed");
+    };
+
+    template<>
+    struct assert<> {};
+
+    template<typename T>
+    using void_t = typename std::conditional<sizeof(T*) >= 0, void, T>::type;
+
+    template<typename T>
+    struct identity
+    {
+        using type = T;
+    };
+
+    template<typename Metafunction>
+    using type_t = typename Metafunction::type;
+
+    template<bool Cond, typename T = void>
+    using enable_if_t = typename std::enable_if<Cond, T>::type;
+
+    template<typename MetafunctionClass, typename... Args>
+    using apply_t = type_t<typename MetafunctionClass::template apply<Args...>>;
+
+    template<typename MetafunctionClass, typename Seq>
+    struct sequence_apply;
+
+    template<typename MetafunctionClass,
+             template<typename...> class Seq, typename... Ts>
+    struct sequence_apply<MetafunctionClass, Seq<Ts...>>
+    {
+        using type = apply_t<MetafunctionClass, Ts...>;
+    };
+
+    template<typename MetafunctionClass, typename Seq>
+    using sequence_apply_t = type_t<sequence_apply<MetafunctionClass, Seq>>;
+
+    template<std::uint8_t I>
+    using uint8_t = std::integral_constant<std::uint8_t, I>;
+    template<std::uint16_t I>
+    using uint16_t = std::integral_constant<std::uint16_t, I>;
+    template<std::uint32_t I>
+    using uint32_t = std::integral_constant<std::uint32_t, I>;
+    template<std::uint64_t I>
+    using uint64_t = std::integral_constant<std::uint64_t, I>;
+
+    template<std::int8_t I>
+    using int8_t = std::integral_constant<std::int8_t, I>;
+    template<std::int16_t I>
+    using int16_t = std::integral_constant<std::int16_t, I>;
+    template<std::int32_t I>
+    using int32_t = std::integral_constant<std::int32_t, I>;
+    template<std::int64_t I>
+    using int64_t = std::integral_constant<std::int64_t, I>;
+
+    template<std::size_t I>
+    using size_t = std::integral_constant<std::size_t, I>;
+
+    template<bool B>
+    using bool_ = std::integral_constant<bool, B>;
+    using true_ = bool_<true>;
+    using false_ = bool_<false>;
+
+    template<char C>
+    using char_ = std::integral_constant<char, C>;
+
+    template<typename T, typename = void>
+    struct is_integral : false_ {};
+    template<typename T>
+    struct is_integral<T, void_t<decltype(T::value)>> :
+        true_
+    {};
+
+    template<typename T, typename = assert<is_integral<T>>>
+    constexpr decltype(T::value) value()
+    {
+        return T::value;
+    }
+
+    template<template<typename...> class Function>
+    struct defer
+    {
+        template<typename... Args>
+        struct apply
+        {
+            template<typename Instance, bool = is_integral<Instance>::value>
+            struct result
+            {
+                using type = Instance;
+            };
+
+            template<typename Instance>
+            struct result<Instance, false>
+            {
+                using type = type_t<Instance>;
+            };
+
+            using type = type_t<result<Function<Args...>>>;
+        };
+    };
+
+    struct and_
+    {
+        template<typename Lhs, typename Rhs>
+        struct apply : assert<
+            is_integral<Lhs>,
+            is_integral<Rhs>
+        >
+        {
+            using type = bool_<Lhs::value && Rhs::value>;
+        };
+    };
+
+    template<typename Lhs, typename Rhs>
+    using and_t = apply_t<and_, Lhs, Rhs>;
+
+    struct or_
+    {
+        template<typename Lhs, typename Rhs>
+        struct apply : assert<
+            is_integral<Lhs>,
+            is_integral<Rhs>
+        >
+        {
+            using type = bool_<Lhs::value || Rhs::value>;
+        };
+    };
+
+    template<typename Lhs, typename Rhs>
+    using or_t = apply_t<or_, Lhs, Rhs>;
+
+    struct add_
+    {
+        template<typename Lhs, typename Rhs>
+        struct apply : assert<
+            is_integral<Lhs>,
+            is_integral<Rhs>
+        >
+        {
+            using type = std::integral_constant<decltype(Lhs::value + Rhs::value), Lhs::value + Rhs::value>;
+        };
+    };
+
+    struct div_
+    {
+        template<typename Lhs, typename Rhs>
+        struct apply : assert<
+            is_integral<Lhs>,
+            is_integral<Rhs>
+        >
+        {
+            using type = std::integral_constant<decltype(Lhs::value / Rhs::value), Lhs::value / Rhs::value>;
+        };
+    };
+
+    template<typename Lhs, typename Rhs>
+    using add_t = apply_t<add_, Lhs, Rhs>;
+
+    template<typename Lhs, typename Rhs>
+    using div_t = apply_t<div_, Lhs, Rhs>;
+
+    struct greater
+    {
+        template<typename Lhs, typename Rhs>
+        struct apply : assert<
+            is_integral<Lhs>,
+            is_integral<Rhs>
+        >
+        {
+            using type = bool_<(Lhs::value > Rhs::value)>;
+        };
+    };
+    struct greater_or_equal
+    {
+        template<typename Lhs, typename Rhs>
+        struct apply : assert<
+            is_integral<Lhs>,
+            is_integral<Rhs>
+        >
+        {
+            using type = bool_<(Lhs::value >= Rhs::value)>;
+        };
+    };
+    struct less
+    {
+        template<typename Lhs, typename Rhs>
+        struct apply : assert<
+            is_integral<Lhs>,
+            is_integral<Rhs>
+        >
+        {
+            using type = bool_<(Lhs::value < Rhs::value)>;
+        };
+    };
+    struct less_or_equal
+    {
+        template<typename Lhs, typename Rhs>
+        struct apply : assert<
+            is_integral<Lhs>,
+            is_integral<Rhs>
+        >
+        {
+            using type = bool_<(Lhs::value <= Rhs::value)>;
+        };
+    };
+
+    template<typename... Ts>
+    struct list
+    {
+        static constexpr std::size_t size = sizeof...(Ts);
+    };
+
+    template<typename... Ts>
+    constexpr std::size_t list<Ts...>::size;
+
+    template<typename List>
+    struct list_size;
+
+    template<template<typename...> class Sequence, typename... Ts>
+    struct list_size<Sequence<Ts...>> : public size_t<sizeof...(Ts)>
+    {};
+
+    template<char... Chars>
+    using string = list<std::integral_constant<char, Chars>...>;
+
+
+    template<typename Seq>
+    struct functor
+    {
+        static_assert(sizeof(Seq) != sizeof(Seq), "Type is not a sequence");
+    };
+
+    template<template<typename...> class Seq, typename... Ts>
+    struct functor<Seq<Ts...>>
+    {
+        template<typename... Us>
+        struct apply
+        {
+            using type = Seq<Us...>;
+        };
+
+        template<template<typename...> class Seq2, typename... Us>
+        struct apply<Seq2<Us...>>
+        {
+            using type = Seq<Us...>;
+        };
+    };
+
+    template<typename Seq, typename... Ts>
+    using apply_functor = apply_t<functor<Seq>, Ts...>;
+
+    template<typename Seq, typename... Ts>
+    using functor_t = apply_functor<Seq, Ts...>;
+
+    template<typename Lhs, typename Rhs>
+    struct cat;
+
+    template<template<typename...> class Seq,
+             typename... Lhs, typename... Rhs>
+    struct cat<Seq<Lhs...>, Seq<Rhs...>>
+    {
+        using type = Seq<Lhs..., Rhs...>;
+    };
+
+    template<typename Lhs, typename Rhs>
+    using cat_t = type_t<cat<Lhs, Rhs>>;
+
+    template<std::size_t I>
+    using index_t = std::integral_constant<std::size_t, I>;
+
+    template<typename T, T... Values>
+    using integer_sequence = list<std::integral_constant<T, Values>...>;
+
+    template<std::size_t... Is>
+    using index_sequence = list<index_t<Is>...>;
+
+    namespace detail
+    {
+        template<typename Left, std::size_t Index, typename Right>
+        struct split;
+
+        template<template<typename...> class Seq, std::size_t Index,
+                 typename... Left, typename Head, typename... Tail>
+        struct split<Seq<Left...>, Index, Seq<Head, Tail...>>
+        {
+            using next = split<Seq<Left..., Head>, Index - 1, Seq<Tail...>>;
+
+            using before = typename next::before;
+            using left  = typename next::left;
+            using head  = typename next::head;
+            using right = typename next::right;
+            using after = typename next::after;
+        };
+
+        template<template<typename...> class Seq,
+            typename... Left, typename Head, typename... Tail>
+        struct split<Seq<Left...>, 0, Seq<Head, Tail...>>
+        {
+            using before = Seq<Left...>;
+            using left  = Seq<Left..., Head>;
+            using head  = Head;
+            using right = Seq<Head, Tail...>;
+            using after = Seq<Tail...>;
+        };
+
+        template<template<typename...> class Seq,
+            typename Head>
+        struct split<Seq<Head>, 0, Seq<>>
+        {
+            using before = Seq<>;
+            using left  = Seq<Head>;
+            using head  = Head;
+            using right = Seq<Head>;
+            using after = Seq<>;
+        };
+    }
+
+    template<std::size_t Index, typename... Ts>
+    using pack_split = detail::split<list<>, Index, list<Ts...>>;
+    template<std::size_t Index, typename... Ts>
+    using pack_split_left_t = typename pack_split<Index, Ts...>::left;
+    template<std::size_t Index, typename... Ts>
+    using pack_get_t = typename pack_split<Index, Ts...>::head;
+    template<std::size_t Index, typename... Ts>
+    using pack_split_right_t = typename pack_split<Index, Ts...>::right;
+    template<std::size_t Index, typename... Ts>
+    using pack_split_before_t = typename pack_split<Index, Ts...>::before;
+    template<std::size_t Index, typename... Ts>
+    using pack_split_after_t = typename pack_split<Index, Ts...>::after;
+    template<typename... Ts>
+    using pack_head_t = pack_get_t<0, Ts...>;
+    template<typename... Ts>
+    using pack_tail_t = pack_split_after_t<0, Ts...>;
+
+    template<std::size_t Index, typename Seq>
+    struct split;
+    template<std::size_t Index, template<typename...> class Seq, typename... Ts>
+    struct split<Index, Seq<Ts...>>
+    {
+        using splitter = detail::split<Seq<>, Index, Seq<Ts...>>;
+
+        using before = typename splitter::before;
+        using left  = typename splitter::left;
+        using head  = typename splitter::head;
+        using right = typename splitter::right;
+        using after = typename splitter::after;
+    };
+    template<std::size_t Index, typename Seq>
+    using split_left_t = typename split<Index, Seq>::left;
+    template<std::size_t Index, typename Seq>
+    using get_t = typename split<Index, Seq>::head;
+    template<std::size_t Index, typename Seq>
+    using split_right_t = typename split<Index, Seq>::right;
+    template<std::size_t Index, typename Seq>
+    using split_before_t = typename split<Index, Seq>::before;
+    template<std::size_t Index, typename Seq>
+    using split_after_t = typename split<Index, Seq>::after;
+    template<typename Seq>
+    using head_t = get_t<0, Seq>;
+    template<typename Seq>
+    using tail_t = split_after_t<0, Seq>;
+
+
+    template<typename T, typename... Ts>
+    using pack_prepend_t = list<T, Ts...>;
+    template<typename T, typename... Ts>
+    using pack_append_t = list<Ts..., T>;
+    template<typename T, std::size_t Index, typename... Ts>
+    using pack_insert_t = cat_t<pack_append_t<pack_split_left_t<Index, Ts...>, T>, pack_split_right_t<Index, Ts...>>;
+    template<typename T, std::size_t Index, typename... Ts>
+    using pack_remove_t = cat_t<pack_split_before_t<Index, Ts...>, pack_split_after_t<Index, Ts...>>;
+
+    template<typename T, typename Seq>
+    struct prepend;
+    template<typename T, template<typename...> class Seq, typename... Ts>
+    struct prepend<T, Seq<Ts...>>
+    {
+        using type = Seq<T, Ts...>;
+    };
+    template<typename T, typename Seq>
+    struct append;
+    template<typename T, template<typename...> class Seq, typename... Ts>
+    struct append<T, Seq<Ts...>>
+    {
+        using type = Seq<Ts..., T>;
+    };
+
+    template<typename T, typename Seq>
+    using prepend_t = type_t<prepend<T, Seq>>;
+    template<typename T, typename Seq>
+    using append_t = type_t<append<Seq, T>>;
+    template<typename T, std::size_t Index, typename Seq>
+    using insert_t = cat_t<append_t<split_left_t<Index, Seq>, T>, split_right_t<Index, Seq>>;
+    template<typename T, std::size_t Index, typename Seq>
+    using remove_t = cat_t<split_before_t<Index, Seq>, split_after_t<Index, Seq>>;
+
+    namespace detail
+    {
+        template<typename Result, typename Lhs, typename Rhs, typename Compare>
+        struct merge;
+
+        template<template<typename...> class Sequence, typename... Ts, typename LhsHead, typename... LhsTail, typename RhsHead, typename... RhsTail, typename Compare>
+        struct merge<Sequence<Ts...>, Sequence<LhsHead, LhsTail...>, Sequence<RhsHead, RhsTail...>, Compare>
+        {
+            using next_result = typename std::conditional<
+                apply_t<Compare, LhsHead, RhsHead>::value,
+                Sequence<Ts..., LhsHead>,
+                Sequence<Ts..., RhsHead>
+            >::type;
+            using next_lhs = typename std::conditional<
+                apply_t<Compare, LhsHead, RhsHead>::value,
+                Sequence<LhsTail...>,
+                Sequence<LhsHead, LhsTail...>
+            >::type;
+            using next_rhs = typename std::conditional<
+                apply_t<Compare, LhsHead, RhsHead>::value,
+                Sequence<RhsHead, RhsTail...>,
+                Sequence<RhsTail...>
+            >::type;
+
+            using type = type_t<
+                merge<
+                    next_result,
+                    next_lhs,
+                    next_rhs,
+                    Compare
+                >
+            >;
+        };
+
+        template<template<typename...> class Sequence, typename... Ts, typename LhsHead, typename... LhsTail, typename Compare>
+        struct merge<Sequence<Ts...>, Sequence<LhsHead, LhsTail...>, Sequence<>, Compare>
+        {
+            using type = Sequence<Ts..., LhsHead, LhsTail...>;
+        };
+
+        template<template<typename...> class Sequence, typename... Ts, typename RhsHead, typename... RhsTail, typename Compare>
+        struct merge<Sequence<Ts...>, Sequence<>, Sequence<RhsHead, RhsTail...>, Compare>
+        {
+            using type = Sequence<Ts..., RhsHead, RhsTail...>;
+        };
+
+        template<template<typename...> class Sequence, typename... Ts, typename Compare>
+        struct merge<Sequence<Ts...>, Sequence<>, Sequence<>, Compare>
+        {
+            using type = Sequence<Ts...>;
+        };
+    }
+
+    template<typename Lhs, typename Rhs, typename Compare = less>
+    using merge = detail::merge<functor_t<Lhs>, Lhs, Rhs, Compare>;
+
+    template<typename Lhs, typename Rhs, typename Compare = less>
+    using merge_t = type_t<merge<Lhs, Rhs, Compare>>;
+
+    namespace detail
+    {
+        namespace mergesort
+        {
+            template<typename List, typename Compare>
+            struct mergesort
+            {
+                using left  = split_left_t< div_t<list_size<List>, int32_t<2>>::value, List>;
+                using right = split_after_t<div_t<list_size<List>, int32_t<2>>::value, List>;
+
+                using left_sorted  = type_t<mergesort<left,  Compare>>;
+                using right_sorted = type_t<mergesort<right, Compare>>;
+
+                using type = merge_t<left_sorted, right_sorted, Compare>;
+            };
+
+            template<template<typename...> class Sequence, typename Compare>
+            struct mergesort<Sequence<>, Compare>
+            {
+                using type = Sequence<>;
+            };
+
+            template<template<typename...> class Sequence, typename T, typename Compare>
+            struct mergesort<Sequence<T>, Compare>
+            {
+                using type = Sequence<T>;
+            };
+
+            template<template<typename...> class Sequence, typename T, typename U, typename Compare>
+            struct mergesort<Sequence<T, U>, Compare>
+            {
+                template<typename First, typename Second, bool FirstWins = apply_t<Compare, First, Second>::value>
+                struct apply
+                {
+                    using type = Sequence<First, Second>;
+                };
+
+                template<typename First, typename Second>
+                struct apply<First, Second, false>
+                {
+                    using type = Sequence<Second, First>;
+                };
+
+                using type = type_t<apply<T, U>>;
+            };
+        }
+    }
+
+    template<typename List, typename Compare = less>
+    using sort = detail::mergesort::mergesort<List, Compare>;
+
+    template<typename List, typename Compare = less>
+    using sort_t = type_t<sort<List, Compare>>;
+
+    template<typename Key, typename Value>
+    struct pair
+    {
+        using key = Key;
+        using value = Value;
+    };
+
+    template<typename Pair>
+    using key_t = typename Pair::key;
+    template<typename Pair>
+    using value_t = typename Pair::value;
+
+    template<typename... Ts>
+    struct inherit : Ts... {};
+
+    template<typename... Ts>
+    struct inherit<list<Ts...>> : Ts... {};
+
+    namespace detail
+    {
+        template<typename Ts>
+        struct aggregate;
+
+        template<template<typename...> class Seq, typename T, typename... Ts>
+        struct aggregate<Seq<T, Ts...>> : public
+            aggregate<Seq<Ts...>>
+        {
+            aggregate()                            = delete;
+            aggregate(const aggregate&)            = delete;
+            aggregate(aggregate&&)                 = delete;
+            aggregate& operator=(const aggregate&) = delete;
+            aggregate& operator=(aggregate&&)      = delete;
+
+            T member;
+        };
+
+        template<template<typename...> class Seq>
+        struct aggregate<Seq<>>
+        {
+            aggregate()                            = delete;
+            aggregate(const aggregate&)            = delete;
+            aggregate(aggregate&&)                 = delete;
+            aggregate& operator=(const aggregate&) = delete;
+            aggregate& operator=(aggregate&&)      = delete;
+        };
+    }
+
+    template<typename... Ts>
+    using aggregate = ::ctti::meta::detail::aggregate<::ctti::meta::list<Ts...>>;
+
+    template<typename...>
+    struct map;
+
+    template<typename... Keys, typename... Values>
+    struct map<pair<Keys, Values>...>
+    {
+        using keys   = list<Keys...>;
+        using values = list<Values...>;
+        using pairs  = list<pair<Keys, Values>...>;
+
+        struct key_not_found {};
+
+        template<typename Key>
+        using at_key = type_t<decltype(lookup(static_cast<inherit<pairs>*>(nullptr)))>;
+    private:
+        template<typename Key, typename Value>
+        static identity<Value> lookup(pair<Key, Value>*);
+
+        template<typename Key>
+        static identity<key_not_found> lookup(...);
+    };
+
+    template<typename Map>
+    using keys_t = typename Map::keys;
+    template<typename Map>
+    using values_t = typename Map::values;
+    template<typename Map>
+    using pairs_t = typename Map::pairs;
+    template<typename Map, typename Key>
+    using at_key = typename Map::template at_key<Key>;
+
+    template<typename Function, typename... Ts>
+    struct pack_fmap
+    {
+        using type = list<apply_t<Function, Ts>...>;
+    };
+
+    template<typename Function, typename List>
+    struct fmap;
+
+    template<typename Function, template<typename...> class Seq, typename... Ts>
+    struct fmap<Function, Seq<Ts...>>
+    {
+        using type = Seq<apply_t<Function, Ts>...>;
+    };
+
+    namespace detail
+    {
+        template<typename Predicate, typename FilteredSeq, typename Seq>
+        struct filter;
+
+        template<typename Predicate,
+                 template<typename...> class Seq, typename... Filtered, typename Head, typename... Tail>
+        struct filter<Predicate, Seq<Filtered...>, Seq<Head, Tail...>>
+        {
+            template<typename _Head = Head, bool = value<apply_t<Predicate, _Head>>()>
+            struct next
+            {
+                using type = Seq<Filtered..., Head>;
+            };
+
+            template<typename _Head>
+            struct next<_Head, false>
+            {
+                using type = Seq<Filtered...>;
+            };
+
+            using type = type_t<filter<Predicate, type_t<next<>>, Seq<Tail...>>>;
+        };
+
+        template<typename Predicate,
+            template<typename...> class Seq, typename... Filtered>
+        struct filter<Predicate, Seq<Filtered...>, Seq<>>
+        {
+            using type = Seq<Filtered...>;
+        };
+    }
+
+    template<typename Function, typename Seed, typename Seq>
+    struct foldl;
+
+    template<typename Function, typename Seed,
+             template<typename...> class Seq, typename Head, typename... Tail>
+    struct foldl<Function, Seed, Seq<Head, Tail...>>
+    {
+        using type = type_t<
+            foldl<Function,
+                  apply_t<Function, Seed, Head>,
+                  Seq<Tail...>
+            >
+        >;
+    };
+
+    template<typename Function, typename Seed,
+             template<typename...> class Seq>
+    struct foldl<Function, Seed, Seq<>>
+    {
+        using type = Seed;
+    };
+
+    template<typename Function, typename Seed, typename Seq>
+    struct foldr;
+
+    template<typename Function, typename Seed,
+        template<typename...> class Seq, typename Head, typename... Tail>
+    struct foldr<Function, Seed, Seq<Head, Tail...>>
+    {
+        using type = apply_t<
+            Function, Head,
+            type_t<foldr<Function, Seed, Seq<Tail...>>>
+        >;
+    };
+
+    template<typename Function, typename Seed,
+        template<typename...> class Seq>
+    struct foldr<Function, Seed, Seq<>>
+    {
+        using type = Seed;
+    };
+
+    template<typename Function, typename... Ts>
+    using pack_fmap_t = type_t<pack_fmap<Function, Ts...>>;
+    template<typename Function, typename Seq>
+    using fmap_t = type_t<fmap<Function, Seq>>;
+
+    template<typename Function, typename Seed, typename... Seq>
+    using pack_foldl = foldl<Function, Seed, list<Seq...>>;
+    template<typename Function, typename Seed, typename... Seq>
+    using pack_foldl_t = type_t<pack_foldl<Function, Seed, Seq...>>;
+    template<typename Function, typename Seed, typename Seq>
+    using foldl_t = type_t<foldl<Function, Seed, Seq>>;
+
+    template<typename Function, typename Seed, typename... Seq>
+    using pack_foldr = foldr<Function, Seed, list<Seq...>>;
+    template<typename Function, typename Seed, typename... Seq>
+    using pack_foldr_t = type_t<pack_foldr<Function, Seed, Seq...>>;
+    template<typename Function, typename Seed, typename Seq>
+    using foldr_t = type_t<foldr<Function, Seed, Seq>>;
+
+    template<typename Predicate, typename Seq>
+    using filter = detail::filter<Predicate, apply_functor<Seq>, Seq>;
+    template<typename Predicate, typename Seq>
+    using filter_t = type_t<filter<Predicate, Seq>>;
+    template<typename Predicate, typename... Seq>
+    using pack_filter = detail::filter<Predicate, list<>, list<Seq...>>;
+    template<typename Predicate, typename... Seq>
+    using pack_filter_t = type_t<pack_filter<Predicate, Seq...>>;
+
+    template<typename Bs>
+    using any_of = foldl<or_, false_, Bs>;
+    template<typename Bs>
+    using any_of_t = foldl_t<or_, false_, Bs>;
+    template<typename... Bs>
+    using pack_any_of = pack_foldl<or_, false_, Bs...>;
+    template<typename... Bs>
+    using pack_any_of_t = pack_foldl_t<or_, false_, Bs...>;
+
+    template<typename Bs>
+    using any_of = foldl<or_, false_, Bs>;
+    template<typename Bs>
+    using any_of_t = foldl_t<or_, false_, Bs>;
+    template<typename... Bs>
+    using pack_any_of = pack_foldl<or_, false_, Bs...>;
+    template<typename... Bs>
+    using pack_any_of_t = pack_foldl_t<or_, false_, Bs...>;
+
+    template<typename... Seqs>
+    using join = foldl<defer<cat>, apply_functor<pack_get_t<0, Seqs...>>, apply_functor<pack_get_t<0, Seqs...>, Seqs...>>;
+    template<typename... Seqs>
+    using join_t = type_t<join<Seqs...>>;
+
+    namespace detail
+    {
+        template<template<typename...> class Seq, std::size_t N>
+        struct make_index_sequence
+        {
+            static constexpr std::size_t n = (N % 2) ? ((N - 1) / 2) : (N / 2);
+            static constexpr std::size_t m = N - n;
+
+            struct adder
+            {
+                template<typename T>
+                struct apply
+                {
+                    using type = apply_t<add_, size_t<n>, T>;
+                };
+            };
+
+            using type = cat_t<
+                type_t<make_index_sequence<Seq, n>>,
+                fmap_t<adder, type_t<make_index_sequence<Seq, m>>>
+            >;
+        };
+
+        template<template<typename...> class Seq>
+        struct make_index_sequence<Seq, 1>
+        {
+            using type = Seq<size_t<0>>;
+        };
+
+        template<template<typename...> class Seq>
+        struct make_index_sequence<Seq, 0>
+        {
+            using type = Seq<>;
+        };
+    }
+
+    template<std::size_t N, template<typename...> class Seq = list>
+    using make_index_sequence = type_t<detail::make_index_sequence<Seq, N>>;
+    template<typename... Ts>
+    using make_index_sequence_for = make_index_sequence<sizeof...(Ts)>;
+    template<typename Seq>
+    struct to_index_sequence;
+    template<template<typename...> class Seq, typename... Ts>
+    struct to_index_sequence<Seq<Ts...>>
+    {
+        using type = make_index_sequence<sizeof...(Ts), Seq>;
+    };
+    template<typename Seq>
+    using to_index_sequence_t = type_t<to_index_sequence<Seq>>;
+
+    template<typename Seq>
+    using make_index_sequence_from_sequence = ctti::meta::functor_t<ctti::meta::list<>, ctti::meta::to_index_sequence_t<Seq>>;
+
+    namespace detail
+    {
+        template<typename Function, typename... Ts, std::size_t... Indices>
+        void foreach(ctti::meta::list<Ts...>, ctti::meta::index_sequence<Indices...>, Function function)
+        {
+            (void)function;
+            [](...){}(std::array<int, sizeof...(Ts) + 1>{{(function(ctti::meta::identity<Ts>(), ctti::meta::size_t<Indices>()), 0)..., 0}});
+        }
+    }
+
+    template<typename Sequence, typename Function>
+    void foreach(Function function)
+    {
+        ctti::meta::detail::foreach(ctti::meta::apply_functor<ctti::meta::list<>, Sequence>(), ctti::meta::make_index_sequence_from_sequence<Sequence>(), function);
+    }
+}
+
+}
+
+#endif // CTTI_UTILITY_META_H
diff --git a/include/cereal/external/ctti/detail/name_filters.hpp b/include/cereal/external/ctti/detail/name_filters.hpp
new file mode 100644
index 00000000..4fe208c1
--- /dev/null
+++ b/include/cereal/external/ctti/detail/name_filters.hpp
@@ -0,0 +1,77 @@
+#ifndef CTTI_DETAIL_NAMEFILTERS_HPP
+#define CTTI_DETAIL_NAMEFILTERS_HPP
+
+#include "cstring.hpp"
+
+namespace ctti
+{
+
+namespace detail
+{
+
+constexpr ctti::detail::cstring filter_prefix(const ctti::detail::cstring& str, const ctti::detail::cstring& prefix)
+{
+    return str.size() >= prefix.size() ? (str(0, prefix.size()) == prefix ? str(prefix.size(), str.size()) : str) : str;
+}
+
+constexpr ctti::detail::cstring leftpad(const ctti::detail::cstring& str)
+{
+    return (str.size() > 0 && str[0] == ' ') ? leftpad(str(1, str.size())) : str;
+}
+
+constexpr ctti::detail::cstring filter_class(const ctti::detail::cstring& type_name)
+{
+    return leftpad(filter_prefix(leftpad(type_name), "class"));
+}
+
+constexpr ctti::detail::cstring filter_struct(const ctti::detail::cstring& type_name)
+{
+    return leftpad(filter_prefix(leftpad(type_name), "struct"));
+}
+
+constexpr ctti::detail::cstring filter_typename_prefix(const ctti::detail::cstring& type_name)
+{
+    return filter_struct(filter_class(type_name));
+}
+
+namespace
+{
+
+constexpr const char* find_ith_impl(const ctti::detail::cstring& name, const ctti::detail::cstring& substring, const char* res, std::size_t i, bool infinite = false)
+{
+    return (name.length() >= substring.length()) ?
+        ((name(0, substring.length()) == substring) ?
+            ((i == 0) ?
+                name.begin()
+            :
+                find_ith_impl(name(substring.length(), name.length()), substring, name.begin(), i - 1, infinite))
+        :
+            find_ith_impl(name(1, name.length()), substring, res, i, infinite))
+        :
+            (!infinite) ? name.end() : res;
+}
+
+}
+
+constexpr const char* find_ith(const ctti::detail::cstring& name, const ctti::detail::cstring& substring, std::size_t i)
+{
+    return find_ith_impl(name, substring, name.end(), i);
+}
+
+constexpr const char* find_last(const ctti::detail::cstring& name, const ctti::detail::cstring& substring)
+{
+    return find_ith_impl(name, substring, name.end(), -1, true);
+}
+
+constexpr const char* find(const ctti::detail::cstring& name, const ctti::detail::cstring& substring)
+{
+    return find_ith(name, substring, 0);
+}
+
+
+
+}
+
+}
+
+#endif // CTTI_DETAIL_NAMEFILTERS_HPP
diff --git a/include/cereal/external/ctti/detail/preprocessor.hpp b/include/cereal/external/ctti/detail/preprocessor.hpp
new file mode 100644
index 00000000..ff838f9a
--- /dev/null
+++ b/include/cereal/external/ctti/detail/preprocessor.hpp
@@ -0,0 +1,7 @@
+#ifndef CTTI_DETAIL_PREPROCESSOR_HPP
+#define CTTI_DETAIL_PREPROCESSOR_HPP
+
+#define CTTI_PP_STR_IMPL(x) #x
+#define CTTI_PP_STR(x) CTTI_PP_STR_IMPL(x)
+
+#endif // CTTI_DETAIL_PREPROCESSOR_HPP
diff --git a/include/cereal/external/ctti/detail/pretty_function.hpp b/include/cereal/external/ctti/detail/pretty_function.hpp
new file mode 100644
index 00000000..22a2ed8e
--- /dev/null
+++ b/include/cereal/external/ctti/detail/pretty_function.hpp
@@ -0,0 +1,78 @@
+//
+// Created by manu343726 on 4/08/15.
+//
+
+#ifndef CTTI_PRETTY_FUNCTION_HPP
+#define CTTI_PRETTY_FUNCTION_HPP
+
+#include "cstring.hpp"
+
+#if defined(__clang__)
+    #define CTTI_PRETTY_FUNCTION __PRETTY_FUNCTION__
+#elif defined(__GNUC__) && !defined(__clang__)
+    #define CTTI_PRETTY_FUNCTION __PRETTY_FUNCTION__
+#elif defined(_MSC_VER)
+    #define CTTI_PRETTY_FUNCTION __FUNCSIG__
+#else
+    #error "No support for this compiler."
+#endif
+
+namespace ctti
+{
+
+namespace pretty_function
+{
+
+template<typename T>
+constexpr ctti::detail::cstring type()
+{
+    return {CTTI_PRETTY_FUNCTION};
+}
+
+template<typename T, T Value>
+constexpr ctti::detail::cstring value()
+{
+    return {CTTI_PRETTY_FUNCTION};
+}
+
+}
+
+}
+
+#if defined(__clang__)
+    #define CTTI_TYPE_PRETTY_FUNCTION_PREFIX "ctti::detail::cstring ctti::pretty_function::type() [T = "
+    #define CTTI_TYPE_PRETTY_FUNCTION_SUFFIX "]"
+#elif defined(__GNUC__) && !defined(__clang__)
+    #define CTTI_TYPE_PRETTY_FUNCTION_PREFIX "constexpr ctti::detail::cstring ctti::pretty_function::type() [with T = "
+    #define CTTI_TYPE_PRETTY_FUNCTION_SUFFIX "]"
+#elif defined(_MSC_VER)
+    #define CTTI_TYPE_PRETTY_FUNCTION_PREFIX "struct ctti::detail::cstring __cdecl ctti::pretty_function::type<"
+    #define CTTI_TYPE_PRETTY_FUNCTION_SUFFIX ">(void)"
+#else
+    #error "No support for this compiler."
+#endif
+
+#define CTTI_TYPE_PRETTY_FUNCTION_LEFT (sizeof(CTTI_TYPE_PRETTY_FUNCTION_PREFIX) - 1)
+#define CTTI_TYPE_PRETTY_FUNCTION_RIGHT (sizeof(CTTI_TYPE_PRETTY_FUNCTION_SUFFIX) - 1)
+
+#if defined(__clang__)
+    #define CTTI_VALUE_PRETTY_FUNCTION_PREFIX "ctti::detail::cstring ctti::pretty_function::value() [T = "
+    #define CTTI_VALUE_PRETTY_FUNCTION_SEPARATOR "; Value = "
+    #define CTTI_VALUE_PRETTY_FUNCTION_SUFFIX "]"
+#elif defined(__GNUC__) && !defined(__clang__)
+    #define CTTI_VALUE_PRETTY_FUNCTION_PREFIX "constexpr ctti::detail::cstring ctti::pretty_function::value() [with T = "
+    #define CTTI_VALUE_PRETTY_FUNCTION_SEPARATOR "; T Value = "
+    #define CTTI_VALUE_PRETTY_FUNCTION_SUFFIX "]"
+#elif defined(_MSC_VER)
+    #define CTTI_VALUE_PRETTY_FUNCTION_PREFIX "struct ctti::detail::cstring __cdecl ctti::pretty_function::value<"
+    #define CTTI_VALUE_PRETTY_FUNCTION_SEPARATOR "; T Value = "
+    #define CTTI_VALUE_PRETTY_FUNCTION_SUFFIX ">(void)"
+#else
+    #error "No support for this compiler."
+#endif
+
+#define CTTI_VALUE_PRETTY_FUNCTION_LEFT (sizeof(CTTI_VALUE_PRETTY_FUNCTION_PREFIX) - 1)
+#define CTTI_VALUE_PRETTY_FUNCTION_SEPARATION (sizeof(CTTI_VALUE_PRETTY_FUNCTION_SEPARATOR) - 1)
+#define CTTI_VALUE_PRETTY_FUNCTION_RIGHT (sizeof(CTTI_VALUE_PRETTY_FUNCTION_SUFFIX) - 1)
+
+#endif //CTTI_PRETTY_FUNCTION_HPP
diff --git a/include/cereal/external/ctti/detailed_nameof.hpp b/include/cereal/external/ctti/detailed_nameof.hpp
new file mode 100644
index 00000000..23af837e
--- /dev/null
+++ b/include/cereal/external/ctti/detailed_nameof.hpp
@@ -0,0 +1,35 @@
+#ifndef CTTI_DETAILED_NAMEOF_HPP
+#define CTTI_DETAILED_NAMEOF_HPP
+
+#include <ctti/nameof.hpp>
+#include <ctti/name.hpp>
+#include <ctti/detail/language_features.hpp>
+
+namespace ctti
+{
+
+
+template<typename T>
+constexpr name_t detailed_nameof()
+{
+    return {ctti::nameof<T>()};
+}
+
+template<typename T, T Value>
+constexpr name_t detailed_nameof()
+{
+    return {ctti::nameof<T, Value>()};
+}
+
+#ifdef CTTI_HAS_VARIABLE_TEMPLATES
+template<typename T>
+constexpr ctti::name_t detailed_nameof_v = ctti::detailed_nameof<T>();
+
+// CONSIDER USING detailed_nameof_v<CTTI_STATIC_VALUE(value)> INSTEAD
+template<typename T, T Value>
+constexpr ctti::name_t detailed_nameof_value_v = ctti::detailed_nameof<T, Value>();
+#endif // CTTI_HAS_VARIABLE_TEMPLATES
+
+}
+
+#endif // CTTI_DETAILED_NAMEOF_HPP
diff --git a/include/cereal/external/ctti/hash_literal.hpp b/include/cereal/external/ctti/hash_literal.hpp
new file mode 100644
index 00000000..f6b4afbc
--- /dev/null
+++ b/include/cereal/external/ctti/hash_literal.hpp
@@ -0,0 +1,20 @@
+#ifndef CTTI_HASH_LITERAL_HPP
+#define CTTI_HASH_LITERAL_HPP
+
+#include <ctti/detail/cstring.hpp>
+
+#ifdef CTI_HASH_LITERAL_NAMESPACE
+namespace CTTI_HASH_LITERAL_NAMESPACE
+{
+#endif // CTTI_HASH_LITERAL_NAMESPACE
+
+constexpr std::uint64_t operator"" _sh(const char* str, std::size_t length)
+{
+    return ctti::detail::cstring{str, length}.hash();
+}
+
+#ifdef CTTI_HASH_LITERAL_NAMESPACE
+}
+#endif // CTTI_HASH_LITERAL_NAMESPACE
+
+#endif // CTTI_HASH_LITERAL_HPP
diff --git a/include/cereal/external/ctti/map.hpp b/include/cereal/external/ctti/map.hpp
new file mode 100644
index 00000000..be933fa4
--- /dev/null
+++ b/include/cereal/external/ctti/map.hpp
@@ -0,0 +1,79 @@
+#ifndef CTTI_MAP_HPP
+#define CTTI_MAP_HPP
+
+#include <ctti/symbol.hpp>
+
+namespace ctti
+{
+
+struct default_symbol_mapping_function
+{
+    constexpr default_symbol_mapping_function() = default;
+
+    template<typename Source, typename SourceSymbol, typename Sink, typename SinkSymbol>
+    void operator()(const Source& source, SourceSymbol, Sink& sink, SinkSymbol) const
+    {
+        ctti::set_member_value<SinkSymbol>(sink, ctti::get_member_value<SourceSymbol>(source));
+    }
+};
+
+template<typename SourceSymbol, typename SinkSymbol, typename Source, typename Sink, typename Function>
+void map(const Source& source, Sink& sink, const Function& function)
+{
+    function(source, SourceSymbol(), sink, SinkSymbol());
+}
+
+template<typename SourceSymbol, typename SinkSymbol, typename Source, typename Sink>
+void map(const Source& source, Sink& sink)
+{
+    ctti::map<SourceSymbol, SinkSymbol>(source, sink, ctti::default_symbol_mapping_function());
+}
+
+template<typename SourceSymbol, typename SinkSymbol, typename Function = default_symbol_mapping_function>
+struct symbol_mapping
+{
+    constexpr symbol_mapping(Function function) :
+        function{function}
+    {}
+
+    Function function;
+
+    template<typename Source, typename Sink>
+    auto operator()(const Source& source, SourceSymbol, Sink& sink, SinkSymbol) const ->
+        ctti::meta::void_t<decltype(std::declval<Function>()(source, SourceSymbol(), sink, SinkSymbol()))>
+    {
+        function(source, SourceSymbol(), sink, SinkSymbol());
+    }
+
+    template<typename Source, typename Sink>
+    auto operator()(const Source& source, SourceSymbol, Sink& sink, SinkSymbol) const ->
+        ctti::meta::void_t<decltype(std::declval<Function>()(ctti::get_member_value<SourceSymbol>(source), ctti::type_tag<typename SinkSymbol::template value_type<Sink>>()))>
+    {
+        ctti::set_member_value<SinkSymbol>(sink, function(
+            ctti::get_member_value<SourceSymbol>(source),
+            ctti::type_tag<typename SinkSymbol::template value_type<Sink>>()
+        ));
+    }
+};
+
+template<typename SourceSymbol, typename SinkSymbol, typename Function>
+constexpr ctti::symbol_mapping<SourceSymbol, SinkSymbol, ctti::meta::decay_t<Function>> mapping(const Function& function)
+{
+    return {function};
+}
+
+template<typename SourceSymbol, typename SinkSymbol>
+constexpr ctti::symbol_mapping<SourceSymbol, SinkSymbol> mapping()
+{
+    return {ctti::default_symbol_mapping_function()};
+}
+
+template<typename Source, typename Sink, typename... SourceSymbols, typename... SinkSymbols, typename... MappingFunctions>
+void map(const Source& source, Sink& sink, const ctti::symbol_mapping<SourceSymbols, SinkSymbols, MappingFunctions>&... mapping)
+{
+    [](...){}((map<SourceSymbols, SinkSymbols>(source, sink, mapping), 0)...);
+}
+
+}
+
+#endif // CTTI_MAP_HPP
diff --git a/include/cereal/external/ctti/model.hpp b/include/cereal/external/ctti/model.hpp
new file mode 100644
index 00000000..134743d7
--- /dev/null
+++ b/include/cereal/external/ctti/model.hpp
@@ -0,0 +1,45 @@
+#ifndef CTTI_MODEL_HPP
+#define CTTI_MODEL_HPP
+
+#include <ctti/detail/meta.hpp>
+#include <ctti/symbol.hpp>
+#include <ctti/type_tag.hpp>
+
+namespace ctti
+{
+
+template<typename... Symbols>
+struct model
+{
+    using symbols = ctti::meta::list<Symbols...>;
+};
+
+template<typename T>
+ctti::model<> ctti_model(ctti::type_tag<T>);
+
+namespace detail
+{
+    template<typename T, typename = void>
+    struct get_model
+    {
+        using type = decltype(ctti_model(ctti::type_tag<T>()));
+    };
+
+    template<typename T>
+    struct get_model<T, ctti::meta::void_t<typename T::ctti_model>>
+    {
+        using type = typename T::ctti_model;
+    };
+}
+
+template<typename T>
+using get_model = typename ctti::detail::get_model<T>::type;
+
+template<typename T>
+struct has_model : public ctti::meta::bool_<
+    (ctti::meta::list_size<ctti::get_model<T>>() > 0)
+> {};
+
+}
+
+#endif // CTTI_MODEL_HPP
diff --git a/include/cereal/external/ctti/name.hpp b/include/cereal/external/ctti/name.hpp
new file mode 100644
index 00000000..36f8fe22
--- /dev/null
+++ b/include/cereal/external/ctti/name.hpp
@@ -0,0 +1,86 @@
+#ifndef CTTI_NAME_HPP
+#define CTTI_NAME_HPP
+
+#include <ctti/detail/cstring.hpp>
+#include <ctti/detail/name_filters.hpp>
+
+namespace ctti
+{
+
+struct name_t
+{
+    constexpr name_t(const ctti::detail::cstring& full_name) :
+        _full_name{full_name}
+    {}
+
+    constexpr ctti::detail::cstring name() const
+    {
+        return ctti::detail::find_last(_full_name, "::") == _full_name.end() ?
+            _full_name : ctti::detail::cstring{ctti::detail::find_last(_full_name, "::") + 2, _full_name.end()};
+    }
+
+    constexpr ctti::detail::cstring full_name() const
+    {
+        return _full_name;
+    }
+
+    constexpr ctti::detail::cstring full_homogeneous_name() const
+    {
+        return ctti::detail::filter_prefix(full_name(), "&");
+    }
+
+    constexpr ctti::detail::cstring qualifier(std::size_t i) const
+    {
+        return (i > 0) ? get_qualifier(
+            ctti::detail::find_ith(_full_name, "::", i - 1) + 2,
+            ctti::detail::find_ith(_full_name, "::", i)
+        ) : (ctti::detail::find_ith(_full_name, "::", i) != _full_name.end()) ?
+            ctti::detail::cstring{_full_name.begin(), ctti::detail::find_ith(_full_name, "::", i)} :
+            ctti::detail::cstring{""};
+    }
+
+private:
+    ctti::detail::cstring _full_name;
+
+    constexpr ctti::detail::cstring right(const ctti::detail::cstring& str) const
+    {
+        return {ctti::detail::min(_full_name.end(), str.begin()), _full_name.end()};
+    }
+
+    constexpr ctti::detail::cstring left(const char* end) const
+    {
+        return (end < _full_name.end()) ?
+            ctti::detail::cstring{_full_name.begin(), end}
+        :
+            ctti::detail::cstring{""};
+    }
+
+    constexpr ctti::detail::cstring get_name(const ctti::detail::cstring& name) const
+    {
+        return (name != "") ? name : _full_name;
+    }
+
+    constexpr ctti::detail::cstring get_qualifier(const char* begin, const char* end) const
+    {
+        return get_qualifier_impl(begin, end);
+    }
+
+    constexpr ctti::detail::cstring get_qualifier_impl(const char* begin, const char* end) const
+    {
+        return (end == _full_name.end()) ? ctti::detail::cstring{""} : ctti::detail::cstring{begin, end};
+    }
+};
+
+constexpr bool operator==(const name_t& lhs, const name_t rhs)
+{
+    return lhs.full_name() == rhs.full_name();
+}
+
+constexpr bool operator!=(const name_t& lhs, const name_t rhs)
+{
+    return !(lhs == rhs);
+}
+
+}
+
+#endif // CTTI_NAME_HPP
diff --git a/include/cereal/external/ctti/nameof.hpp b/include/cereal/external/ctti/nameof.hpp
new file mode 100644
index 00000000..9dbfb946
--- /dev/null
+++ b/include/cereal/external/ctti/nameof.hpp
@@ -0,0 +1,149 @@
+#ifndef CTTI_NAMEOF_HPP
+#define CTTI_NAMEOF_HPP
+
+#include "detail/pretty_function.hpp"
+#include "detail/name_filters.hpp"
+#include "detail/meta.hpp"
+#include "detail/language_features.hpp"
+#include "type_tag.hpp"
+#include "static_value.hpp"
+#include <type_traits>
+#include <cstdint>
+
+namespace ctti
+{
+
+template<typename T>
+constexpr ctti::detail::cstring nameof();
+
+template<typename T, T Value>
+constexpr ctti::detail::cstring nameof();
+
+namespace detail
+{
+
+template<typename T, typename = void>
+struct TypeNameLength :
+    std::integral_constant<
+        std::size_t,
+        ctti::nameof<T>().length()
+    >
+{};
+
+template<typename R, typename Class>
+struct TypeNameLength<R Class::*, void> :
+    std::integral_constant<
+        std::size_t,
+        ctti::nameof<R Class::*>().length()
+    >
+{};
+
+template<typename Enum>
+struct TypeNameLength<Enum, typename std::enable_if<std::is_enum<Enum>::value>::type> :
+    std::integral_constant<
+        std::size_t,
+        ctti::nameof<Enum>().length()
+    >
+{};
+
+}
+
+template<typename T, T Value>
+constexpr ctti::detail::cstring nameof();
+
+namespace detail
+{
+
+template<typename T>
+struct another_level_of_indirection {};
+
+template<typename T, typename = void>
+struct nameof_impl
+{
+    static constexpr ctti::detail::cstring apply()
+    {
+        return ctti::detail::filter_typename_prefix(ctti::pretty_function::type<T>().pad(
+            CTTI_TYPE_PRETTY_FUNCTION_LEFT,
+            CTTI_TYPE_PRETTY_FUNCTION_RIGHT
+        ));
+    }
+};
+
+template<typename T>
+struct nameof_impl<T, ctti::meta::void_t<decltype(T::ctti_nameof())>>
+{
+    static constexpr ctti::detail::cstring apply()
+    {
+        return T::ctti_nameof();
+    }
+};
+
+template<typename T, T Value>
+struct nameof_impl<another_level_of_indirection<ctti::static_value<T, Value>>, void>
+{
+    static constexpr ctti::detail::cstring apply()
+    {
+        return ctti::pretty_function::value<T, Value>().pad(
+            CTTI_VALUE_PRETTY_FUNCTION_LEFT + ctti::detail::TypeNameLength<T>::value + CTTI_VALUE_PRETTY_FUNCTION_SEPARATION,
+            CTTI_VALUE_PRETTY_FUNCTION_RIGHT
+        );
+    }
+};
+
+template<typename T, T Value>
+struct nameof_impl<ctti::static_value<T, Value>, void>
+{
+    static constexpr ctti::detail::cstring apply()
+    {
+        return ctti::nameof<T, Value>();
+    }
+};
+
+}
+
+template<typename T>
+constexpr ctti::detail::cstring ctti_nameof(ctti::type_tag<T>)
+{
+    return ctti::detail::nameof_impl<T>::apply();
+}
+
+template<typename T, T Value>
+constexpr ctti::detail::cstring ctti_nameof(ctti::static_value<T, Value>)
+{
+    return ctti::detail::nameof_impl<ctti::detail::another_level_of_indirection<ctti::static_value<T, Value>>>::apply();
+}
+
+template<typename T>
+constexpr ctti::detail::cstring nameof()
+{
+    using namespace ctti;
+    return ctti_nameof(ctti::type_tag<T>());
+}
+
+template<typename T, T Value>
+constexpr ctti::detail::cstring nameof()
+{
+    using namespace ctti;
+    return ctti_nameof(ctti::static_value<T, Value>());
+}
+
+#ifdef CTTI_HAS_VARIABLE_TEMPLATES
+template<typename T>
+constexpr ctti::detail::cstring nameof_v = ctti::nameof<T>();
+
+// CONSIDER USING nameof_v<CTTI_STATIC_VALUE(value)> INSTEAD
+template<typename T, T Value>
+constexpr ctti::detail::cstring nameof_value_v = ctti::nameof<T, Value>();
+#endif // CTTI_HAS_VARIABLE_TEMPLATES
+
+}
+
+namespace std
+{
+constexpr ctti::detail::cstring ctti_nameof(ctti::type_tag<std::string>)
+{
+    return "std::string";
+}
+}
+
+#endif // CTTI_NAMEOF_HPP
diff --git a/include/cereal/external/ctti/serialization.hpp b/include/cereal/external/ctti/serialization.hpp
new file mode 100644
index 00000000..3df4e04c
--- /dev/null
+++ b/include/cereal/external/ctti/serialization.hpp
@@ -0,0 +1,656 @@
+#ifndef CTTI_SERIALIZATION_HPP
+#define CTTI_SERIALIZATION_HPP
+
+#include <ctti/symbol.hpp>
+#include <ctti/model.hpp>
+#include <ctti/detail/nlohmann_json.hpp>
+#include <vector>
+#include <unordered_map>
+#include <array>
+#include <tuple>
+
+namespace ctti
+{
+
+namespace serialization
+{
+
+template<typename Formatter, typename Output, typename T>
+void serialize(Formatter formatter, Output& output, const T& value);
+
+template<typename Writer, typename T>
+void serialize(Writer writer, const T& value);
+
+template<typename Reader, typename T>
+void deserialize(Reader reader, T& value);
+
+namespace detail
+{
+    template<typename T, bool IsEnum = std::is_enum<T>(), bool EmptyModel = ctti::meta::list_size<ctti::get_model<T>>() == 0>
+    struct serialize
+    {
+        using Model = ctti::get_model<T>;
+
+        template<typename Writer>
+        struct loop_body
+        {
+            Writer* writer;
+            const T* value;
+
+            template<typename SymbolIdentity, typename Index>
+            void operator()(SymbolIdentity, Index)
+            {
+                using Symbol = ctti::meta::type_t<SymbolIdentity>;
+                constexpr std::size_t index = Index();
+
+                writer->value(Symbol::symbol().str(), ctti::get_member_value<Symbol>(*value));
+
+                if(index + 1 < ctti::meta::list_size<Model>())
+                {
+                    writer->value_separator();
+                }
+            }
+        };
+
+        template<typename Writer>
+        static void apply(Writer& writer, const T& value)
+        {
+            loop_body<Writer> loop_body{&writer, &value};
+
+            writer.begin_object(value);
+                ctti::meta::foreach<Model>(loop_body);
+            writer.end_object(value);
+        }
+    };
+
+    template<typename T>
+    struct serialize<T, true, false>
+    {
+        using Model = ctti::get_model<T>;
+
+        template<typename Writer>
+        struct loop_body
+        {
+            Writer* writer;
+            const T* value;
+
+            template<typename SymbolIdentity, typename Index>
+            void operator()(SymbolIdentity, Index)
+            {
+                using Symbol = ctti::meta::type_t<SymbolIdentity>;
+
+                if(Symbol::template get_member<T>() == *value)
+                {
+                    // Found the enumeration value with this value
+                    writer->raw_value(Symbol::symbol().str());
+                }
+            }
+        };
+
+        template<typename Writer>
+        static void apply(Writer& writer, const T& value)
+        {
+            loop_body<Writer> loop_body{&writer, &value};
+            ctti::meta::foreach<Model>(loop_body);
+        }
+    };
+
+    template<typename T, bool IsEnum>
+    struct serialize<T, IsEnum, true>
+    {
+        template<typename Writer>
+        static void apply(Writer& writer, const T& value)
+        {
+            writer.value(value);
+        }
+    };
+
+    template<typename T, bool IsEnum = std::is_enum<T>::value, bool HasModel = ctti::has_model<T>::value>
+    struct deserialize
+    {
+        using Model = ctti::get_model<T>;
+
+        template<typename Reader>
+        struct loop_body
+        {
+            Reader* reader;
+            T* value;
+
+            template<typename SymbolIdentity, typename Index>
+            void operator()(SymbolIdentity, Index)
+            {
+                using Symbol = ctti::meta::type_t<SymbolIdentity>;
+                reader->value(Symbol::symbol().str(), ctti::get_member_value<Symbol>(*value));
+            }
+        };
+
+        template<typename Reader>
+        static void apply(Reader& reader, T& value)
+        {
+            loop_body<Reader> loop_body{&reader, &value};
+            ctti::meta::foreach<Model>(loop_body);
+        }
+    };
+
+    template<typename T>
+    struct deserialize<T, true, true>
+    {
+        using Model = ctti::get_model<T>;
+
+        template<typename InputValue, typename ValueType = T>
+        struct loop_body
+        {
+            T* value;
+            InputValue input_value;
+
+            template<typename SymbolIdentity, typename Index>
+            void operator()(SymbolIdentity, Index)
+            {
+                using Symbol = ctti::meta::type_t<SymbolIdentity>;
+
+                if(static_cast<typename std::underlying_type<T>::type>(Symbol::template get_member<T>()) ==
+                   static_cast<typename std::underlying_type<T>::type>(input_value))
+                {
+                    *value = Symbol::template get_member<T>();
+                }
+            }
+        };
+
+        template<typename ValueType>
+        struct loop_body<std::string, ValueType>
+        {
+            T* value;
+            std::string input_value;
+
+            template<typename SymbolIdentity, typename Index>
+            void operator()(SymbolIdentity, Index)
+            {
+                using Symbol = ctti::meta::type_t<SymbolIdentity>;
+
+                if(Symbol::symbol().str() == input_value)
+                {
+                    *value = Symbol::template get_member<T>();
+                }
+            }
+        };
+
+        struct callback
+        {
+            template<typename InputValue>
+            T operator()(const InputValue& input_value)
+            {
+                T output_value{};
+                ctti::meta::foreach<Model>(loop_body<InputValue>{&output_value, input_value});
+                return output_value;
+            }
+        };
+
+        template<typename Reader>
+        static void apply(Reader& reader, T& value)
+        {
+            reader.enum_value(value, callback());
+        }
+    };
+
+    template<typename T, bool IsEnum>
+    struct deserialize<T, IsEnum, false>
+    {
+        template<typename Reader>
+        static void apply(Reader& reader, T& value)
+        {
+            reader.value(value);
+        }
+    };
+}
+
+template<typename Formatter, typename Output>
+struct Writer
+{
+    Writer(Formatter formatter, Output& output) :
+        _formatter{formatter},
+        _output{&output}
+    {}
+
+    void value_separator()
+    {
+        _formatter.value_separator(*_output);
+    }
+
+    template<typename T>
+    void raw_value(const T& value)
+    {
+        _formatter.raw_value(*_output, value);
+    }
+
+    template<typename T>
+    void value(const T& value)
+    {
+        _formatter.value(*_output, value);
+    }
+
+    template<typename T>
+    void value(const std::string& name, const T& value)
+    {
+        _formatter.value(*_output, name, value);
+    }
+
+    template<typename T>
+    void begin_object(const T& object)
+    {
+        _formatter.begin_object(*_output, object);
+    }
+
+    template<typename T>
+    void end_object(const T& object)
+    {
+        _formatter.end_object(*_output, object);
+    }
+
+private:
+    Formatter _formatter;
+    Output* _output;
+};
+
+template<typename Formatter, typename Output>
+Writer<Formatter, Output> make_writer(Formatter formatter, Output& output)
+{
+    return {formatter, output};
+}
+
+struct ostream_otuput
+{
+    ostream_otuput(std::ostream& os) :
+        os(&os)
+    {}
+
+    template<typename T>
+    void write(const T& value)
+    {
+        (*os) << value;
+    }
+
+private:
+    std::ostream* os;
+};
+
+struct json_formatter
+{
+    template<typename Output, typename T>
+    void raw_value(Output& output, const T& value)
+    {
+        output.write(value);
+    }
+
+    template<typename Output>
+    void value_separator(Output& out)
+    {
+        out.write(", ");
+    }
+
+    template<typename Output, typename T>
+    void begin_object(Output& out, const T&)
+    {
+        out.write("{");
+    }
+
+    template<typename Output, typename T>
+    void end_object(Output& out, const T&)
+    {
+        out.write("}");
+    }
+
+    template<typename Output, typename T>
+    void value(Output& out, const std::string& name, const T& value)
+    {
+        out.write("\""); out.write(name); out.write("\": "); this->value(out, value);
+    }
+
+    template<typename Output, typename T>
+    void value(Output& out, const T& value)
+    {
+        write_value(out, value, ctti::meta::bool_<ctti::meta::list_size<ctti::get_model<T>>() == 0>());
+    }
+
+    template<typename Output>
+    void value(Output& out, const std::string& value)
+    {
+        out.write("\""); out.write(value); out.write("\"");
+    }
+
+    template<typename Output, typename T>
+    void value(Output& out, const std::vector<T>& vector)
+    {
+        out.write("[");
+
+        for(std::size_t i = 0; i < vector.size(); ++i)
+        {
+            ctti::serialization::serialize(*this, out, vector[i]);
+
+            if(i + 1 < vector.size())
+            {
+                out.write(", ");
+            }
+        }
+
+        out.write("]");
+    }
+
+    template<typename Output, typename T, std::size_t Size>
+    void value(Output& out, const std::array<T, Size>& array)
+    {
+        out.write("[");
+
+        for(std::size_t i = 0; i < array.size(); ++i)
+        {
+            ctti::serialization::serialize(*this, out, array[i]);
+
+            if(i + 1 < array.size())
+            {
+                out.write(", ");
+            }
+        }
+
+        out.write("]");
+    }
+
+    template<typename Output, typename Key, typename Value, typename Hash>
+    void value(Output& out, const std::unordered_map<Key, Value, Hash>& map)
+    {
+        out.write("[");
+        std::size_t i = 0;
+
+        for(const auto& keyValue : map)
+        {
+            out.write("{");
+            ctti::serialization::serialize(*this, out, keyValue.first);
+            out.write(": ");
+            ctti::serialization::serialize(*this, out, keyValue.second);
+            out.write("}");
+
+            if(i + 1 < map.size())
+            {
+                out.write(", ");
+            }
+
+            ++i;
+        }
+
+        out.write("]");
+    }
+
+    template<typename Output, typename... Ts>
+    void value(Output& out, const std::tuple<Ts...>& tuple)
+    {
+        out.write("(");
+        ctti::meta::foreach<std::tuple<Ts...>>(tuple_loop_body_t<Output, Ts...>{&tuple, this, &out});
+        out.write(")");
+    }
+
+private:
+    template<typename Output, typename... Ts>
+    struct tuple_loop_body_t
+    {
+        const std::tuple<Ts...>* tuple;
+        json_formatter* self;
+        Output* out;
+
+        template<typename T, std::size_t Index>
+        void operator()(ctti::meta::identity<T>, ctti::meta::size_t<Index>) const
+        {
+            ctti::serialization::serialize(*self, *out, std::get<Index>(*tuple));
+
+            if(Index + 1 < sizeof...(Ts))
+            {
+                out->write(", ");
+            }
+        }
+    };
+
+    template<typename Output, typename T>
+    void write_value(Output& out, const T& value, ctti::meta::true_)
+    {
+        out.write(value);
+    }
+
+    template<typename Output, typename T>
+    void write_value(Output& out, const T& value, ctti::meta::false_)
+    {
+        ctti::serialization::serialize(*this, out, value);
+    }
+};
+
+struct json_writer
+{
+    json_writer(nlohmann::json& current_object) :
+        _current_object{&current_object}
+    {}
+
+    template<typename T>
+    ctti::meta::enable_if_t<ctti::has_model<T>::value> value(const std::string& name, const T& value)
+    {
+        ctti::serialization::serialize(json_writer((*_current_object)[name]), value);
+    }
+
+    template<typename T>
+    ctti::meta::enable_if_t<!ctti::has_model<T>::value> value(const std::string& name, const T& value)
+    {
+        (*_current_object)[name] = nlohmann::json(value);
+    }
+
+    template<typename T>
+    void raw_value(const T& value)
+    {
+        *_current_object = nlohmann::json(value);
+    }
+
+    template<typename T>
+    ctti::meta::enable_if_t<ctti::has_model<T>::value> value(const T& value)
+    {
+        ctti::serialization::serialize(json_writer(*_current_object), value);
+    }
+
+    template<typename T>
+    ctti::meta::enable_if_t<!ctti::has_model<T>::value> value(const T& value)
+    {
+        raw_value(value);
+    }
+
+    template<typename T>
+    void begin_object(const T&)
+    {
+    }
+
+    template<typename T>
+    void end_object(const T&)
+    {
+    }
+
+    void value_separator() {}
+
+private:
+    nlohmann::json* _current_object;
+};
+
+struct json_reader
+{
+    json_reader(const nlohmann::json& json) :
+        _current_object{&json}
+    {}
+
+    template<typename T>
+    ctti::meta::enable_if_t<ctti::has_model<T>::value> value(T& value)
+    {
+        ctti::serialization::deserialize(json_reader(*_current_object), value);
+    }
+
+    template<typename T>
+    ctti::meta::enable_if_t<!ctti::has_model<T>::value> value(T& value)
+    {
+        value = _current_object->get<T>();
+    }
+
+    template<typename T, typename Function>
+    void enum_value(T& value, Function callback)
+    {
+        if(_current_object->is_number())
+        {
+            value = callback(_current_object->get<typename std::underlying_type<T>::type>());
+        }
+        else if(_current_object->is_string())
+        {
+            value = callback(_current_object->get<std::string>());
+        }
+    }
+
+    template<typename T>
+    ctti::meta::enable_if_t<ctti::has_model<T>::value> value(const std::string& name, T& value)
+    {
+        ctti::serialization::deserialize(json_reader((*_current_object)[name]), value);
+    }
+
+    template<typename T>
+    ctti::meta::enable_if_t<!ctti::has_model<T>::value> value(const std::string& name, T& value)
+    {
+        auto subobject = (*_current_object)[name];
+        value = subobject.get<T>();
+    }
+
+    template<typename Key, typename Value, typename Hash>
+    void value(const std::string& name, std::unordered_map<Key, Value, Hash>& map)
+    {
+        value((*_current_object)[name], map);
+    }
+
+    template<typename Key, typename Value, typename Hash>
+    void value(std::unordered_map<Key, Value, Hash>& map)
+    {
+        value(*_current_object, map);
+    }
+
+private:
+    const nlohmann::json* _current_object;
+
+    template<typename Key, typename Value, typename Hash>
+    void value(const nlohmann::json& json, std::unordered_map<Key, Value, Hash>& map)
+    {
+        assert(json.is_array());
+
+        for(const auto& key_value_object : json)
+        {
+            // maps are serialized as key, value arrays, where key value pairs are arrays too
+            assert(key_value_object.is_array());
+            assert(key_value_object.size() == 2);
+
+            const auto& key = key_value_object[0];
+            const auto& value = key_value_object[1];
+
+            Key deserialized_key;
+            Value deserialized_value;
+            ctti::serialization::deserialize(json_reader(key), deserialized_key);
+            ctti::serialization::deserialize(json_reader(value), deserialized_value);
+
+            map[std::move(deserialized_key)] = std::move(deserialized_value);
+        }
+    }
+};
+
+struct enum_from_string_reader
+{
+    enum_from_string_reader(const std::string& input) :
+        _input{input}
+    {}
+
+    template<typename T, typename Callback>
+    void enum_value(T& value, Callback callback)
+    {
+        value = callback(_input);
+    }
+
+private:
+    std::string _input;
+};
+
+struct enum_to_string_writer
+{
+    enum_to_string_writer(std::string& output) :
+        _output{&output}
+    {}
+
+    void raw_value(const std::string& enum_value)
+    {
+        *_output = enum_value;
+    }
+
+private:
+    std::string* _output;
+};
+
+template<typename Enum>
+ctti::meta::enable_if_t<ctti::has_model<Enum>::value && std::is_enum<Enum>::value, std::string> enum_to_string(const Enum value)
+{
+    std::string output;
+    ctti::serialization::serialize(ctti::serialization::enum_to_string_writer(output), value);
+    return output;
+}
+
+template<typename Enum>
+ctti::meta::enable_if_t<ctti::has_model<Enum>::value && std::is_enum<Enum>::value, Enum> enum_from_string(const std::string& enum_string)
+{
+    Enum enum_value{};
+    ctti::serialization::deserialize(ctti::serialization::enum_from_string_reader(enum_string), enum_value);
+    return enum_value;
+}
+
+template<typename Writer, typename T>
+void serialize(Writer writer, const T& value)
+{
+    ctti::serialization::detail::serialize<T>::apply(writer, value);
+}
+
+template<typename Formatter, typename Output, typename T>
+void serialize(Formatter formatter, Output& output, const T& value)
+{
+    auto writer = ctti::serialization::make_writer(formatter, output);
+    ctti::serialization::serialize(writer, value);
+}
+
+template<typename Formatter, typename Output, typename T>
+void serialize(Formatter formatter, Output output, const T& value)
+{
+    auto writer = ctti::serialization::make_writer(formatter, output);
+    ctti::serialization::serialize(writer, value);
+}
+
+template<typename Reader, typename T>
+void deserialize(Reader reader, T& value)
+{
+    ctti::serialization::detail::deserialize<T>::apply(reader, value);
+}
+
+namespace detail
+{
+    template<typename T, bool HasModel = ctti::meta::list_size<ctti::get_model<T>>() == 0, typename = void>
+    struct is_default_ostream_serializable : public ctti::meta::false_ {};
+
+    template<typename T>
+    struct is_default_ostream_serializable<T, false, ctti::meta::void_t<decltype(T::ctti_ostream_print())>> : public ctti::meta::true_ {};
+
+    template<typename T>
+    struct is_default_ostream_serializable<T, false, ctti::meta::void_t<decltype(std::declval<T>().ctti_ostream_print())>> : public ctti::meta::true_ {};
+
+    template<typename T>
+    struct is_default_ostream_serializable<T, false, ctti::meta::void_t<decltype(ctti_ostream_print(std::declval<ctti::type_tag<T>>()))>> : public ctti::meta::true_ {};
+}
+
+}
+
+}
+
+template<typename T>
+ctti::meta::enable_if_t<ctti::serialization::detail::is_default_ostream_serializable<T>::value, std::ostream&> operator<<(std::ostream& os, const T& value)
+{
+    ctti::serialization::serialize(ctti::serialization::json_formatter(), ctti::serialization::ostream_otuput(os), value);
+    return os;
+}
+
+#endif // CTTI_SERIALIZATION_HPP
diff --git a/include/cereal/external/ctti/static_value.hpp b/include/cereal/external/ctti/static_value.hpp
new file mode 100644
index 00000000..4c21e036
--- /dev/null
+++ b/include/cereal/external/ctti/static_value.hpp
@@ -0,0 +1,52 @@
+#ifndef CTTI_DETAIL_STATIC_VALUE_HPP
+#define CTTI_DETAIL_STATIC_VALUE_HPP
+
+namespace ctti
+{
+
+template<typename T, T Value>
+struct static_value
+{
+    constexpr static_value() = default;
+    using value_type = T;
+    static constexpr value_type value = Value;
+
+    constexpr operator value_type() const
+    {
+        return Value;
+    }
+
+    constexpr value_type get() const
+    {
+        return Value;
+    }
+
+    friend constexpr bool operator==(const static_value& lhs, const value_type rhs)
+    {
+        return lhs.get() == rhs;
+    }
+
+    friend constexpr bool operator==(const value_type lhs, const static_value& rhs)
+    {
+        return rhs == lhs;
+    }
+
+    friend constexpr bool operator!=(const static_value& lhs, const value_type rhs)
+    {
+        return !(lhs == rhs);
+    }
+
+    friend constexpr bool operator!=(const value_type lhs, const static_value& rhs)
+    {
+        return !(lhs == rhs);
+    }
+};
+
+template<typename T, T Value>
+constexpr T static_value<T, Value>::value;
+
+}
+
+#define CTTI_STATIC_VALUE(x) ::ctti::static_value<decltype(x), (x)>
+
+#endif // CTTI_DETAIL_STATIC_VALUE_HPP
diff --git a/include/cereal/external/ctti/symbol.hpp b/include/cereal/external/ctti/symbol.hpp
new file mode 100644
index 00000000..fce58e1d
--- /dev/null
+++ b/include/cereal/external/ctti/symbol.hpp
@@ -0,0 +1,242 @@
+#ifndef CTTI_SYMBOL_HPP
+#define CTTI_SYMBOL_HPP
+
+#include <ctti/detail/meta.hpp>
+#include <ctti/detailed_nameof.hpp>
+#include <ctti/detail/cstring.hpp>
+#include <ctti/detail/preprocessor.hpp>
+#include <memory>
+
+#define CTTI_DEFINE_SYMBOL(name)                                             \
+    struct name {                                                            \
+        constexpr name() {}                                                  \
+                                                                             \
+        static constexpr ctti::detail::cstring symbol() {                    \
+            return CTTI_PP_STR(name);                                        \
+        }                                                                    \
+                                                                             \
+        static constexpr std::uint64_t hash() {                              \
+            return symbol().hash();                                          \
+        }                                                                    \
+                                                                             \
+        template<typename T, bool IsEnum = std::is_enum<T>::value, typename = void> \
+        struct impl                                                          \
+        {                                                                    \
+            static constexpr bool is_member_of() {                           \
+                return false;                                                \
+            }                                                                \
+                                                                             \
+            using member_type = std::nullptr_t;                              \
+                                                                             \
+            static constexpr member_type get_member() {                      \
+                return nullptr;                                              \
+            }                                                                \
+                                                                             \
+            static constexpr ctti::detail::cstring member_name() {           \
+                return CTTI_PP_STR(name);                                    \
+            }                                                                \
+        };                                                                   \
+                                                                             \
+        template<typename T>                                                 \
+        struct impl<T, false, ::ctti::meta::void_t<decltype(&T::name)>> {    \
+            static constexpr bool is_member_of() {                           \
+                return true;                                                 \
+            }                                                                \
+                                                                             \
+            using member_type = decltype(&T::name);                          \
+                                                                             \
+            static constexpr member_type get_member() {                      \
+                return &T::name;                                             \
+            }                                                                \
+                                                                             \
+            static constexpr ctti::detail::cstring member_name() {           \
+                return ctti::nameof<CTTI_STATIC_VALUE(&T::name)>();          \
+            }                                                                \
+        };                                                                   \
+                                                                             \
+        template<typename T>                                                 \
+        struct impl<T, true, ::ctti::meta::void_t<decltype(T::name)>> {      \
+            static constexpr bool is_member_of() {                           \
+                return true;                                                 \
+            }                                                                \
+                                                                             \
+            using member_type = decltype(T::name);                           \
+                                                                             \
+            static constexpr member_type get_member() {                      \
+                return T::name;                                              \
+            }                                                                \
+                                                                             \
+            static constexpr ctti::detail::cstring member_name() {           \
+                return CTTI_PP_STR(name);                                    \
+            }                                                                \
+        };                                                                   \
+                                                                             \
+        template<typename T>                                                 \
+        using member_type = typename impl<T>::member_type;                   \
+                                                                             \
+        template<typename T>                                                 \
+        static constexpr bool is_member_of() {                               \
+            return impl<T>::is_member_of();                                  \
+        }                                                                    \
+                                                                             \
+        template<typename T>                                                 \
+        static constexpr member_type<T> get_member() {                       \
+            return impl<T>::get_member();                                    \
+        }                                                                    \
+                                                                             \
+        template<typename T>                                                 \
+        static constexpr ctti::name_t detailed_name() {                      \
+            return ctti::detailed_nameof<CTTI_STATIC_VALUE(get_member<T>())>(); \
+        }                                                                    \
+                                                                             \
+        template<typename T>                                                 \
+        static constexpr ctti::detail::cstring member_name() {               \
+            return impl<T>::member_name();                                   \
+        }                                                                    \
+                                                                             \
+        template<typename T>                                                 \
+        using value_type = typename ::ctti::detail::member_traits<member_type<T>>::value_type; \
+    };                                                                       \
+                                                                             \
+    name ctti_symbol_from_hash(::ctti::meta::uint64_t<ctti::detail::fnv1a_hash(CTTI_PP_STR(name))>)
+
+
+namespace ctti
+{
+
+namespace detail
+{
+
+template<typename Member>
+struct member_traits;
+
+template<typename T, typename Class>
+struct member_traits<T Class::*>
+{
+    using value_type = T;
+    using pointer_type = T Class::*;
+
+    template<typename Obj>
+    static constexpr const value_type& get(const Obj& object, pointer_type member)
+    {
+        return object.*member;
+    }
+
+    template<typename Obj>
+    static constexpr value_type& get(Obj& object, pointer_type member)
+    {
+        return object.*member;
+    }
+
+    template<typename Obj, typename Value>
+    static void set(Obj& object, pointer_type member, Value&& value)
+    {
+        get(object, member) = std::forward<Value>(value);
+    }
+};
+
+template<typename T, typename Class, typename... Args>
+struct member_traits<T (Class::*)(Args...)>
+{
+    using value_type = T;
+    using pointer_type = T (Class::*)(Args...);
+
+    template<typename Obj, typename... _Args>
+    static constexpr value_type get(const Obj& object, pointer_type member, _Args&&... args)
+    {
+        return (object.*member)(std::forward<_Args>(args)...);
+    }
+
+    template<typename Obj, typename... _Args>
+    static void set(Obj& object, pointer_type member, _Args&&... args)
+    {
+        get(object, member, std::forward<_Args>(args)...);
+    }
+};
+
+template<typename Class, typename Arg>
+struct member_traits<void (Class::*)(Arg)>
+{
+    using pointer_type = void (Class::*)(Arg);
+    using value_type = ctti::meta::decay_t<Arg>;
+
+    template<typename Obj, typename _Arg>
+    static void set(Obj& object, pointer_type member, _Arg&& arg)
+    {
+        (object.*member)(std::forward<_Arg>(arg));
+    }
+};
+
+template<typename T, typename Class, typename... Args>
+struct member_traits<T (Class::*)(Args...) const>
+{
+    using value_type = T;
+    using pointer_type = T (Class::*)(Args...) const;
+
+    template<typename Obj, typename... _Args>
+    static constexpr value_type get(const Obj& object, pointer_type member, _Args&&... args)
+    {
+        return (object.*member)(std::forward<_Args>(args)...);
+    }
+};
+
+template<typename T, typename Member, typename... Args>
+constexpr auto member_traits_get(const T& object, Member member, Args&&... args)
+    -> const typename member_traits<Member>::value_type&
+{
+    return member_traits<Member>::get(object, member, std::forward<Args>(args)...);
+}
+
+template<typename T, typename Member, typename... Args>
+constexpr auto member_traits_get(T& object, Member member, Args&&... args)
+    -> typename member_traits<Member>::value_type&
+{
+    return member_traits<Member>::get(object, member, std::forward<Args>(args)...);
+}
+
+template<typename T, typename Member, typename... Args>
+void member_traits_set(T& object, Member member, Args&&... args)
+{
+    member_traits<Member>::set(object, member, std::forward<Args>(args)...);
+}
+
+template<std::size_t Hash>
+struct no_symbol_for_hash {};
+
+}
+
+template<typename Symbol, typename T, typename... Args>
+constexpr const typename Symbol::template value_type<T>& get_member_value(const T& object, Args&&... args)
+{
+    static_assert(Symbol::template is_member_of<T>(), "not a member of the class");
+    return ctti::detail::member_traits_get(object, Symbol::template get_member<T>(), std::forward<Args>(args)...);
+}
+
+template<typename Symbol, typename T, typename... Args>
+typename Symbol::template value_type<T>&
+get_member_value(T& object, Args&&... args)
+{
+    static_assert(Symbol::template is_member_of<T>(), "not a member of the class");
+    return ctti::detail::member_traits_get(object, Symbol::template get_member<T>(), std::forward<Args>(args)...);
+}
+
+template<typename Symbol, typename T, typename... Args>
+void set_member_value(const T& object, Args&&... args)
+{
+    static_assert(Symbol::template is_member_of<T>(), "not a member of the class");
+    ctti::detail::member_traits_set(object, Symbol::template get_member<T>(), std::forward<Args>(args)...);
+}
+
+template<typename Symbol, typename T, typename... Args>
+void set_member_value(T& object, Args&&... args)
+{
+    static_assert(Symbol::template is_member_of<T>(), "not a member of the class");
+    ctti::detail::member_traits_set(object, Symbol::template get_member<T>(), std::forward<Args>(args)...);
+}
+
+}
+
+template<typename Hash>
+ctti::detail::no_symbol_for_hash<Hash::value> ctti_symbol_from_hash(Hash);
+
+#endif // CTTI_SYMBOL_HPP
diff --git a/include/cereal/external/ctti/symbol_from_hash.hpp b/include/cereal/external/ctti/symbol_from_hash.hpp
new file mode 100644
index 00000000..cdd8fcef
--- /dev/null
+++ b/include/cereal/external/ctti/symbol_from_hash.hpp
@@ -0,0 +1,15 @@
+#ifndef CTTI_SYMBOL_FROM_HASH_HPP
+#define CTTI_SYMBOL_FROM_HASH_HPP
+
+#include <cstddef>
+
+namespace ctti
+{
+
+template<std::uint64_t Hash>
+using symbol_from_hash = decltype(ctti_symbol_from_hash(ctti::meta::uint64_t<Hash>()));
+
+}
+
+
+#endif // CTTI_SYMBOL_FROM_HASH_HPP
diff --git a/include/cereal/external/ctti/tie.hpp b/include/cereal/external/ctti/tie.hpp
new file mode 100644
index 00000000..738f3e19
--- /dev/null
+++ b/include/cereal/external/ctti/tie.hpp
@@ -0,0 +1,70 @@
+#ifndef CTTI_TIE_HPP
+#define CTTI_TIE_HPP
+
+#include <ctti/symbol.hpp>
+#include <ctti/detail/meta.hpp>
+#include <tuple>
+
+namespace ctti
+{
+
+namespace detail
+{
+
+template<typename Symbols, typename Refs>
+struct tie_t;
+
+template<typename... Symbols, typename... Refs>
+struct tie_t<ctti::meta::list<Symbols...>, ctti::meta::list<Refs...>>
+{
+    constexpr tie_t(Refs&... refs) :
+        _refs{refs...}
+    {}
+
+    template<typename T>
+    void operator=(const T& object)
+    {
+        assign(object, ctti::meta::make_index_sequence_for<Symbols...>());
+    }
+
+private:
+    template<std::size_t Index>
+    using Symbol = ctti::meta::pack_get_t<Index, Symbols...>;
+
+
+    template<std::size_t Index, typename T, typename = typename std::enable_if<
+        Symbol<Index>::template is_member_of<T>()
+    >::type>
+    void assign_member(const T& object)
+    {
+        std::get<Index>(_refs) = ctti::get_member_value<Symbol<Index>>(object);
+    }
+
+    template<std::size_t Index, typename T, typename std::enable_if<
+        !Symbol<Index>::template is_member_of<T>()
+    >::type>
+    void assign_member(const T& object)
+    {}
+
+    template<typename T, std::size_t... Index>
+    void assign(const T& object, ctti::meta::index_sequence<Index...>)
+    {
+        [](...){}((tie_t::assign_member<Index>(object), 42)...);
+    }
+
+    std::tuple<Refs&...> _refs;
+};
+
+}
+
+template<typename... Symbols, typename... Refs>
+constexpr ctti::detail::tie_t<
+    ctti::meta::list<Symbols...>, ctti::meta::list<Refs...>
+> tie(Refs&... refs)
+{
+    return {refs...};
+}
+
+}
+
+#endif // CTTI_TIE_HPP
diff --git a/include/cereal/external/ctti/type_id.hpp b/include/cereal/external/ctti/type_id.hpp
new file mode 100644
index 00000000..ec58dc87
--- /dev/null
+++ b/include/cereal/external/ctti/type_id.hpp
@@ -0,0 +1,201 @@
+//
+// Created by manu343726 on 4/08/15.
+//
+
+#ifndef CTTI_HASH_HPP
+#define CTTI_HASH_HPP
+
+#include <functional>
+#include "detail/hash.hpp"
+#include "detail/cstring.hpp"
+#include "nameof.hpp"
+
+#ifdef CTTI_DEBUG_ID_FUNCTIONS
+#include <iostream>
+#include <string>
+
+#ifndef CTTI_CONSTEXPR_ID
+#define CTTI_CONSTEXPR_ID
+#endif
+#else
+#ifndef CTTI_CONSTEXPR_ID
+#define CTTI_CONSTEXPR_ID constexpr
+#endif
+#endif
+namespace ctti
+{
+    struct type_id_t
+    {
+        constexpr type_id_t(const detail::cstring& name) :
+            name_{name}
+        {}
+
+        constexpr type_id_t() :
+            type_id_t{"void"}
+        {}
+
+        type_id_t& operator=(const type_id_t&) = default;
+
+        constexpr detail::hash_t hash() const
+        {
+            return name_.hash();
+        }
+
+        constexpr const detail::cstring& name() const
+        {
+            return name_;
+        }
+
+        friend constexpr bool operator==(const type_id_t& lhs, const type_id_t& rhs)
+        {
+            return lhs.hash() == rhs.hash();
+        }
+
+        friend constexpr bool operator!=(const type_id_t& lhs, const type_id_t& rhs)
+        {
+            return !(lhs == rhs);
+        }
+
+    private:
+        detail::cstring name_;
+    };
+
+    struct unnamed_type_id_t
+    {
+        constexpr unnamed_type_id_t(const detail::hash_t hash) :
+            _hash{hash}
+        {}
+
+        constexpr unnamed_type_id_t(const type_id_t& id) :
+            _hash{id.hash()}
+        {}
+
+        unnamed_type_id_t& operator=(const unnamed_type_id_t&) = default;
+
+        constexpr detail::hash_t hash() const
+        {
+	    return _hash;
+        }
+
+        friend constexpr bool operator==(const unnamed_type_id_t& lhs, const unnamed_type_id_t& rhs)
+        {
+            return lhs.hash() == rhs.hash();
+        }
+
+        friend constexpr bool operator!=(const unnamed_type_id_t& lhs, const unnamed_type_id_t& rhs)
+        {
+            return !(lhs == rhs);
+        }
+
+    private:
+        detail::hash_t _hash;
+    };
+
+    using type_index = unnamed_type_id_t; // To mimic std::type_index when using maps
+
+
+    template<std::size_t N>
+    constexpr ctti::unnamed_type_id_t id_from_name(const char (&typeName)[N])
+    {
+        return detail::fnv1a_hash(typeName);
+    }
+
+    constexpr ctti::unnamed_type_id_t id_from_name(const char* typeName, std::size_t length)
+    {
+        return detail::fnv1a_hash(length, typeName);
+    }
+
+    constexpr ctti::unnamed_type_id_t id_from_name(const ctti::detail::cstring& name)
+    {
+        return detail::fnv1a_hash(name.size(), name.begin());
+    }
+
+    // Inline to prevent ODR violation
+    inline ctti::unnamed_type_id_t id_from_name(const std::string& typeName)
+    {
+        return detail::fnv1a_hash(typeName.size(), typeName.data());
+    }
+
+    namespace detail
+    {
+        template<typename T>
+	CTTI_CONSTEXPR_ID ctti::type_id_t type_id()
+        {
+            return { ctti::nameof<T>() };
+        }
+
+        template<typename T>
+        CTTI_CONSTEXPR_ID ctti::unnamed_type_id_t unnamed_type_id()
+        {
+            return { id_from_name(ctti::nameof<T>()) };
+        }
+    }
+
+    /**
+     * Returns type information at compile-time for a value
+     * of type T. Decay is applied to argument type first, use
+     * ctti::type_id<decltype(arg)>() to preserve references and cv qualifiers.
+     */
+    template<typename T>
+    constexpr type_id_t type_id(T&&)
+    {
+        return detail::type_id<typename std::decay<T>::type>();
+    }
+
+    /**
+     * Returns type information at compile-time for type T.
+     */
+    template<typename T>
+    constexpr type_id_t type_id()
+    {
+        return detail::type_id<T>();
+    }
+
+    /**
+     * Returns unnamed type information at compile-time for a value
+     * of type T. Decay is applied to argument type first, use
+     * ctti::type_id<decltype(arg)>() to preserve references and cv qualifiers.
+     */
+    template<typename T>
+    constexpr unnamed_type_id_t unnamed_type_id(T&&)
+    {
+        return detail::unnamed_type_id<typename std::decay<T>::type>();
+    }
+
+    /**
+     * Returns unnamed type information at compile-time for type T.
+     */
+    template<typename T>
+    constexpr unnamed_type_id_t unnamed_type_id()
+    {
+        return detail::unnamed_type_id<T>();
+    }
+
+    //assert commented out, GCC 5.2.0 ICE here.
+    //static_assert(type_id<void>() == type_id<void>(), "ctti::type_id_t instances must be constant expressions");
+}
+
+namespace std
+{
+    template<>
+    struct hash<ctti::type_id_t>
+    {
+        constexpr std::size_t operator()(const ctti::type_id_t& id) const
+        {
+            // quiet warning about possible loss of data
+            return std::size_t(id.hash());
+        }
+    };
+
+    template<>
+    struct hash<ctti::unnamed_type_id_t>
+    {
+        constexpr std::size_t operator()(const ctti::unnamed_type_id_t& id) const
+        {
+            // quiet warning about possible loss of data
+            return std::size_t(id.hash());
+        }
+    };
+}
+
+#endif //CTTI_HASH_HPP
diff --git a/include/cereal/external/ctti/type_tag.hpp b/include/cereal/external/ctti/type_tag.hpp
new file mode 100644
index 00000000..d98bd21e
--- /dev/null
+++ b/include/cereal/external/ctti/type_tag.hpp
@@ -0,0 +1,16 @@
+#ifndef CTTI_TYPE_TAG_HPP
+#define CTTI_TYPE_TAG_HPP
+
+namespace ctti
+{
+
+template<typename T>
+struct type_tag
+{
+    constexpr type_tag() = default;
+    using type = T;
+};
+
+}
+
+#endif // CTTI_TYPE_TAG_HPP