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
new file mode 100644
index 00000000..3263c0c6
--- /dev/null
+++ b/examples/checkpoint_example_user_traits.cc
@@ -0,0 +1,61 @@
+/*
+//@HEADER
+// *****************************************************************************
+//
+//                      checkpoint_example_user_traits.cc
+//                 DARMA/magistrate => Serialization Library
+//
+// Copyright 2019 National Technology & Engineering Solutions of Sandia, LLC
+// (NTESS). Under the terms of Contract DE-NA0003525 with NTESS, the U.S.
+// Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from this
+//   software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact darma@sandia.gov
+//
+// *****************************************************************************
+//@HEADER
+*/
+#include "checkpoint/checkpoint.h"
+
+#include "checkpoint_example_user_traits.hpp"
+
+int main(int, char**){
+  using namespace test;
+  TestObj obj;
+
+  //Each invocation will be handled based on the traits attached
+  auto s_info_a = checkpoint::serialize(obj);
+  auto s_info_b = checkpoint::serialize<TestObj, checkpoint_trait>(obj);
+  auto s_info_c = checkpoint::serialize<TestObj, checkpoint_trait, checkpoint_trait>(obj);
+  auto s_info_d = checkpoint::serialize<TestObj, random_trait, checkpoint_trait>(obj);
+  auto s_info_e = checkpoint::serialize<TestObj, checkpoint_trait, random_trait>(obj);
+  auto s_info_f = checkpoint::serialize<TestObj, random_trait, random_trait>(obj);
+  auto s_info_g = checkpoint::serialize<TestObj, shallow_trait>(obj);
+  auto s_info_h = checkpoint::serialize<TestObj, misc::namespace_trait>(obj);
+  auto s_info_i = checkpoint::serialize<TestObj, misc::hook_all_trait>(obj);
+}
diff --git a/examples/checkpoint_example_user_traits.hpp b/examples/checkpoint_example_user_traits.hpp
new file mode 100644
index 00000000..92f0d0b8
--- /dev/null
+++ b/examples/checkpoint_example_user_traits.hpp
@@ -0,0 +1,109 @@
+#include "checkpoint/checkpoint.h"
+
+struct checkpoint_trait {} CheckpointTrait;
+struct shallow_trait {} ShallowTrait;
+
+using checkpoint::has_user_traits_v;
+using checkpoint::has_any_user_traits_v;
+
+namespace test {
+  struct random_trait {} RandomTrait;
+
+  struct TestObj {
+    int a = 1;
+
+    TestObj() {}
+
+    template<
+      typename SerT,
+      typename std::enable_if_t<
+        not has_user_traits_v<SerT, shallow_trait>, void*
+      > = nullptr
+    >
+    void serialize(SerT& s){
+      if constexpr(has_user_traits_v<SerT, checkpoint_trait>){
+        if(s.isSizing()) printf("Customizing serialization for checkpoint\n");
+        s | a;
+      } else {
+        if(s.isSizing()) printf("Default serializing testObj\n");
+      }
+
+      static_assert(not has_user_traits_v<SerT, shallow_trait>,
+          "ShallowTrait should have been removed!\n");
+    }
+  };
+}
+
+namespace test {
+  template<
+    typename SerT,
+    typename std::enable_if_t<
+      has_user_traits_v<SerT, random_trait>, void*
+    > = nullptr
+  >
+  void serialize(SerT& s, TestObj& myObj){
+    if(s.isSizing()){
+      printf("Inserting random extra object serialization step! ");
+    }
+    myObj.serialize(s);
+  }
+
+  template<
+    typename SerT,
+    typename std::enable_if_t<
+      has_user_traits_v<SerT, shallow_trait>, void*
+    > = nullptr
+  >
+  void serialize(SerT& s, TestObj& myObj){
+    if(s.isSizing()) printf("Removing shallow trait before passing along!\n");
+    auto newS = s.template withoutTraits<shallow_trait>();
+    myObj.serialize(newS);
+  }
+}
+
+namespace misc {
+  template<
+    typename SerT,
+    typename std::enable_if_t<
+      has_user_traits_v<SerT, test::random_trait>, void*
+    > = nullptr
+  >
+  void serialize(SerT& s, test::TestObj& myObj){
+    if(s.isSizing()){
+      printf("Serializers in other namespaces don't usually get found ");
+    }
+    myObj.serialize(s);
+  }
+
+
+  const struct namespace_trait {} NamespaceTrait;
+  template<
+    typename SerT,
+    typename std::enable_if_t<
+      has_user_traits_v<SerT, namespace_trait>, void*
+    > = nullptr
+  >
+  void serialize(SerT& s, test::TestObj& myObj){
+    if(s.isSizing()){
+      printf("A misc:: trait means we can serialize from misc:: too: ");
+    }
+    myObj.serialize(s);
+  }
+
+
+  const struct hook_all_trait {} HookAllTrait;
+  template<
+    typename SerT,
+    typename T,
+    typename std::enable_if_t<
+      has_user_traits_v<SerT, hook_all_trait>, void*
+    > = nullptr
+  >
+  void serialize(SerT& s, T& myObj){
+    if(s.isSizing()){
+      printf("We can even add on a generic pre-serialize hook: ");
+    }
+    auto newS = s.template withoutTraits<hook_all_trait>();
+    myObj.serialize(newS);
+  }
+}
diff --git a/src/checkpoint/checkpoint_api.h b/src/checkpoint/checkpoint_api.h
index cd123cf4..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 T>
+template <typename T, typename... UserTraits>
 SerializedReturnType serialize(T& target, BufferCallbackType fn = nullptr);
 
 /**
@@ -101,7 +101,7 @@ SerializedReturnType serialize(T& target, BufferCallbackType fn = nullptr);
  *
  * \return a pointer to the newly reified \c T based on bytes in \c buf
  */
