diff --git a/data_tamer_cpp/CMakeLists.txt b/data_tamer_cpp/CMakeLists.txt
index 388c9be..5924974 100644
--- a/data_tamer_cpp/CMakeLists.txt
+++ b/data_tamer_cpp/CMakeLists.txt
@@ -29,6 +29,17 @@ if (DATA_TAMER_BUILD_ROS)
     endif()
 endif()
 
+option(DATA_TAMER_EIGEN_SUPPORT "Enable Eigen support" ON)
+if (DATA_TAMER_EIGEN_SUPPORT)
+    find_package(Eigen3 QUIET)
+    if (NOT Eigen3_FOUND)
+        set(DATA_TAMER_EIGEN_SUPPORT FALSE)
+        message(WARNING "Eigen3 not found, building without Eigen support. Set DATA_TAMER_EIGEN_SUPPORT to false to disable this warning.")
+    else()
+        message(STATUS "Eigen3 found, building with Eigen support.")
+    endif()
+endif()
+
 ###########################################
 # check if mcap can be found. If true,
 # probably we used conan. If false, build from 3rdparty
@@ -95,6 +106,7 @@ target_include_directories(data_tamer
   $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/3rdparty>
 )
 target_compile_definitions(data_tamer PUBLIC -DDATA_TAMER_VERSION="${CMAKE_PROJECT_VERSION}")
+target_compile_definitions(data_tamer PUBLIC DATA_TAMER_EIGEN_SUPPORT=$<BOOL:${DATA_TAMER_EIGEN_SUPPORT}>)
 
 set(INSTALL_TARGETS data_tamer)
 
@@ -125,18 +137,33 @@ if (DATA_TAMER_BUILD_ROS)
         ${MCAP_LIBRARY}
     )
 
+    if (DATA_TAMER_EIGEN_SUPPORT)
+        target_link_libraries(data_tamer PUBLIC Eigen3::Eigen)
+    endif()
+
     ament_export_targets(data_tamerTargets HAS_LIBRARY_TARGET)
     ament_export_dependencies(mcap_vendor rclcpp rclcpp_lifecycle data_tamer_msgs)
+    if (DATA_TAMER_EIGEN_SUPPORT)
+        ament_export_dependencies(Eigen3)
+    endif()
+
     ament_package()
 
 elseif( USE_VENDORED_MCAP )
     target_include_directories(data_tamer PRIVATE
         $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/3rdparty/mcap/include> )
     target_link_libraries(data_tamer PRIVATE mcap_lib)
+    if (DATA_TAMER_EIGEN_SUPPORT)
+        target_link_libraries(data_tamer PUBLIC Eigen3::Eigen)
+    endif()
+
     list(APPEND INSTALL_TARGETS mcap_lib)
 else()
     find_package(mcap REQUIRED)
     target_link_libraries(data_tamer PRIVATE mcap::mcap)
