diff --git a/examples/checkpoint_example_to_file_nonintrusive.cc b/examples/checkpoint_example_to_file_nonintrusive.cc
index e369b5be..b3a99869 100644
--- a/examples/checkpoint_example_to_file_nonintrusive.cc
+++ b/examples/checkpoint_example_to_file_nonintrusive.cc
@@ -140,18 +140,19 @@ int main(int, char**) {
   // Call the serialization routine for the variable `my_test_inst`
   // The output is a unique pointer: `std::unique_ptr<SerializedInfo>`
   // (defined in `src/checkpoint_api.h`)
-  magistrate::serializeToFile(my_test_inst, "hello.txt");
+  std::string my_filename = "CheckpointExampleToFileNoninstrusive.txt";
+  magistrate::serializeToFile(my_test_inst, my_filename);
 
   //
   // De-serializes from the file an object of type 'MyTestType'
   // out will be an object of type 'std::unique_ptr<MyTestType>'
   //
-  auto out = magistrate::deserializeFromFile<MyTestType>("hello.txt");
+  auto out = magistrate::deserializeFromFile<MyTestType>(my_filename);
 
   if (my_test_inst == *out) {
     std::cout << " Serialization / Deserialization from file worked. \n";
   } else {
-    std::cout << " Serialization / Deserialization from file failed. \n";
+    std::cout << " Serialization / Deserialization from file failed. \n" << std::flush;
     assert(false);
   }
 
@@ -164,7 +165,7 @@ int main(int, char**) {
   // Here 'out_2' will contain an empty vector and an integer 'len_' set to 0.
   //
 
-  magistrate::deserializeInPlaceFromFile<MyTestType>("hello.txt", &out_2);
+  magistrate::deserializeInPlaceFromFile<MyTestType>(my_filename, &out_2);
 
   //
   // Now 'out_2' will contain:
@@ -175,7 +176,7 @@ int main(int, char**) {
   if (my_test_inst == out_2) {
     std::cout << " Deserialization in-place from file worked. \n";
   } else {
-    std::cout << " Deserialization in-place from file failed. \n";
+    std::cout << " Deserialization in-place from file failed. \n" << std::flush;
     assert(false);
   }
 
diff --git a/examples/checkpoint_example_user_traits.cc b/examples/checkpoint_example_user_traits.cc
index bf2ef9b2..bf1d7053 100644
--- a/examples/checkpoint_example_user_traits.cc
+++ b/examples/checkpoint_example_user_traits.cc
@@ -49,12 +49,12 @@ int main(int, char**){
 
   //Each invocation will be handled based on the traits attached
   auto s_info_a = checkpoint::serialize(obj);
-  auto s_info_b = checkpoint::serialize<checkpoint_trait>(obj);
-  auto s_info_c = checkpoint::serialize<checkpoint_trait, checkpoint_trait>(obj);
-  auto s_info_d = checkpoint::serialize<test::random_trait, checkpoint_trait>(obj);
-  auto s_info_e = checkpoint::serialize<checkpoint_trait, test::random_trait>(obj);
-  auto s_info_f = checkpoint::serialize<test::random_trait, test::random_trait>(obj);
-  auto s_info_g = checkpoint::serialize<shallow_trait>(obj);
-  auto s_info_h = checkpoint::serialize<misc::namespace_trait>(obj);
-  auto s_info_i = checkpoint::serialize<misc::hook_all_trait>(obj);
+  auto s_info_b = checkpoint::serialize<test::TestObj, checkpoint_trait>(obj);
+  auto s_info_c = checkpoint::serialize<test::TestObj, checkpoint_trait, checkpoint_trait>(obj);
+  auto s_info_d = checkpoint::serialize<test::TestObj, test::random_trait, checkpoint_trait>(obj);
+  auto s_info_e = checkpoint::serialize<test::TestObj, checkpoint_trait, test::random_trait>(obj);
+  auto s_info_f = checkpoint::serialize<test::TestObj, test::random_trait, test::random_trait>(obj);
+  auto s_info_g = checkpoint::serialize<test::TestObj, shallow_trait>(obj);
+  auto s_info_h = checkpoint::serialize<test::TestObj, misc::namespace_trait>(obj);
+  auto s_info_i = checkpoint::serialize<test::TestObj, misc::hook_all_trait>(obj);
 }
diff --git a/src/checkpoint/checkpoint_api.h b/src/checkpoint/checkpoint_api.h
index 83162753..2dbb50cf 100644
--- a/src/checkpoint/checkpoint_api.h
+++ b/src/checkpoint/checkpoint_api.h
@@ -78,7 +78,7 @@ using SerializedReturnType = std::unique_ptr<SerializedInfo>;
  * \return a \c std::unique_ptr to a \c SerializedInfo containing the buffer
  * with serialized data and the size of the buffer
  */
-template <typename... UserTraits, typename T>
+template <typename T, typename... UserTraits>
 SerializedReturnType serialize(T& target, BufferCallbackType fn = nullptr);
 
 /**
@@ -132,7 +132,7 @@ std::unique_ptr<T> deserialize(char* buf);
  * \param[in] t a valid pointer to a \c T that has been user-allocated and
  * constructed
  */
-template <typename... UserTraits, typename T>
+template <typename T, typename... UserTraits>
 void deserializeInPlace(char* buf, T* t);
 
 /**
@@ -153,7 +153,7 @@ std::unique_ptr<T> deserialize(SerializedReturnType&& in);
  *
  * \return number of bytes for the \c target
  */
-template <typename... UserTraits, typename T>
+template <typename T, typename... UserTraits>
 std::size_t getSize(T& target);
 
 /**
@@ -170,7 +170,7 @@ std::size_t getSize(T& target);
  *
  * \return memory footprint of the \c target
  */
-template <typename... UserTraits, typename T>
+template <typename T, typename... UserTraits>
 std::size_t getMemoryFootprint(T& target, std::size_t size_offset = 0);
 
 /**
@@ -184,7 +184,7 @@ std::size_t getMemoryFootprint(T& target, std::size_t size_offset = 0);
  * \param[in] target the \c T to serialize
  * \param[in] file name of the file to create
  */
-template <typename... UserTraits, typename T>
+template <typename T, typename... UserTraits>
 void serializeToFile(T& target, std::string const& file);
 
 /**
@@ -214,7 +214,7 @@ std::unique_ptr<T> deserializeFromFile(std::string const& file);
  * \param[in] file the filename to read with bytes for \c T
  * \param[in] t a valid, constructed \c T to deserialize into
  */
-template <typename... UserTraits, typename T>
+template <typename T, typename... UserTraits>
 void deserializeInPlaceFromFile(std::string const& file, T* buf);
 
 /**
@@ -227,7 +227,7 @@ void deserializeInPlaceFromFile(std::string const& file, T* buf);
  * \param[in] target the \c T to serialize
  * \param[in] stream to serialize into, with tellp and write functions.
  */
-template <typename... Traits, typename T, typename StreamT>
+template <typename T, typename... UserTraits, typename StreamT>
 void serializeToStream(T& target, StreamT& stream);
 
 /**
@@ -243,7 +243,7 @@ void serializeToStream(T& target, StreamT& stream);
  *
  * \return unique pointer to the new object \c T
  */
-template <typename T, typename... Traits, typename StreamT>
+template <typename T, typename... UserTraits, typename StreamT>
 std::unique_ptr<T> deserializeFromStream(StreamT& stream);
 
 /**
@@ -257,7 +257,7 @@ std::unique_ptr<T> deserializeFromStream(StreamT& stream);
  * \param[in] stream the stream to read with bytes for \c T, with tellg and read functions
  * \param[in] t a valid, constructed \c T to deserialize into
  */
-template <typename... Traits, typename T, typename StreamT>
+template <typename T, typename... UserTraits, typename StreamT>
 void deserializeInPlaceFromStream(StreamT& stream, T* buf);
 
 
diff --git a/src/checkpoint/checkpoint_api.impl.h b/src/checkpoint/checkpoint_api.impl.h
index e78c92a6..f04f4bff 100644
--- a/src/checkpoint/checkpoint_api.impl.h
+++ b/src/checkpoint/checkpoint_api.impl.h
@@ -53,9 +53,9 @@
 
 namespace checkpoint {
 
-template <typename... Traits, typename T>
+template <typename T, typename... Traits>
 SerializedReturnType serialize(T& target, BufferCallbackType fn) {
-  auto ret = dispatch::serializeType<T, Traits...>(target, fn);
+  auto ret = dispatch::serializeType<T, UserTraitHolder<Traits...>>(target, fn);
   auto& buf = std::get<0>(ret);
   std::unique_ptr<SerializedInfo> base_ptr(
     static_cast<SerializedInfo*>(buf.release())
@@ -65,43 +65,43 @@ SerializedReturnType serialize(T& target, BufferCallbackType fn) {
 
 template <typename T, typename... Traits>
 T* deserialize(char* buf, char* object_buf) {
-  return dispatch::deserializeType<T, Traits...>(buf, object_buf);
+  return dispatch::deserializeType<T, UserTraitHolder<Traits...>>(buf, object_buf);
 }
 
 template <typename T, typename... Traits>
 std::unique_ptr<T> deserialize(char* buf) {
-  auto t = dispatch::deserializeType<T, Traits...>(buf);
+  auto t = dispatch::deserializeType<T, UserTraitHolder<Traits...>>(buf);
   return std::unique_ptr<T>(t);
 }
 
 template <typename T, typename... Traits>
 std::unique_ptr<T> deserialize(SerializedReturnType&& in) {
-  auto t = dispatch::deserializeType<T, Traits...>(in->getBuffer());
+  auto t = dispatch::deserializeType<T, UserTraitHolder<Traits...>>(in->getBuffer());
   return std::unique_ptr<T>(t);
 }
 
-template <typename... Traits, typename T>
+template <typename T, typename... Traits>
 void deserializeInPlace(char* buf, T* t) {
-  return dispatch::deserializeType<T, Traits...>(dispatch::InPlaceTag{}, buf, t);
+  return dispatch::deserializeType<T, UserTraitHolder<Traits...>>(dispatch::InPlaceTag{}, buf, t);
 }
 
-template <typename... Traits, typename T>
+template <typename T, typename... Traits>
 std::size_t getSize(T& target) {
-  return dispatch::Standard::size<T, SerializerRef<Sizer, Traits...>>(target);
+  return dispatch::Standard::size<T, Sizer, UserTraitHolder<Traits...>>(target);
 }
 
-template <typename... Traits, typename T>
+template <typename T, typename... Traits>
 std::size_t getMemoryFootprint(T& target, std::size_t size_offset) {
   return size_offset + std::max(
-    dispatch::Standard::footprint<T, SerializerRef<Footprinter, Traits...>>(target),
+    dispatch::Standard::footprint<T, Footprinter, UserTraitHolder<Traits...>>(target),
     sizeof(target)
   );
 }
 
-template <typename... Traits, typename T>
+template <typename T, typename... Traits>
 void serializeToFile(T& target, std::string const& file) {
   auto len = getSize<Traits...>(target);
-  dispatch::Standard::pack<T, SerializerRef<PackerBuffer<buffer::IOBuffer>, Traits...>>(
+  dispatch::Standard::pack<T, PackerBuffer<buffer::IOBuffer>, UserTraitHolder<Traits...>>(
     target, len, buffer::IOBuffer::WriteToFileTag{}, len, file
   );
 }
@@ -110,23 +110,23 @@ template <typename T, typename... Traits>
 std::unique_ptr<T> deserializeFromFile(std::string const& file) {
   auto mem = dispatch::Standard::allocate<T>();
   T* t_buf = dispatch::Standard::construct<T>(mem);
-  auto t = dispatch::Standard::unpack<T, SerializerRef<UnpackerBuffer<buffer::IOBuffer>, Traits...>>(
+  auto t = dispatch::Standard::unpack<T, UnpackerBuffer<buffer::IOBuffer>, UserTraitHolder<Traits...>>(
     t_buf, buffer::IOBuffer::ReadFromFileTag{}, file
   );
   return std::unique_ptr<T>(t);
 }
 
-template <typename... Traits, typename T>
+template <typename T, typename... Traits>
 void deserializeInPlaceFromFile(std::string const& file, T* t) {
-  dispatch::Standard::unpack<T, SerializerRef<UnpackerBuffer<buffer::IOBuffer>, Traits...>>(
+  dispatch::Standard::unpack<T, UnpackerBuffer<buffer::IOBuffer>, UserTraitHolder<Traits...>>(
     t, buffer::IOBuffer::ReadFromFileTag{}, file
   );
 }
 
-template <typename... Traits, typename T, typename StreamT>
+template <typename T, typename... Traits, typename StreamT>
 void serializeToStream(T& target, StreamT& stream) {
   auto len = getSize<T>(target);
-  dispatch::Standard::pack<T, SerializerRef<StreamPacker<StreamT>, Traits...>>(
+  dispatch::Standard::pack<T, StreamPacker<StreamT>, UserTraitHolder<Traits...>>(
     target, len, stream
   );
 }
@@ -135,15 +135,15 @@ template <typename T, typename... Traits, typename StreamT>
 std::unique_ptr<T> deserializeFromStream(StreamT& stream) {
   auto mem = dispatch::Standard::allocate<T>();
   T* t_buf = dispatch::Standard::construct<T>(mem);
-  auto t = dispatch::Standard::unpack<T, SerializerRef<StreamUnpacker<StreamT>, Traits...>>(
+  auto t = dispatch::Standard::unpack<T, StreamUnpacker<StreamT>, UserTraitHolder<Traits...>>(
     t_buf, stream
   );
   return std::unique_ptr<T>(t);
 }
 
-template <typename... Traits, typename T, typename StreamT>
+template <typename T, typename... Traits, typename StreamT>
 void deserializeInPlaceFromStream(StreamT& stream, T* t) {
-  dispatch::Standard::unpack<T, SerializerRef<StreamUnpacker<StreamT>, Traits...>>(
+  dispatch::Standard::unpack<T, StreamUnpacker<StreamT>, UserTraitHolder<Traits...>>(
     t, stream
   );
 }
diff --git a/src/checkpoint/container/atomic_serialize.h b/src/checkpoint/container/atomic_serialize.h
index f0783453..e1bc80e3 100644
--- a/src/checkpoint/container/atomic_serialize.h
+++ b/src/checkpoint/container/atomic_serialize.h
@@ -54,7 +54,7 @@ template <
   typename SerializerT,
   typename T,
   typename = std::enable_if_t<
-    checkpoint::is_footprinter<SerializerT>::value
+    checkpoint::is_footprinter_v<SerializerT>
   >
 >
 void serialize(SerializerT& s, const std::atomic<T>& atomic) {
diff --git a/src/checkpoint/container/function_serialize.h b/src/checkpoint/container/function_serialize.h
index 4ab98f3e..6a192fee 100644
--- a/src/checkpoint/container/function_serialize.h
+++ b/src/checkpoint/container/function_serialize.h
@@ -68,9 +68,7 @@ template <
   typename Res,
   typename... ArgTypes,
   typename = std::enable_if_t<
-    checkpoint::is_footprinter<
-      SerializerT
-    >::value
+    checkpoint::is_footprinter_v<SerializerT>
   >
 >
 void serializeFunction(SerializerT& s, std::function<Res(ArgTypes...)>& fn) {
diff --git a/src/checkpoint/container/kokkos_unordered_map_serialize.h b/src/checkpoint/container/kokkos_unordered_map_serialize.h
index d07b0e6f..81183452 100644
--- a/src/checkpoint/container/kokkos_unordered_map_serialize.h
+++ b/src/checkpoint/container/kokkos_unordered_map_serialize.h
@@ -117,7 +117,7 @@ template <
   typename Hasher, typename EqualTo
 >
 typename std::enable_if_t<
-  not checkpoint::is_footprinter<SerializerT>::value, void
+  not checkpoint::is_footprinter_v<SerializerT>, void
 > serialize(
   SerializerT& s,
   Kokkos::UnorderedMap<Key, Value, Device, Hasher, EqualTo>& map
@@ -140,7 +140,7 @@ template <
   typename Hasher, typename EqualTo
 >
 typename std::enable_if_t<
-  checkpoint::is_footprinter<SerializerT>::value, void
+  checkpoint::is_footprinter_v<SerializerT>, void
 > serialize(
   SerializerT& s,
   Kokkos::UnorderedMap<Key, Value, Device, Hasher, EqualTo>& map
diff --git a/src/checkpoint/container/list_serialize.h b/src/checkpoint/container/list_serialize.h
index 72f6d1b8..262a08d5 100644
--- a/src/checkpoint/container/list_serialize.h
+++ b/src/checkpoint/container/list_serialize.h
@@ -56,7 +56,7 @@ namespace checkpoint {
 
 template <typename Serializer, typename ContainerT, typename ElmT>
 inline typename std::enable_if_t<
-  not checkpoint::is_footprinter<Serializer>::value, void
+  not checkpoint::is_footprinter_v<Serializer>, void
 >
 deserializeOrderedElems(
   Serializer& s, ContainerT& cont, typename ContainerT::size_type size,
@@ -76,7 +76,7 @@ deserializeOrderedElems(
 
 template <typename Serializer, typename ContainerT, typename ElmT>
 inline typename std::enable_if_t<
-  not checkpoint::is_footprinter<Serializer>::value, void
+  not checkpoint::is_footprinter_v<Serializer>, void
 >
 deserializeOrderedElems(
   Serializer& s, ContainerT& cont, typename ContainerT::size_type size,
@@ -96,7 +96,7 @@ deserializeOrderedElems(
 
 template <typename Serializer, typename ContainerT, typename ElmT>
 inline typename std::enable_if_t<
-  checkpoint::is_footprinter<Serializer>::value, void
+  checkpoint::is_footprinter_v<Serializer>, void
 >
 deserializeOrderedElems(
   Serializer&, ContainerT&, typename ContainerT::size_type
diff --git a/src/checkpoint/container/map_serialize.h b/src/checkpoint/container/map_serialize.h
index 39e1b6b8..a1a2a880 100644
--- a/src/checkpoint/container/map_serialize.h
+++ b/src/checkpoint/container/map_serialize.h
@@ -58,7 +58,7 @@ namespace checkpoint {
 
 template <typename Serializer, typename ContainerT, typename ElmT>
 inline typename std::enable_if_t<
-  not checkpoint::is_footprinter<Serializer>::value,
+  not checkpoint::is_footprinter_v<Serializer>,
   void
 > deserializeEmplaceElems(
   Serializer& s, ContainerT& cont, typename ContainerT::size_type size
@@ -77,7 +77,7 @@ inline typename std::enable_if_t<
 
 template <typename Serializer, typename ContainerT, typename ElmT>
 inline typename std::enable_if_t<
-  checkpoint::is_footprinter<Serializer>::value,
+  checkpoint::is_footprinter_v<Serializer>,
   void
 > deserializeEmplaceElems(
   Serializer&, ContainerT&, typename ContainerT::size_type
diff --git a/src/checkpoint/container/queue_serialize.h b/src/checkpoint/container/queue_serialize.h
index 8da15f1c..485fbccc 100644
--- a/src/checkpoint/container/queue_serialize.h
+++ b/src/checkpoint/container/queue_serialize.h
@@ -108,7 +108,7 @@ template <
   typename SerializerT,
   typename Q,
   typename = std::enable_if_t<
-    checkpoint::is_footprinter<SerializerT>::value
+    checkpoint::is_footprinter_v<SerializerT>
   >
 >
 void serializeQueueLikeContainer(SerializerT& s, const Q& q) {
diff --git a/src/checkpoint/container/raw_ptr_serialize.h b/src/checkpoint/container/raw_ptr_serialize.h
index cb1df132..30814ad9 100644
--- a/src/checkpoint/container/raw_ptr_serialize.h
+++ b/src/checkpoint/container/raw_ptr_serialize.h
@@ -61,7 +61,7 @@ template <
   typename SerializerT,
   typename T,
   typename = std::enable_if_t<
-    checkpoint::is_footprinter<SerializerT>::value
+    checkpoint::is_footprinter_v<SerializerT>
   >
 >
 void serialize(SerializerT& s, T* ptr) {
@@ -92,7 +92,7 @@ void serializeRawPtr(SerializerT& s, void* ptr) {
 #define CHECKPOINT_FOOTPRINT_PIMPL_WITH_SIZEOF_PTR(PIMPL_TYPE) \
   template < \
     typename SerializerT, \
-    typename = std::enable_if_t< checkpoint::is_footprinter<SerializerT>::value > \
+    typename = std::enable_if_t< checkpoint::is_footprinter_v<SerializerT> > \
   > \
   void serialize(SerializerT &s, PIMPL_TYPE *t) { \
     s.countBytes(t); \
diff --git a/src/checkpoint/container/shared_ptr_serialize.h b/src/checkpoint/container/shared_ptr_serialize.h
index f880aef0..db854b52 100644
--- a/src/checkpoint/container/shared_ptr_serialize.h
+++ b/src/checkpoint/container/shared_ptr_serialize.h
@@ -52,7 +52,7 @@ template <
   typename SerializerT,
   typename T,
   typename = std::enable_if_t<
-    checkpoint::is_footprinter<SerializerT>::value
+    checkpoint::is_footprinter_v<SerializerT>
   >
 >
 void serialize(SerializerT& s, std::shared_ptr<T>& ptr) {
diff --git a/src/checkpoint/container/thread_serialize.h b/src/checkpoint/container/thread_serialize.h
index d755ce39..d2596a18 100644
--- a/src/checkpoint/container/thread_serialize.h
+++ b/src/checkpoint/container/thread_serialize.h
@@ -53,7 +53,7 @@ namespace checkpoint {
 template <
   typename SerializerT,
   typename = std::enable_if_t<
-    checkpoint::is_footprinter<SerializerT>::value
+    checkpoint::is_footprinter_v<SerializerT>
   >
 >
 void serialize(SerializerT& s, const std::thread& t) {
diff --git a/src/checkpoint/container/vector_serialize.h b/src/checkpoint/container/vector_serialize.h
index ede47ad0..ed4478c6 100644
--- a/src/checkpoint/container/vector_serialize.h
+++ b/src/checkpoint/container/vector_serialize.h
@@ -56,7 +56,7 @@ namespace checkpoint {
 
 template <typename SerializerT, typename T, typename VectorAllocator>
 typename std::enable_if_t<
-  not checkpoint::is_footprinter<SerializerT>::value, SerialSizeType
+  not checkpoint::is_footprinter_v<SerializerT>, SerialSizeType
 >
 serializeVectorMeta(SerializerT& s, std::vector<T, VectorAllocator>& vec) {
   SerialSizeType vec_capacity = vec.capacity();
@@ -108,7 +108,7 @@ void constructVectorData(
 
 template <typename SerializerT, typename T, typename VectorAllocator>
 typename std::enable_if_t<
-  not checkpoint::is_footprinter<SerializerT>::value, void
+  not checkpoint::is_footprinter_v<SerializerT>, void
 >
 serialize(SerializerT& s, std::vector<T, VectorAllocator>& vec) {
   auto const vec_size = serializeVectorMeta(s, vec);
@@ -122,7 +122,7 @@ serialize(SerializerT& s, std::vector<T, VectorAllocator>& vec) {
 
 template <typename SerializerT, typename VectorAllocator>
 typename std::enable_if_t<
-  not checkpoint::is_footprinter<SerializerT>::value, void
+  not checkpoint::is_footprinter_v<SerializerT>, void
 >
 serialize(SerializerT& s, std::vector<bool, VectorAllocator>& vec) {
   auto const vec_size = serializeVectorMeta(s, vec);
@@ -146,7 +146,7 @@ serialize(SerializerT& s, std::vector<bool, VectorAllocator>& vec) {
 
 template <typename SerializerT, typename T, typename VectorAllocator>
 typename std::enable_if_t<
-  checkpoint::is_footprinter<SerializerT>::value, void
+  checkpoint::is_footprinter_v<SerializerT>, void
 >
 serialize(SerializerT& s, std::vector<T, VectorAllocator>& vec) {
   s.countBytes(vec);
@@ -156,7 +156,7 @@ serialize(SerializerT& s, std::vector<T, VectorAllocator>& vec) {
 
 template <typename SerializerT, typename VectorAllocator>
 typename std::enable_if_t<
-  checkpoint::is_footprinter<SerializerT>::value, void
+  checkpoint::is_footprinter_v<SerializerT>, void
 >
 serialize(SerializerT& s, std::vector<bool, VectorAllocator>& vec) {
   s.countBytes(vec);
diff --git a/src/checkpoint/dispatch/dispatch.h b/src/checkpoint/dispatch/dispatch.h
index 08e613b8..b5cefcaf 100644
--- a/src/checkpoint/dispatch/dispatch.h
+++ b/src/checkpoint/dispatch/dispatch.h
@@ -98,7 +98,7 @@ struct Traverse {
    *
    * \return the constructed traverser after traversal is complete
    */
-  template <typename T, typename TraverserT, typename... Args>
+  template <typename T, typename TraverserT, typename UserTraits = UserTraitHolder<>, typename... Args>
   static TraverserT with(T& target, Args&&... args);
 
   /**
@@ -131,7 +131,7 @@ struct Standard {
    *
    * \return the number of bytes
    */
-  template <typename T, typename SizerT, typename...Args>
+  template <typename T, typename SizerT, typename UserTraits, typename...Args>
   static SerialSizeType size(T& target, Args&&... args);
 
   /**
@@ -142,20 +142,19 @@ struct Standard {
    *
    * \return memory footprint of \c T
    */
-  template <typename T, typename FootprinterT, typename...Args>
+  template <typename T, typename FootprinterT, typename UserTraits, typename...Args>
   static SerialSizeType footprint(T& target, Args&&... args);
 
   /**
    * \brief Pack \c target that requires \c size number of bytes.
    *
    * \param[in] target the target to pack
-   * \param[in] size the number of bytes for \c target
    * \param[in] args arguments to the packer's constructor
    *
    * \return the packer after packing
    */
-  template <typename T, typename PackerT, typename... Args>
-  static PackerT pack(T& target, SerialSizeType const& size, Args&&... args);
+  template <typename T, typename PackerT, typename UserTraits, typename... Args>
+  static PackerT pack(T& target, Args&&... args);
 
   /**
    * \brief Unpack \c T from packed byte-buffer \c mem
@@ -166,7 +165,7 @@ struct Standard {
    *
    * \return a pointer to an unpacked \c T
    */
-  template <typename T, typename UnpackerT, typename... Args>
+  template <typename T, typename UnpackerT, typename UserTraits, typename... Args>
   static T* unpack(T* mem, Args&&... args);
 
   /**
@@ -188,7 +187,7 @@ struct Standard {
   static SerialByteType* allocate();
 };
 
-template <typename T, typename... UserTraits>
+template <typename T, typename UserTraits>
 buffer::ImplReturnType packBuffer(
   T& target, SerialSizeType size, BufferObtainFnType fn
 );
@@ -196,13 +195,13 @@ buffer::ImplReturnType packBuffer(
 template <typename Serializer, typename T>
 inline void serializeArray(Serializer& s, T* array, SerialSizeType const len);
 
-template <typename T, typename... UserTraits>
+template <typename T, typename UserTraits>
 buffer::ImplReturnType serializeType(T& target, BufferObtainFnType fn = nullptr);
 
-template <typename T, typename... UserTraits>
+template <typename T, typename UserTraits>
 T* deserializeType(SerialByteType* data, SerialByteType* allocBuf = nullptr);
 
-template <typename T, typename... UserTraits>
+template <typename T, typename UserTraits>
 void deserializeType(InPlaceTag, SerialByteType* data, T* t);
 
 template <typename T>
diff --git a/src/checkpoint/dispatch/dispatch.impl.h b/src/checkpoint/dispatch/dispatch.impl.h
index 451938c2..568848cb 100644
--- a/src/checkpoint/dispatch/dispatch.impl.h
+++ b/src/checkpoint/dispatch/dispatch.impl.h
@@ -50,6 +50,7 @@
 
 #include <stdexcept>
 #include <string>
+#include <optional>
 
 namespace checkpoint {
 
@@ -166,13 +167,22 @@ TraverserT& Traverse::with(T& target, TraverserT& t, SerialSizeType len) {
   return t;
 }
 
-template <typename T, typename TraverserT, typename... Args>
+template <typename T, typename TraverserT, typename Traits, typename... Args>
 TraverserT Traverse::with(T& target, Args&&... args) {
   #if !defined(SERIALIZATION_ERROR_CHECKING)
   using CleanT = typename CleanType<T>::CleanT;
   #endif
-
-  TraverserT t(std::forward<Args>(args)...);
+ 
+  TraverserT t_base(std::forward<Args>(args)...);
+  auto t = SerializerRef(&t_base, Traits{});
+  
+  //std::optional<TraverserT> t_opt;
+  //if constexpr(is_serializer_ref<TraverserT>) {
+  //  t_opt.emplace(std::in_place, std::forward<Args>(args)...);
+  //} else {
+  //  t_opt.emplace(std::forward<Args>(args)...);
+  //}
+  //TraverserT& t = t_opt.value();
 
   #if !defined(SERIALIZATION_ERROR_CHECKING)
   withTypeIdx<CleanT>(t);
@@ -184,7 +194,7 @@ TraverserT Traverse::with(T& target, Args&&... args) {
   withMemUsed<CleanT>(t, 1);
   #endif
 
-  return t;
+  return t_base;
 }
 
 template <typename T>
@@ -192,22 +202,22 @@ T* Traverse::reconstruct(SerialByteType* mem) {
   return Reconstructor<typename CleanType<T>::CleanT>::construct(mem);
 }
 
-template <typename T, typename SizerT, typename... Args>
+template <typename T, typename SizerT, typename Traits, typename... Args>
 SerialSizeType Standard::size(T& target, Args&&... args) {
-  auto sizer = Traverse::with<T, SizerT>(target, std::forward<Args>(args)...);
-  return sizer->getSize();
+  auto sizer = Traverse::with<T, SizerT, Traits>(target, std::forward<Args>(args)...);
+  return sizer.getSize();
 }
 
-template <typename T, typename FootprinterT, typename... Args>
+template <typename T, typename FootprinterT, typename Traits, typename... Args>
 SerialSizeType Standard::footprint(T& target, Args&&... args) {
   auto footprinter =
-    Traverse::with<T, FootprinterT>(target, std::forward<Args>(args)...);
-  return footprinter->getMemoryFootprint();
+    Traverse::with<T, FootprinterT, Traits>(target, std::forward<Args>(args)...);
+  return footprinter.getMemoryFootprint();
 }
 
-template <typename T, typename PackerT, typename... Args>
-PackerT Standard::pack(T& target, SerialSizeType const& size, Args&&... args) {
-  return Traverse::with<T, PackerT>(target, size, std::forward<Args>(args)...);
+template <typename T, typename PackerT, typename Traits, typename... Args>
+PackerT Standard::pack(T& target, Args&&... args) {
+  return Traverse::with<T, PackerT, Traits>(target, std::forward<Args>(args)...);
 }
 
 template <typename T>
@@ -215,9 +225,9 @@ SerialByteType* Standard::allocate() {
   return reinterpret_cast<SerialByteType*>(std::allocator<T>{}.allocate(1));
 }
 
-template <typename T, typename UnpackerT, typename... Args>
+template <typename T, typename UnpackerT, typename Traits, typename... Args>
 T* Standard::unpack(T* t_buf, Args&&... args) {
-  Traverse::with<T, UnpackerT>(*t_buf, std::forward<Args>(args)...);
+  Traverse::with<T, UnpackerT, Traits>(*t_buf, std::forward<Args>(args)...);
   return t_buf;
 }
 
@@ -247,44 +257,44 @@ validatePackerBufferSize(PackerT const& p, SerialSizeType bufferSize) {
   }
 }
 
-template <typename T, typename... UserTraits>
+template <typename T, typename UserTraits>
 buffer::ImplReturnType
 packBuffer(T& target, SerialSizeType size, BufferObtainFnType fn) {
   SerialByteType* user_buf = fn ? fn(size) : nullptr;
   if (user_buf == nullptr) {
     auto p =
-      Standard::pack<T, SerializerRef<PackerBuffer<buffer::ManagedBuffer>, UserTraits...>>(target, size);
+      Standard::pack<T, PackerBuffer<buffer::ManagedBuffer>, UserTraits>(target, size);
     validatePackerBufferSize<T>(p, size);
-    return std::make_tuple(std::move(p->extractPackedBuffer()), size);
+    return std::make_tuple(std::move(p.extractPackedBuffer()), size);
   } else {
-    auto p = Standard::pack<T, SerializerRef<PackerBuffer<buffer::UserBuffer>, UserTraits...>>(
+    auto p = Standard::pack<T, PackerBuffer<buffer::UserBuffer>, UserTraits>(
       target, size, std::make_unique<buffer::UserBuffer>(user_buf, size)
     );
     validatePackerBufferSize<T>(p, size);
-    return std::make_tuple(std::move(p->extractPackedBuffer()), size);
+    return std::make_tuple(std::move(p.extractPackedBuffer()), size);
   }
 }
 
-template <typename T, typename... UserTraits>
+template <typename T, typename UserTraits>
 buffer::ImplReturnType serializeType(T& target, BufferObtainFnType fn) {
-  auto len = Standard::size<T, SerializerRef<Sizer, UserTraits...>>(target);
+  auto len = Standard::size<T, Sizer, UserTraits>(target);
   debug_checkpoint("serializeType: len=%ld\n", len);
-  return packBuffer<T, UserTraits...>(target, len, fn);
+  return packBuffer<T, UserTraits>(target, len, fn);
 }
 
-template <typename T, typename... UserTraits>
+template <typename T, typename UserTraits>
 T* deserializeType(SerialByteType* data, SerialByteType* allocBuf) {
   auto mem = allocBuf ? allocBuf : Standard::allocate<T>();
   auto t_buf = std::unique_ptr<T>(Standard::construct<T>(mem));
   T* traverser =
-    Standard::unpack<T, SerializerRef<UnpackerBuffer<buffer::UserBuffer>, UserTraits...>>(t_buf.get(), data);
+    Standard::unpack<T, UnpackerBuffer<buffer::UserBuffer>, UserTraits>(t_buf.get(), data);
   t_buf.release();
   return traverser;
 }
 
-template <typename T, typename... UserTraits>
+template <typename T, typename UserTraits>
 void deserializeType(InPlaceTag, SerialByteType* data, T* t) {
-  Standard::unpack<T, SerializerRef<UnpackerBuffer<buffer::UserBuffer>, UserTraits...>>(t, data);
+  Standard::unpack<T, UnpackerBuffer<buffer::UserBuffer>, UserTraits>(t, data);
 }
 
 }} /* end namespace checkpoint::dispatch */
diff --git a/src/checkpoint/dispatch/dispatch_serializer_nonbyte.h b/src/checkpoint/dispatch/dispatch_serializer_nonbyte.h
index 9bc2fd9a..cae6b4f1 100644
--- a/src/checkpoint/dispatch/dispatch_serializer_nonbyte.h
+++ b/src/checkpoint/dispatch/dispatch_serializer_nonbyte.h
@@ -112,7 +112,7 @@ struct SerializerDispatchNonByte {
   template <typename U>
   using justFootprint =
   typename std::enable_if<
-    checkpoint::is_footprinter<S>::value and
+    checkpoint::is_footprinter_v<S> and
     not SerializableTraits<U, S>::is_traversable and
     not std::is_enum<U>::value,
     T
diff --git a/src/checkpoint/dispatch/vrt/virtual_serialize.h b/src/checkpoint/dispatch/vrt/virtual_serialize.h
index 5196d4c5..99f8c81f 100644
--- a/src/checkpoint/dispatch/vrt/virtual_serialize.h
+++ b/src/checkpoint/dispatch/vrt/virtual_serialize.h
@@ -59,18 +59,13 @@ namespace checkpoint { namespace dispatch { namespace vrt {
  */
 template <typename T, typename SerializerT>
 void virtualSerialize(T*& base, SerializerT& s) {
+  //We can't support traited serializing with virtual types.
+  static_assert(std::is_same_v<SerializerT, typename SerializerT::TraitlessT>, "User Traits are incompatible with virtual serialization");
+  
   // Get the real base in case this is called on a derived type
   using BaseT = ::checkpoint::dispatch::vrt::checkpoint_base_type_t<T>;
   auto serializer_idx = serializer_registry::makeObjIdx<BaseT, SerializerT>();
 
-  if constexpr (not std::is_same_v<SerializerT, typename SerializerT::TraitlessT>){
-    static bool warned_once = false;
-    if(!warned_once){
-      fprintf(stderr, "Warning: Magistrate cannot support UserTraits being visible to virtually serialized objects.\n");
-      warned_once = true;
-    }
-  }
-
   base->_checkpointDynamicSerialize(&s, serializer_idx, no_type_idx);
 }
 
@@ -155,7 +150,7 @@ struct ReconstructAsVirtualIfNeeded<
   SerializerT,
   typename std::enable_if_t<
     dispatch::vrt::VirtualSerializeTraits<T>::has_not_virtual_serialize and
-    not checkpoint::is_footprinter<SerializerT>::value
+    not checkpoint::is_footprinter_v<SerializerT>
   >
 > {
   static T* apply(SerializerT&, dispatch::vrt::TypeIdx) {
@@ -171,7 +166,7 @@ struct ReconstructAsVirtualIfNeeded<
   SerializerT,
   typename std::enable_if_t<
     dispatch::vrt::VirtualSerializeTraits<T>::has_not_virtual_serialize and
-    checkpoint::is_footprinter<SerializerT>::value
+    checkpoint::is_footprinter_v<SerializerT>
   >
 > {
   static T* apply(SerializerT&, dispatch::vrt::TypeIdx) { return nullptr; }
diff --git a/src/checkpoint/serializers/footprinter.h b/src/checkpoint/serializers/footprinter.h
index dbd027b7..7d38d44b 100644
--- a/src/checkpoint/serializers/footprinter.h
+++ b/src/checkpoint/serializers/footprinter.h
@@ -76,8 +76,8 @@ namespace {
     template <typename>
     struct is_footprinter_impl : public std::false_type {};
 
-    template <typename... UserTraits>
-    struct is_footprinter_impl<SerializerRef<Footprinter, UserTraits...>> : std::true_type {};
+    template <typename UserTraits>
+    struct is_footprinter_impl<SerializerRef<Footprinter, UserTraits>> : std::true_type {};
 
     template <>
     struct is_footprinter_impl<Footprinter> : std::true_type {};
@@ -86,6 +86,9 @@ namespace {
 template<typename U>
 using is_footprinter = is_footprinter_impl<std::decay_t<U>>;
 
+template<typename U>
+static constexpr const bool is_footprinter_v = is_footprinter<U>::value;
+
 } /* end namespace checkpoint */
 
 #endif /*INCLUDED_SRC_CHECKPOINT_SERIALIZERS_FOOTPRINTER_H*/
diff --git a/src/checkpoint/serializers/reference.h b/src/checkpoint/serializers/serializer_ref.h
similarity index 81%
rename from src/checkpoint/serializers/reference.h
rename to src/checkpoint/serializers/serializer_ref.h
index 7e402c62..9afbb6c2 100644
--- a/src/checkpoint/serializers/reference.h
+++ b/src/checkpoint/serializers/serializer_ref.h
@@ -2,7 +2,7 @@
 //@HEADER
 // *****************************************************************************
 //
-//                                 reference.h
+//                              serializer_ref.h
 //                 DARMA/checkpoint => Serialization Library
 //
 // Copyright 2019 National Technology & Engineering Solutions of Sandia, LLC
@@ -41,8 +41,8 @@
 //@HEADER
 */
 
-#if !defined INCLUDED_CHECKPOINT_SERIALIZERS_REFERENCE_H
-#define INCLUDED_CHECKPOINT_SERIALIZERS_REFERENCE_H
+#if !defined INCLUDED_CHECKPOINT_SERIALIZERS_SERIALIZER_REF_H
+#define INCLUDED_CHECKPOINT_SERIALIZERS_SERIALIZER_REF_H
 
 #include "checkpoint/common.h"
 #include "checkpoint/serializers/base_serializer.h"
@@ -54,29 +54,22 @@
 
 namespace checkpoint {
 
-namespace {
-  template<typename T, typename... U>
-  struct first_type_matches : public std::false_type {};
-  template<typename T, typename... U>
-  struct first_type_matches<T, T, U...> : public std::true_type {};
-}
-
-template<typename SerT, typename... UserTraits>
+template<typename SerT, typename UserTraits = UserTraitHolder<>>
 struct SerializerRef
 {
-  using TraitHolder = typename UserTraitHolder<UserTraits...>::BaseTraits;
+  using TraitHolder = typename UserTraits::BaseTraits;
 
   //Passing initialization to the serializer implementation
-  template<typename... Args>
-  explicit SerializerRef(Args&&... args)
-  {
-    if constexpr(first_type_matches<std::shared_ptr<SerT>, std::decay_t<Args>...>::value and sizeof...(Args) == 1) {
-        //If only 1 arg which is a shared pointer to the base serializer, use that instead of initializing a new serializer.
-        impl = {std::forward<Args>(args)...};
-    } else {
-        impl = std::make_shared<SerT>(std::forward<Args>(args)...);
-    }
-  }
+  explicit SerializerRef(SerT* m_impl, const UserTraits& = {}) :
+    impl(m_impl)
+  { }
+
+  //Copy constructor, possibly changing the traits
+  template<typename OtherTraits>
+  explicit SerializerRef(
+    const SerializerRef<SerT, OtherTraits>& other
+  ) : impl(other.impl)
+  { }
 
   //Now forward along Serializer function calls and types
   using ModeType = eSerializationMode;
@@ -109,11 +102,11 @@ struct SerializerRef
 
 
 
-  SerT* operator->(){ return impl.get(); }
+  SerT* operator->(){ return impl; }
 
-  template<typename... Traits>
-  operator SerializerRef<SerT, Traits...>() const {
-    return SerializerRef<SerT, Traits...>(impl);
+  template<typename OtherTraits>
+  operator SerializerRef<SerT, OtherTraits>() const {
+    return SerializerRef<SerT, OtherTraits>(*this);
   }
 
 
@@ -154,25 +147,31 @@ struct SerializerRef
   template<typename Trait, typename... Traits>
   auto withTraits(UserTraitHolder<Trait, Traits...> = {}){
     using NewTraitHolder = typename TraitHolder::template with<Trait, Traits...>;
-    return setTraits(NewTraitHolder());
+    //return setTraits(NewTraitHolder {});
+    return SerializerRef<SerT, NewTraitHolder>(*this);
   }
 
   //Returns a new reference with traits removed (if present) from this reference's traits.
   template<typename Trait, typename... Traits>
   auto withoutTraits(UserTraitHolder<Trait, Traits...> = {}){
     using NewTraitHolder = typename TraitHolder::template without<Trait, Traits...>;
-    return setTraits(NewTraitHolder());
+    return SerializerRef<SerT, NewTraitHolder>(*this);
   }
 
   //Returns a new reference with traits set to the inputs, regardless of this reference's traits.
   template<typename... NewTraits>
-  SerializerRef<SerT, NewTraits...> setTraits(UserTraitHolder<NewTraits...> = {}){
-    return *this;
+  SerializerRef<SerT, UserTraitHolder<NewTraits...>> setTraits(
+      const UserTraitHolder<NewTraits...>& = {}
+  ){
+    return SerializerRef<SerT, UserTraitHolder<NewTraits...>>(*this);
   }
 
-private:
-  std::shared_ptr<SerT> impl;
+protected:
+  SerT *const impl;
+  
+  template<typename, typename>
+  friend struct SerializerRef;
 };
 
 }
-#endif /*INCLUDED_CHECKPOINT_SERIALIZERS_REFERENCE_H*/
+#endif /*INCLUDED_CHECKPOINT_SERIALIZERS_SERIALIZER_REF_H*/
diff --git a/src/checkpoint/serializers/serializers_headers.h b/src/checkpoint/serializers/serializers_headers.h
index d7b5c44a..e9b4c674 100644
--- a/src/checkpoint/serializers/serializers_headers.h
+++ b/src/checkpoint/serializers/serializers_headers.h
@@ -46,7 +46,7 @@
 
 #include "checkpoint/common.h"
 #include "checkpoint/serializers/base_serializer.h"
-#include "checkpoint/serializers/reference.h"
+#include "checkpoint/serializers/serializer_ref.h"
 #include "checkpoint/serializers/footprinter.h"
 #include "checkpoint/serializers/sizer.h"
 #include "checkpoint/serializers/packer.h"