-template <typename T>
+template <typename T, typename... UserTraits>
 T* deserialize(char* buf, char* object_buf);
 
 /**
@@ -118,7 +118,7 @@ T* deserialize(char* buf, char* object_buf);
  *
  * \return a unique pointer to the newly reified \c T based on bytes in \c buf
  */
-template <typename T>
+template <typename T, typename... UserTraits>
 std::unique_ptr<T> deserialize(char* buf);
 
 /**
@@ -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 T>
+template <typename T, typename... UserTraits>
 void deserializeInPlace(char* buf, T* t);
 
 /**
@@ -143,7 +143,7 @@ void deserializeInPlace(char* buf, T* t);
  *
  * \return a unique pointer to \c T that must be deallocated
  */
-template <typename T>
+template <typename T, typename... UserTraits>
 std::unique_ptr<T> deserialize(SerializedReturnType&& in);
 
 /**
@@ -153,7 +153,7 @@ std::unique_ptr<T> deserialize(SerializedReturnType&& in);
  *
  * \return number of bytes for the \c target
  */
-template <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 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 T>
+template <typename T, typename... UserTraits>
 void serializeToFile(T& target, std::string const& file);
 
 /**
@@ -200,7 +200,7 @@ void serializeToFile(T& target, std::string const& file);
  *
  * \return unique pointer to the new object \c T
  */