+    if (DATA_TAMER_EIGEN_SUPPORT)
+        target_link_libraries(data_tamer PUBLIC Eigen3::Eigen)
+    endif()
 endif()
 
 install(
diff --git a/data_tamer_cpp/include/data_tamer/channel.hpp b/data_tamer_cpp/include/data_tamer/channel.hpp
index 6cee1a5..22cb721 100644
--- a/data_tamer_cpp/include/data_tamer/channel.hpp
+++ b/data_tamer_cpp/include/data_tamer/channel.hpp
@@ -7,6 +7,10 @@
 #include <chrono>
 #include <memory>
 
+#if DATA_TAMER_EIGEN_SUPPORT
+#include <Eigen/Dense>
+#endif
+
 namespace DataTamer
 {
 using SerializeMe::has_TypeDefinition;
@@ -86,8 +90,9 @@ class LogChannel : public std::enable_shared_from_this<LogChannel>
    * @param value  pointer to the vectors of values.
    * @return       the ID to be used to unregister or enable/disable the values.
    */
-  template <template <class, class> class Container, class T, class... TArgs,
-            std::enable_if_t<!has_TypeDefinition<Container<T, TArgs...>>::value, bool> = true>
+  template <
+      template <class, class> class Container, class T, class... TArgs,
+      std::enable_if_t<!has_TypeDefinition<Container<T, TArgs...>>::value, bool> = true>
   RegistrationID registerValue(const std::string& name,
                                const Container<T, TArgs...>* value);
 
@@ -104,6 +109,10 @@ class LogChannel : public std::enable_shared_from_this<LogChannel>
             std::enable_if_t<!has_TypeDefinition<std::array<T, N>>::value, bool> = true>
   RegistrationID registerValue(const std::string& name, const std::array<T, N>* value);
 
+#if DATA_TAMER_EIGEN_SUPPORT
+  RegistrationID registerValue(const std::string& prefix, const Eigen::VectorXd* value);
+#endif
+
   /**
    * @brief registerCustomValue should be used when you want to "bypass" the serialization
    * provided by DataTamer and use your own.
@@ -325,6 +334,14 @@ inline RegistrationID LogChannel::registerValue(const std::string& prefix,
   }
 }
 
+#if DATA_TAMER_EIGEN_SUPPORT
+inline RegistrationID LogChannel::registerValue(const std::string& prefix,
+                                                const Eigen::VectorXd* value)
+{
+  return registerValueImpl(prefix, ValuePtr(value), {});
+}
+#endif
+
 template <typename T>
 inline std::shared_ptr<LoggedValue<T>>
 LogChannel::createLoggedValue(std::string const& name, T initial_value)
diff --git a/data_tamer_cpp/include/data_tamer/values.hpp b/data_tamer_cpp/include/data_tamer/values.hpp
index 44c5cd1..f4e429e 100644
--- a/data_tamer_cpp/include/data_tamer/values.hpp
+++ b/data_tamer_cpp/include/data_tamer/values.hpp
@@ -7,6 +7,9 @@
 #include "data_tamer/custom_types.hpp"
 #include "data_tamer/contrib/SerializeMe.hpp"
 
+#if DATA_TAMER_EIGEN_SUPPORT
+#include <Eigen/Dense>
+#endif
 namespace DataTamer
 {
 using SerializeMe::has_TypeDefinition;
@@ -23,12 +26,14 @@ class ValuePtr
   template <typename T, bool = true>
   ValuePtr(const T* pointer, CustomSerializer::Ptr type_info = {});
 
-  template <template <class, class> class Container, class T, class... TArgs,
-            std::enable_if_t<!has_TypeDefinition<Container<T, TArgs...>>::value, bool> = true>
+  template <
+      template <class, class> class Container, class T, class... TArgs,
+      std::enable_if_t<!has_TypeDefinition<Container<T, TArgs...>>::value, bool> = true>
   ValuePtr(const Container<T, TArgs...>* vect);
 
-  template <template <class, class> class Container, class T, class... TArgs,
-            std::enable_if_t<!has_TypeDefinition<Container<T, TArgs...>>::value, bool> = true>
+  template <
+      template <class, class> class Container, class T, class... TArgs,
+      std::enable_if_t<!has_TypeDefinition<Container<T, TArgs...>>::value, bool> = true>
   ValuePtr(const Container<T, TArgs...>* vect, CustomSerializer::Ptr type_info);
 
   template <typename T, size_t N,
@@ -39,6 +44,10 @@ class ValuePtr
             std::enable_if_t<!has_TypeDefinition<std::array<T, N>>::value, bool> = true>
   ValuePtr(const std::array<T, N>* vect, CustomSerializer::Ptr type_info);
 
+#if DATA_TAMER_EIGEN_SUPPORT
+  ValuePtr(const Eigen::VectorXd* vect);
+#endif
+
   ValuePtr(ValuePtr const& other) = delete;
   ValuePtr& operator=(ValuePtr const& other) = delete;
 
@@ -144,7 +153,8 @@ inline ValuePtr::ValuePtr(const Container<T, TArgs...>* vect,
   };
 }
 
-template <typename T, size_t N, std::enable_if_t<!has_TypeDefinition<std::array<T, N>>::value, bool>>
+template <typename T, size_t N,
+          std::enable_if_t<!has_TypeDefinition<std::array<T, N>>::value, bool>>
 inline ValuePtr::ValuePtr(const std::array<T, N>* array)
   : v_ptr_(array)
   , type_(GetBasicType<T>())
@@ -158,7 +168,8 @@ inline ValuePtr::ValuePtr(const std::array<T, N>* array)
   get_size_impl_ = [array]() { return SerializeMe::BufferSize(*array); };
 }
 
-template <typename T, size_t N, std::enable_if_t<!has_TypeDefinition<std::array<T, N>>::value, bool>>
+template <typename T, size_t N,
+          std::enable_if_t<!has_TypeDefinition<std::array<T, N>>::value, bool>>
 inline ValuePtr::ValuePtr(const std::array<T, N>* array, CustomSerializer::Ptr type_info)
   : v_ptr_(array)
   , type_(GetBasicType<T>())
@@ -186,6 +197,33 @@ inline ValuePtr::ValuePtr(const std::array<T, N>* array, CustomSerializer::Ptr t
   };
 }
 
+#if DATA_TAMER_EIGEN_SUPPORT
+inline ValuePtr::ValuePtr(const Eigen::VectorXd* vect)
+  : v_ptr_(vect)
+  , type_(GetBasicType<double>())         // element type
+  , type_index_(typeid(Eigen::VectorXd))  // identifies the "container type"
+  , memory_size_(sizeof(double))          // element size (consistent with containers)
+  , is_vector_(true)
+{
+  serialize_impl_ = [vect](SerializeMe::SpanBytes& buffer) -> void {
+    const uint32_t n = static_cast<uint32_t>(vect->size());
+    SerializeMe::SerializeIntoBuffer(buffer, n);
+
+    // contiguous block of doubles
+    const size_t bytes = static_cast<size_t>(n) * sizeof(double);
+    if(bytes > 0)
+    {
+      std::memcpy(buffer.data(), vect->data(), bytes);
+      buffer.trimFront(bytes);
+    }
+  };
+
+  get_size_impl_ = [vect]() -> size_t {
+    return sizeof(uint32_t) + static_cast<size_t>(vect->size()) * sizeof(double);
+  };
+}
+#endif
+
 inline bool ValuePtr::operator==(const ValuePtr& other) const
 {
   return type_ == other.type_ && type_index_ == other.type_index_ &&