-template <typename T>
+template <typename T, typename... UserTraits>
 std::unique_ptr<T> deserializeFromFile(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 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 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 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 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 863472e9..f04f4bff 100644
--- a/src/checkpoint/checkpoint_api.impl.h
+++ b/src/checkpoint/checkpoint_api.impl.h
@@ -53,9 +53,9 @@
 
 namespace checkpoint {
 
-template <typename T>
+template <typename T, typename... Traits>
 SerializedReturnType serialize(T& target, BufferCallbackType fn) {
-  auto ret = dispatch::serializeType<T>(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())
@@ -63,87 +63,87 @@ SerializedReturnType serialize(T& target, BufferCallbackType fn) {
   return base_ptr;
 }
 
-template <typename T>
+template <typename T, typename... Traits>
 T* deserialize(char* buf, char* object_buf) {
-  return dispatch::deserializeType<T>(buf, object_buf);
+  return dispatch::deserializeType<T, UserTraitHolder<Traits...>>(buf, object_buf);
 }
 
-template <typename T>
+template <typename T, typename... Traits>
 std::unique_ptr<T> deserialize(char* buf) {
-  auto t = dispatch::deserializeType<T>(buf);
+  auto t = dispatch::deserializeType<T, UserTraitHolder<Traits...>>(buf);
   return std::unique_ptr<T>(t);
 }
 
-template <typename T>
+template <typename T, typename... Traits>
 std::unique_ptr<T> deserialize(SerializedReturnType&& in) {
-  auto t = dispatch::deserializeType<T>(in->getBuffer());
+  auto t = dispatch::deserializeType<T, UserTraitHolder<Traits...>>(in->getBuffer());
   return std::unique_ptr<T>(t);
 }
 
-template <typename T>
+template <typename T, typename... Traits>
 void deserializeInPlace(char* buf, T* t) {
-  return dispatch::deserializeType<T>(dispatch::InPlaceTag{}, buf, t);
+  return dispatch::deserializeType<T, UserTraitHolder<Traits...>>(dispatch::InPlaceTag{}, buf, t);
 }
 
-template <typename T>
+template <typename T, typename... Traits>
 std::size_t getSize(T& target) {
-  return dispatch::Standard::size<T, Sizer>(target);
+  return dispatch::Standard::size<T, Sizer, UserTraitHolder<Traits...>>(target);
 }
 
-template <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, Footprinter>(target),
+    dispatch::Standard::footprint<T, Footprinter, UserTraitHolder<Traits...>>(target),
     sizeof(target)
   );
 }
 
-template <typename T>
+template <typename T, typename... Traits>
 void serializeToFile(T& target, std::string const& file) {
-  auto len = getSize<T>(target);
-  dispatch::Standard::pack<T, PackerBuffer<buffer::IOBuffer>>(
+  auto len = getSize<Traits...>(target);
+  dispatch::Standard::pack<T, PackerBuffer<buffer::IOBuffer>, UserTraitHolder<Traits...>>(
     target, len, buffer::IOBuffer::WriteToFileTag{}, len, file
   );
 }
 
-template <typename T>
+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, UnpackerBuffer<buffer::IOBuffer>>(
+  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 T>
+template <typename T, typename... Traits>
 void deserializeInPlaceFromFile(std::string const& file, T* t) {
-  dispatch::Standard::unpack<T, UnpackerBuffer<buffer::IOBuffer>>(
+  dispatch::Standard::unpack<T, UnpackerBuffer<buffer::IOBuffer>, UserTraitHolder<Traits...>>(
     t, buffer::IOBuffer::ReadFromFileTag{}, file
   );
 }
 
-template <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, StreamPacker<StreamT>>(
+  dispatch::Standard::pack<T, StreamPacker<StreamT>, UserTraitHolder<Traits...>>(
     target, len, stream
   );
 }
 
-template <typename T, typename StreamT>
+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, StreamUnpacker<StreamT>>(
+  auto t = dispatch::Standard::unpack<T, StreamUnpacker<StreamT>, UserTraitHolder<Traits...>>(
     t_buf, stream
   );
   return std::unique_ptr<T>(t);
 }
 
-template <typename T, typename StreamT>
+template <typename T, typename... Traits, typename StreamT>
 void deserializeInPlaceFromStream(StreamT& stream, T* t) {
-  dispatch::Standard::unpack<T, StreamUnpacker<StreamT>>(
+  dispatch::Standard::unpack<T, StreamUnpacker<StreamT>, UserTraitHolder<Traits...>>(
     t, stream
   );
 }
diff --git a/src/checkpoint/container/queue_serialize.h b/src/checkpoint/container/queue_serialize.h
index 485fbccc..613a849a 100644
--- a/src/checkpoint/container/queue_serialize.h
+++ b/src/checkpoint/container/queue_serialize.h
@@ -76,7 +76,7 @@ template <
   typename SerializerT,
   typename T,
   typename = std::enable_if_t<
-    not std::is_same_v<SerializerT, checkpoint::Footprinter>
+    not checkpoint::is_footprinter_v<SerializerT>
   >
 >
 void serializeQueueLikeContainer(SerializerT& s, std::queue<T>& q) {
diff --git a/src/checkpoint/dispatch/dispatch.h b/src/checkpoint/dispatch/dispatch.h
index e5c6da1b..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>
+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>
+template <typename T, typename UserTraits>
 buffer::ImplReturnType serializeType(T& target, BufferObtainFnType fn = nullptr);
 
-template <typename T>
+template <typename T, typename UserTraits>
 T* deserializeType(SerialByteType* data, SerialByteType* allocBuf = nullptr);
 
-template <typename T>
+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 44aac6a2..c74b3cc1 100644
--- a/src/checkpoint/dispatch/dispatch.impl.h
+++ b/src/checkpoint/dispatch/dispatch.impl.h
@@ -166,13 +166,14 @@ 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{});
 
   #if !defined(SERIALIZATION_ERROR_CHECKING)
   withTypeIdx<CleanT>(t);
@@ -184,7 +185,7 @@ TraverserT Traverse::with(T& target, Args&&... args) {
   withMemUsed<CleanT>(t, 1);
   #endif
 
-  return t;
+  return t_base;
 }
 
 template <typename T>
@@ -192,22 +193,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)...);
+  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)...);
+    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 +216,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,17 +248,17 @@ validatePackerBufferSize(PackerT const& p, SerialSizeType bufferSize) {
   }
 }
 
-template <typename T>
+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, PackerBuffer<buffer::ManagedBuffer>>(target, size);
+      Standard::pack<T, PackerBuffer<buffer::ManagedBuffer>, UserTraits>(target, size);
     validatePackerBufferSize<T>(p, size);
     return std::make_tuple(std::move(p.extractPackedBuffer()), size);
   } else {
-    auto p = Standard::pack<T, PackerBuffer<buffer::UserBuffer>>(
+    auto p = Standard::pack<T, PackerBuffer<buffer::UserBuffer>, UserTraits>(
       target, size, std::make_unique<buffer::UserBuffer>(user_buf, size)
     );
     validatePackerBufferSize<T>(p, size);
@@ -265,26 +266,26 @@ packBuffer(T& target, SerialSizeType size, BufferObtainFnType fn) {
   }
 }
 
-template <typename T>
+template <typename T, typename UserTraits>
 buffer::ImplReturnType serializeType(T& target, BufferObtainFnType fn) {
-  auto len = Standard::size<T, Sizer>(target);
+  auto len = Standard::size<T, Sizer, UserTraits>(target);
   debug_checkpoint("serializeType: len=%ld\n", len);
-  return packBuffer<T>(target, len, fn);
+  return packBuffer<T, UserTraits>(target, len, fn);
 }
 
-template <typename T>
+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, UnpackerBuffer<buffer::UserBuffer>>(t_buf.get(), data);
+    Standard::unpack<T, UnpackerBuffer<buffer::UserBuffer>, UserTraits>(t_buf.get(), data);
   t_buf.release();
   return traverser;
 }
 
-template <typename T>
+template <typename T, typename UserTraits>
 void deserializeType(InPlaceTag, SerialByteType* data, T* t) {
-  Standard::unpack<T, UnpackerBuffer<buffer::UserBuffer>>(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 247e0c42..cae6b4f1 100644
--- a/src/checkpoint/dispatch/dispatch_serializer_nonbyte.h
+++ b/src/checkpoint/dispatch/dispatch_serializer_nonbyte.h
@@ -91,7 +91,7 @@ struct SerializerDispatchNonByte {
 
   template <typename U>
   using hasInSerialize =
-  typename std::enable_if<SerializableTraits<U,S>::has_serialize_instrusive, T>::type;
+  typename std::enable_if<SerializableTraits<U,S>::has_serialize_instrusive && !SerializableTraits<U,S>::has_serialize_noninstrusive, T>::type;
 
   template <typename U>
   using hasNoninSerialize =
@@ -112,7 +112,7 @@ struct SerializerDispatchNonByte {
   template <typename U>
   using justFootprint =
   typename std::enable_if<
-    std::is_same<S, checkpoint::Footprinter>::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/serializer_registry.h b/src/checkpoint/dispatch/vrt/serializer_registry.h
index 9ec3860c..81e70669 100644
--- a/src/checkpoint/dispatch/vrt/serializer_registry.h
+++ b/src/checkpoint/dispatch/vrt/serializer_registry.h
@@ -94,7 +94,7 @@ inline RegistryType<ObjT>& getRegistry() {
 
 template <typename ObjT, typename SerializerT>
 inline TypeIdx makeObjIdx() {
-  return Type<ObjT, SerializerT>::idx;
+  return Type<ObjT, typename SerializerT::TraitlessT>::idx;
 }
 
 template <typename ObjT, typename SerializerT>
diff --git a/src/checkpoint/dispatch/vrt/virtual_serialize.h b/src/checkpoint/dispatch/vrt/virtual_serialize.h
index 2082dd44..a2e66b4c 100644
--- a/src/checkpoint/dispatch/vrt/virtual_serialize.h
+++ b/src/checkpoint/dispatch/vrt/virtual_serialize.h
@@ -59,9 +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>();
+
   base->_checkpointDynamicSerialize(&s, serializer_idx, no_type_idx);
 }
 
@@ -146,7 +150,7 @@ struct ReconstructAsVirtualIfNeeded<
   SerializerT,
   typename std::enable_if_t<
     dispatch::vrt::VirtualSerializeTraits<T>::has_not_virtual_serialize and
-    not std::is_same<SerializerT, checkpoint::Footprinter>::value
+    not checkpoint::is_footprinter_v<SerializerT>
   >
 > {
   static T* apply(SerializerT&, dispatch::vrt::TypeIdx) {
@@ -162,7 +166,7 @@ struct ReconstructAsVirtualIfNeeded<
   SerializerT,
   typename std::enable_if_t<
     dispatch::vrt::VirtualSerializeTraits<T>::has_not_virtual_serialize and
-    std::is_same<SerializerT, checkpoint::Footprinter>::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 84c260a8..da515b41 100644
--- a/src/checkpoint/serializers/footprinter.h
+++ b/src/checkpoint/serializers/footprinter.h
@@ -76,6 +76,9 @@ 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 <>
     struct is_footprinter_impl<Footprinter> : public std::true_type {};
 }
diff --git a/src/checkpoint/serializers/serializer_ref.h b/src/checkpoint/serializers/serializer_ref.h
new file mode 100644
index 00000000..9fd0d901
--- /dev/null
+++ b/src/checkpoint/serializers/serializer_ref.h
@@ -0,0 +1,157 @@
+/*
+//@HEADER
+// *****************************************************************************
+//
+//                               serializer_ref.h
+//                 DARMA/magistrate => Serialization Library
+//
+// Copyright 2019 National Technology & Engineering Solutions of Sandia, LLC
+// (NTESS). Under the terms of Contract DE-NA0003525 with NTESS, the U.S.
+// Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from this
+//   software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact darma@sandia.gov
+//
+// *****************************************************************************
+//@HEADER
+*/
+
+#if !defined INCLUDED_SRC_CHECKPOINT_SERIALIZERS_SERIALIZER_REF_H
+#define INCLUDED_SRC_CHECKPOINT_SERIALIZERS_SERIALIZER_REF_H
+
+#include "checkpoint/common.h"
+#include "checkpoint/serializers/base_serializer.h"
+#include "checkpoint/traits/user_traits.h"
+
+#include <type_traits>
+#include <cstdlib>
+#include <memory>
+
+namespace checkpoint {
+
+template<typename SerT, typename UserTraits = UserTraitHolder<>>
+struct SerializerRef
+{
+  using TraitHolder = typename UserTraits::BaseTraits;
+
+  //Passing initialization to the serializer implementation
+  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;
+  template <typename SerializerT, typename T>
+  using DispatcherType = typename SerT::template DispatcherType<SerializerT, T>;
+  ModeType getMode() const { return impl->getMode(); }
+  bool isSizing() const { return impl->isSizing(); }
+  bool isPacking() const { return impl->isPacking(); }
+  bool isUnpacking() const { return impl->isUnpacking(); }
+  bool isFootprinting() const { return impl->isFootprinting(); }
+  template<typename T>
+  void countBytes(const T& t) { impl->countBytes(t); }
+  void addBytes(std::size_t s) { impl->addBytes(s); }
+  void contiguousBytes(void* ptr, SerialSizeType size, SerialSizeType num_elms) {
+    impl->contiguousBytes(ptr, size, num_elms);
+  }
+  SerialSizeType usedBufferSize() const { return impl->usedBufferSize(); }
+  template<typename SerializerT, typename T>
+  void contiguousTyped(SerializerT& serdes, T* ptr, SerialSizeType num_elms) {
+    serdes.contiguousBytes(static_cast<void*>(ptr), sizeof(T), num_elms);
+  }
+  template<typename... Args>
+  void skip(Args&&... args){
+    impl->skip( std::forward<Args>(args)... );
+  }
+  SerialByteType* getBuffer() const { return impl->getBuffer(); }
+  SerialByteType* getSpotIncrement(const SerialSizeType inc) { return impl->getSpotIncrement(inc); }
+  bool isVirtualDisabled() const { return impl->isVirtualDisabled(); }
+  void setVirtualDisabled(bool val) { impl->setVirtualDisabled(val); }
+
+
+  SerT* operator->(){ return impl; }
+
+  template<typename OtherTraits>
+  operator SerializerRef<SerT, OtherTraits>() const {
+    return SerializerRef<SerT, OtherTraits>(*this);
+  }
+
+  //Helpers for converting between traits
+  using TraitlessT = SerializerRef<SerT>;
+
+  //Returns a new reference with traits in addition to this reference's traits.
+  template<typename Trait, typename... Traits>
+  auto withTraits(UserTraitHolder<Trait, Traits...> = {}){
+    using NewTraitHolder = typename TraitHolder::template with<Trait, Traits...>;
+    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 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, UserTraitHolder<NewTraits...>> setTraits(
+      const UserTraitHolder<NewTraits...>& = {}
+  ){
+    return SerializerRef<SerT, UserTraitHolder<NewTraits...>>(*this);
+  }
+
+protected:
+  SerT *const impl;
+
+  template<typename, typename>
+  friend struct SerializerRef;
+};
+
+
+template<typename S, typename... Traits>
+using has_user_traits = typename S::TraitHolder::template has<Traits...>;
+
+template<typename S, typename... Traits>
+using has_any_user_traits = typename S::TraitHolder::template has_any<Traits...>;
+
+template<typename S, typename... Traits>
+constexpr bool has_user_traits_v = has_user_traits<S, Traits...>::value;
+
+template<typename S, typename... Traits>
+constexpr bool has_any_user_traits_v = has_any_user_traits<S, Traits...>::value;
+
+}
+#endif /*INCLUDED_SRC_CHECKPOINT_SERIALIZERS_SERIALIZER_REF_H*/
diff --git a/src/checkpoint/serializers/serializers_headers.h b/src/checkpoint/serializers/serializers_headers.h
index 395a063d..e9b4c674 100644
--- a/src/checkpoint/serializers/serializers_headers.h
+++ b/src/checkpoint/serializers/serializers_headers.h
@@ -46,21 +46,22 @@
 
 #include "checkpoint/common.h"
 #include "checkpoint/serializers/base_serializer.h"
+#include "checkpoint/serializers/serializer_ref.h"
 #include "checkpoint/serializers/footprinter.h"
 #include "checkpoint/serializers/sizer.h"
 #include "checkpoint/serializers/packer.h"
 #include "checkpoint/serializers/unpacker.h"
 #include "checkpoint/serializers/stream_serializer.h"
 
-#define checkpoint_serializer_variadic_args()   \
-  checkpoint::Footprinter,                      \
-  checkpoint::Packer,                           \
-  checkpoint::PackerUserBuf,                    \
-  checkpoint::PackerIO,                         \
-  checkpoint::Unpacker,                         \
-  checkpoint::UnpackerIO,                       \
-  checkpoint::Sizer,                            \
-  checkpoint::StreamPacker<>,                   \
-  checkpoint::StreamUnpacker<>                  \
+#define checkpoint_serializer_variadic_args()             \
+  checkpoint::SerializerRef<checkpoint::Footprinter>,     \
+  checkpoint::SerializerRef<checkpoint::Packer>,          \
+  checkpoint::SerializerRef<checkpoint::PackerUserBuf>,   \
+  checkpoint::SerializerRef<checkpoint::PackerIO>,        \
+  checkpoint::SerializerRef<checkpoint::Unpacker>,        \
+  checkpoint::SerializerRef<checkpoint::UnpackerIO>,      \
+  checkpoint::SerializerRef<checkpoint::Sizer>,           \
+  checkpoint::SerializerRef<checkpoint::StreamPacker<>>,  \
+  checkpoint::SerializerRef<checkpoint::StreamUnpacker<>> \
 
 #endif /*INCLUDED_SRC_CHECKPOINT_SERIALIZERS_SERIALIZERS_HEADERS_H*/
diff --git a/src/checkpoint/traits/serializable_traits.h b/src/checkpoint/traits/serializable_traits.h
index 3dc8b0bb..fef2e7cb 100644
--- a/src/checkpoint/traits/serializable_traits.h
+++ b/src/checkpoint/traits/serializable_traits.h
@@ -86,7 +86,7 @@ struct isByteCopyableImpl {
 template <typename T>
 struct isByteCopyable : detail::isByteCopyableImpl<T>::has_byteCopyTraitTrue {};
 
-template <typename T, typename S = checkpoint::BaseSerializer>
+template <typename T, typename S = checkpoint::SerializerRef<BaseSerializer>>
 struct SerializableTraits {
   /**
    * Start with detection of "serialize" overloads, intrusive and non-intrusive.
diff --git a/src/checkpoint/traits/user_traits.h b/src/checkpoint/traits/user_traits.h
new file mode 100644
index 00000000..3837e857
--- /dev/null
+++ b/src/checkpoint/traits/user_traits.h
@@ -0,0 +1,176 @@
+/*
+//@HEADER
+// *****************************************************************************
+//
+//                                user_traits.h
+//                 DARMA/magistrate => Serialization Library
+//
+// Copyright 2019 National Technology & Engineering Solutions of Sandia, LLC
+// (NTESS). Under the terms of Contract DE-NA0003525 with NTESS, the U.S.
+// Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from this
+//   software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact darma@sandia.gov
+//
+// *****************************************************************************
+//@HEADER
+*/
+
+#if !defined INCLUDED_SRC_CHECKPOINT_TRAITS_USER_TRAITS_H
+#define INCLUDED_SRC_CHECKPOINT_TRAITS_USER_TRAITS_H
+
+namespace checkpoint {
+namespace serializerUserTraits {
+
+  template<typename U, typename V>
+  struct is_base_or_derived
+    : std::disjunction<std::is_base_of<U,V>, std::is_base_of<V,U>> {};
+
+  template<typename U, typename V>
+  struct is_same_template
+    : std::false_type {};
+  template<template <typename...> typename Templ, typename... U, typename... V>
+  struct is_same_template<Templ<U...>, Templ<V...>>
+    : std::true_type {};
+
+  template<typename U, typename V>
+  struct traits_match
+    : std::disjunction<
+#ifdef CHECKPOINT_INHERITED_USER_TRAITS
+        is_base_or_derived<std::decay_t<U>,std::decay_t<V>>,
+#endif
+#ifdef CHECKPOINT_TEMPLATED_USER_TRAITS
+        is_same_template<std::decay_t<U>,std::decay_t<V>>,
+#endif
+        std::is_same<std::decay_t<U>,std::decay_t<V>>
+      > {};
+  template<typename U, typename V>
+  inline constexpr bool traits_match_v = traits_match<U,V>::value;
+
+  struct NoTrait;
+
+  template<typename Traits, typename T, typename... U>
+  struct without_helper {
+    using type = typename without_helper<typename Traits::template _without_trait<T>, U...>::type;
+  };
+  template<typename Traits, typename T>
+  struct without_helper<Traits, T> {
+    using type = typename Traits::template _without_trait<T>;
+  };
+
+
+  template<typename Trait = NoTrait, typename... Traits>
+  struct TraitHolder {
+  protected:
+    template<typename, typename...>
+    friend struct TraitHolder;
+
+    template<typename T>
+    using has_trait = std::disjunction<traits_match<T, Trait>, traits_match<T, Traits>...>;
+
+  public:
+
+    //Remove one at a time, so we can allow multiple trait copies to be removed independently.
+    template<typename T>
+    using _without_trait = std::conditional_t<
+                            traits_match_v<T, Trait>,
+                            TraitHolder<Traits...>,
+                            typename TraitHolder<Traits...>::template _without_trait<T>::template with_pre<Trait>
+                          >;
+    template<typename... T>
+    using with = TraitHolder<Trait, Traits..., T...>;
+    //To respect ordering. Could be handy in the future -- disambiguating multiple hooks?
+    template<typename... T>
+    using with_pre = TraitHolder<T..., Trait, Traits...>;
+
+    //Flush out any nested traits (TraitHolder<..., TraitHolder<...>, ...>)
+    //Remove any NoTraits, unless that's the only trait.
+    using BaseTraits = typename TraitHolder<Traits...>::BaseTraits::template with_pre<Trait>;
+
+    template<typename... T>
+    using has = std::conjunction<has_trait<T>...>;
+    template<typename... T>
+    using has_any = std::disjunction<has_trait<T>...>;
+
+    template<typename T, typename... U>
+    using without = typename without_helper<BaseTraits, T, U...>::type;
+  };
+
+  //Empty specialization w/ shortcuts.
+  template<>
+  struct TraitHolder<NoTrait> {
+    using BaseTraits = TraitHolder<NoTrait>;
+
+    template<typename... T>
+    using has = std::false_type;
+    template<typename... T>
+    using has_any = std::false_type;
+
+    template<typename... T>
+    static constexpr bool has_v = false;
+    template<typename... T>
+    static constexpr bool has_any_v = false;
+
+    template<typename... T>
+    using with = TraitHolder<T...>;
+    template<typename... T>
+    using with_pre = TraitHolder<T...>;
+
+    template<typename... T>
+    using without = TraitHolder<NoTrait>;
+
+    template<typename T>
+    using _without_trait = TraitHolder<NoTrait>;
+
+  protected:
+    template<typename T>
+    using has_trait = std::false_type;
+
+    template<typename, typename...>
+    friend struct TraitHolder;
+    template<typename, typename, typename...>
+    friend struct without_helper;
+  };
+
+  //Specialization to remove nested traits.
+  template<typename... Traits, typename... NestedTraits>
+  struct TraitHolder<TraitHolder<NestedTraits...>, Traits...>
+        : public TraitHolder<NestedTraits..., Traits...> {};
+  //Ignore nested NoTrait
+  template<typename... Traits>
+  struct TraitHolder<TraitHolder<NoTrait>, Traits...>
+        : public TraitHolder<Traits...> {};
+
+} //namespace serializerUserTraits
+
+
+  template<typename... Traits>
+  using UserTraitHolder = typename serializerUserTraits::template TraitHolder<Traits...>::BaseTraits;
+} //namespace checkpoint
+
+#endif /*INCLUDED_SRC_CHECKPOINT_TRAITS_USER_TRAITS_H*/
diff --git a/tests/unit/test_user_traits.cc b/tests/unit/test_user_traits.cc
new file mode 100644
index 00000000..7b01d4c2
--- /dev/null
+++ b/tests/unit/test_user_traits.cc
@@ -0,0 +1,238 @@
+/*
+//@HEADER
+// *****************************************************************************
+//
+//                             test_user_traits.cc
+//                 DARMA/magistrate => Serialization Library
+//
+// Copyright 2019 National Technology & Engineering Solutions of Sandia, LLC
+// (NTESS). Under the terms of Contract DE-NA0003525 with NTESS, the U.S.
+// Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from this
+//   software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact darma@sandia.gov
+//
+// *****************************************************************************
+//@HEADER
+*/
+
+#include "test_harness.h"
+
+#include <checkpoint/checkpoint.h>
+
+#include <gtest/gtest.h>
+
+#include <vector>
+#include <cstdio>
+
+namespace checkpoint { namespace tests { namespace unit {
+template <typename T>
+struct TestUserTraits : TestHarness { };
+TYPED_TEST_CASE_P(TestUserTraits);
+
+struct CheckpointTrait {};
+struct CheckpointTraitNonintrusive {};
+namespace CheckpointNamespace {
+struct CheckpointTraitNamespaced {};
+}
+
+struct ShallowTrait {};
+struct TraitPairA {};
+struct TraitPairB {};
+
+static constexpr int const u_val = 'a';
+struct UserObjectA {
+  UserObjectA() = default;
+  explicit UserObjectA(int val)
+    : name('A'), val_a(val) {};
+  explicit UserObjectA(int val, char name_)
+    : name(name_), val_a(val) {};
+
+  template <typename S>
+  void serialize(S& s) {
+    std::cout << "A: serializing with type " << typeid(s).name() << std::endl;
+    EXPECT_FALSE((checkpoint::has_user_traits_v<S, ShallowTrait>));
+
+    EXPECT_EQ(
+      (checkpoint::has_user_traits_v<S, TraitPairA>),
+      (checkpoint::has_user_traits_v<S, TraitPairB>)
+    );
+
+    if constexpr(checkpoint::has_user_traits_v<S, CheckpointTrait>){
+      s | name;
+    }
+    s | val_a;
+  }
+
+  char name;
+  int val_a;
+};
+
+template<
+  typename S,
+  typename = typename std::enable_if_t<checkpoint::has_user_traits_v<S, CheckpointTraitNonintrusive>>
+>
+void serialize(S& s, UserObjectA& obj){
+  s | obj.name;
+  obj.serialize(s);
+}
+
+namespace CheckpointNamespace {
+template<
+  typename S,
+  typename = typename std::enable_if_t<checkpoint::has_user_traits_v<S, CheckpointTraitNamespaced>>
+>
+void serialize(S& s, UserObjectA& obj){
+  s | obj.name;
+  obj.serialize(s);
+}
+} // CheckpointNamespace
+
+/*
+ * Test that trait handling works from different sources
+ */
+TYPED_TEST_P(TestUserTraits, test_serialize_extra) {
+  using Trait = TypeParam;
+
+  UserObjectA objA(u_val);
+  char new_name = 'Z', old_name = objA.name;
+  ASSERT_NE(new_name, old_name);
+
+  //Without the checkpoint trait, name shouldn't be checkpointed.
+  auto serA = checkpoint::serialize(objA);
+  objA.name = new_name;
+  checkpoint::deserializeInPlace(serA->getBuffer(), &objA);
+  EXPECT_EQ(objA.name, new_name);
+  EXPECT_NE(objA.name, old_name);
+
+  //With the checkpoint trait, name change should be undone
+  objA.name = old_name;
+  serA = checkpoint::serialize<UserObjectA, Trait>(objA);
+  objA.name = new_name;
+  checkpoint::deserializeInPlace<UserObjectA, Trait>(serA->getBuffer(), &objA);
+  EXPECT_EQ(objA.name, old_name);
+  EXPECT_NE(objA.name, new_name);
+}
+REGISTER_TYPED_TEST_CASE_P(TestUserTraits, test_serialize_extra);
+using TraitTypes = ::testing::Types<CheckpointTrait, CheckpointTraitNonintrusive, CheckpointNamespace::CheckpointTraitNamespaced>;
+INSTANTIATE_TYPED_TEST_CASE_P(checkpoint_trait, TestUserTraits, TraitTypes, );
+
+
+
+struct UserObjectB : public UserObjectA {
+  UserObjectB() = default;
+  explicit UserObjectB(int val)
+    : UserObjectA(0, 'B'), val_b(val) {};
+
+  template <typename S>
+  void serialize(S& s) {
+    std::cout << "B: serializing with type " << typeid(s).name() << std::endl;
+
+    auto new_s = s.template withoutTraits<ShallowTrait>();
+    if (checkpoint::has_user_traits_v<S, TraitPairA>){
+      auto newer_s = new_s.template withTraits<TraitPairB>();
+      UserObjectA::serialize(newer_s);
+    } else {
+      UserObjectA::serialize(new_s);
+    }
+
+    s | val_b;
+  }
+
+  int val_b;
+};
+
+TEST(TestUserTraits, test_trait_removal) {
+  UserObjectB objB(u_val);
+  int old_b_val = objB.val_b, old_a_val = objB.val_a;
+  int new_b_val = old_b_val+1, new_a_val = old_a_val+1;
+
+  auto serB = checkpoint::serialize<UserObjectB, ShallowTrait>(objB);
+  objB.val_b = new_b_val;
+  objB.val_a = new_a_val;
+  checkpoint::deserializeInPlace<UserObjectB, ShallowTrait>(serB->getBuffer(), &objB);
+  EXPECT_EQ(objB.val_b, old_b_val);
+  EXPECT_NE(objB.val_b, new_b_val);
+  EXPECT_EQ(objB.val_a, old_a_val);
+  EXPECT_NE(objB.val_a, new_a_val);
+}
+
+TEST(TestUserTraits, test_trait_addition) {
+  UserObjectB objB(u_val);
+  int old_b_val = objB.val_b, old_a_val = objB.val_a;
+  int new_b_val = old_b_val+1, new_a_val = old_a_val+1;
+
+  auto serB = checkpoint::serialize<UserObjectB, TraitPairA>(objB);
+  objB.val_b = new_b_val;
+  objB.val_a = new_a_val;
+  checkpoint::deserializeInPlace<UserObjectB, TraitPairA>(serB->getBuffer(), &objB);
+  EXPECT_EQ(objB.val_b, old_b_val);
+  EXPECT_NE(objB.val_b, new_b_val);
+  EXPECT_EQ(objB.val_a, old_a_val);
+  EXPECT_NE(objB.val_a, new_a_val);
+}
+
+
+namespace test_user_traits {
+  //Helper type for brevity in the trait detection test
+  template<typename... Traits>
+  using S = checkpoint::SerializerRef<
+    checkpoint::Sizer,
+    checkpoint::UserTraitHolder<Traits...>
+  >;
+}
+
+TEST(TestUserTraits, test_trait_detection) {
+  using test_user_traits::S;
+  using T = CheckpointTrait;
+  using U = ShallowTrait;
+
+  using checkpoint::has_user_traits_v;
+  EXPECT_TRUE (( has_user_traits_v< S<T>, T>    ));
+  EXPECT_FALSE(( has_user_traits_v< S<T>, U>    ));
+  EXPECT_FALSE(( has_user_traits_v< S<T>, T, U> ));
+  EXPECT_FALSE(( has_user_traits_v< S<T>, U, T> ));
+
+  EXPECT_TRUE (( has_user_traits_v< S<T,U>, T>    ));
+  EXPECT_TRUE (( has_user_traits_v< S<U,T>, T>    ));
+  EXPECT_TRUE (( has_user_traits_v< S<T,U>, T, U> ));
+  EXPECT_TRUE (( has_user_traits_v< S<T,U>, U, T> ));
+
+  using checkpoint::has_any_user_traits_v;
+  EXPECT_TRUE (( has_any_user_traits_v< S<T>, T, U> ));
+  EXPECT_TRUE (( has_any_user_traits_v< S<T>, U, T> ));
+  EXPECT_FALSE(( has_any_user_traits_v< S<T>, U>    ));
+
+  EXPECT_TRUE (( has_any_user_traits_v< S<T,U>, T>    ));
+  EXPECT_TRUE (( has_any_user_traits_v< S<U,T>, T>    ));
+  EXPECT_TRUE (( has_any_user_traits_v< S<T,U>, T, U> ));
+  EXPECT_TRUE (( has_any_user_traits_v< S<T,U>, U, T> ));
+}
+
+
+}}} // end namespace checkpoint::tests::unit