diff --git a/.clang-tidy b/.clang-tidy
index dbfa2e52b0980807abc5441bd03fc921e9bfa728..c80092d12cedd30e6a4e8ccc1177cb5e5b735b2d 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -6,6 +6,8 @@ bugprone-*,\
 clang-analyzer-*,\
 -clang-analyzer-security.insecureAPI.DeprecatedOrUnsafeBufferHandling,\
 misc-*,\
+-misc-include-cleaner,\
+-misc-use-anonymous-namespace,\
 modernize-*,\
 -modernize-use-trailing-return-type,\
 mpi-*,\
diff --git a/src/catalyst/catalyst_conduit.hpp b/src/catalyst/catalyst_conduit.hpp
index c3b2fe614b253735951e037d9307f41da1511184..7aa2f3e6908405363031ddbd1aab28d37a65aef0 100644
--- a/src/catalyst/catalyst_conduit.hpp
+++ b/src/catalyst/catalyst_conduit.hpp
@@ -67,6 +67,7 @@ Additional BSD Notice
 #ifndef catalyst_conduit_hpp
 #define catalyst_conduit_hpp
 
+#include <cstdlib>
 #include <cstring>
 #include <iostream>
 #include <memory>
@@ -121,9 +122,9 @@ public:
 
   static int size_of_index_t() { return conduit_datatype_sizeof_index_t(); }
 
-  bool is_valid() const { return this->c_dtype != nullptr; }
+  [[nodiscard]] bool is_valid() const { return this->c_dtype != nullptr; }
 
-  Id id() const
+  [[nodiscard]] Id id() const
   {
     if (!this->is_valid())
     {
@@ -176,12 +177,12 @@ public:
     return Id::unknown;
   }
 
-  bool is_empty() const { return conduit_datatype_is_empty(this->c_dtype); }
-  bool is_object() const { return conduit_datatype_is_object(this->c_dtype); }
-  bool is_list() const { return conduit_datatype_is_list(this->c_dtype); }
+  [[nodiscard]] bool is_empty() const { return conduit_datatype_is_empty(this->c_dtype); }
+  [[nodiscard]] bool is_object() const { return conduit_datatype_is_object(this->c_dtype); }
+  [[nodiscard]] bool is_list() const { return conduit_datatype_is_list(this->c_dtype); }
 
-  conduit_index_t type_id() const { return conduit_datatype_id(this->c_dtype); }
-  std::string name() const
+  [[nodiscard]] conduit_index_t type_id() const { return conduit_datatype_id(this->c_dtype); }
+  [[nodiscard]] std::string name() const
   {
     char* c_name = conduit_datatype_name(this->c_dtype);
     std::string name = c_name;
@@ -189,57 +190,84 @@ public:
     return name;
   }
 
-  conduit_index_t number_of_elements() const
+  [[nodiscard]] conduit_index_t number_of_elements() const
   {
     return conduit_datatype_number_of_elements(this->c_dtype);
   }
-  conduit_index_t offset() const { return conduit_datatype_offset(this->c_dtype); }
-  conduit_index_t stride() const { return conduit_datatype_stride(this->c_dtype); }
-  conduit_index_t element_bytes() const { return conduit_datatype_element_bytes(this->c_dtype); }
+  [[nodiscard]] conduit_index_t offset() const { return conduit_datatype_offset(this->c_dtype); }
+  [[nodiscard]] conduit_index_t stride() const { return conduit_datatype_stride(this->c_dtype); }
+  [[nodiscard]] conduit_index_t element_bytes() const
+  {
+    return conduit_datatype_element_bytes(this->c_dtype);
+  }
   conduit_index_t endianness() const { return conduit_datatype_endianness(this->c_dtype); }
-  conduit_index_t element_index(conduit_index_t idx) const
+  [[nodiscard]] conduit_index_t element_index(conduit_index_t idx) const
   {
     return conduit_datatype_element_index(this->c_dtype, idx);
   }
 
-  bool is_number() const { return conduit_datatype_is_number(this->c_dtype); }
-  bool is_floating_point() const { return conduit_datatype_is_floating_point(this->c_dtype); }
-  bool is_integer() const { return conduit_datatype_is_integer(this->c_dtype); }
-  bool is_signed_integer() const { return conduit_datatype_is_signed_integer(this->c_dtype); }
-  bool is_unsigned_integer() const { return conduit_datatype_is_unsigned_integer(this->c_dtype); }
+  [[nodiscard]] bool is_number() const { return conduit_datatype_is_number(this->c_dtype); }
+  [[nodiscard]] bool is_floating_point() const
+  {
+    return conduit_datatype_is_floating_point(this->c_dtype);
+  }
+  [[nodiscard]] bool is_integer() const { return conduit_datatype_is_integer(this->c_dtype); }
+  [[nodiscard]] bool is_signed_integer() const
+  {
+    return conduit_datatype_is_signed_integer(this->c_dtype);
+  }
+  [[nodiscard]] bool is_unsigned_integer() const
+  {
+    return conduit_datatype_is_unsigned_integer(this->c_dtype);
+  }
 
-  bool is_int8() const { return conduit_datatype_is_int8(this->c_dtype); }
-  bool is_int16() const { return conduit_datatype_is_int16(this->c_dtype); }
-  bool is_int32() const { return conduit_datatype_is_int32(this->c_dtype); }
-  bool is_int64() const { return conduit_datatype_is_int64(this->c_dtype); }
+  [[nodiscard]] bool is_int8() const { return conduit_datatype_is_int8(this->c_dtype); }
+  [[nodiscard]] bool is_int16() const { return conduit_datatype_is_int16(this->c_dtype); }
+  [[nodiscard]] bool is_int32() const { return conduit_datatype_is_int32(this->c_dtype); }
+  [[nodiscard]] bool is_int64() const { return conduit_datatype_is_int64(this->c_dtype); }
 
-  bool is_uint8() const { return conduit_datatype_is_uint8(this->c_dtype); }
-  bool is_uint16() const { return conduit_datatype_is_uint16(this->c_dtype); }
-  bool is_uint32() const { return conduit_datatype_is_uint32(this->c_dtype); }
-  bool is_uint64() const { return conduit_datatype_is_uint64(this->c_dtype); }
+  [[nodiscard]] bool is_uint8() const { return conduit_datatype_is_uint8(this->c_dtype); }
+  [[nodiscard]] bool is_uint16() const { return conduit_datatype_is_uint16(this->c_dtype); }
+  [[nodiscard]] bool is_uint32() const { return conduit_datatype_is_uint32(this->c_dtype); }
+  [[nodiscard]] bool is_uint64() const { return conduit_datatype_is_uint64(this->c_dtype); }
 
-  bool is_float32() const { return conduit_datatype_is_float32(this->c_dtype); }
-  bool is_float64() const { return conduit_datatype_is_float64(this->c_dtype); }
+  [[nodiscard]] bool is_float32() const { return conduit_datatype_is_float32(this->c_dtype); }
+  [[nodiscard]] bool is_float64() const { return conduit_datatype_is_float64(this->c_dtype); }
 
-  bool is_char() const { return conduit_datatype_is_char(this->c_dtype); }
-  bool is_short() const { return conduit_datatype_is_short(this->c_dtype); }
-  bool is_int() const { return conduit_datatype_is_int(this->c_dtype); }
-  bool is_long() const { return conduit_datatype_is_long(this->c_dtype); }
+  [[nodiscard]] bool is_char() const { return conduit_datatype_is_char(this->c_dtype); }
+  [[nodiscard]] bool is_short() const { return conduit_datatype_is_short(this->c_dtype); }
+  [[nodiscard]] bool is_int() const { return conduit_datatype_is_int(this->c_dtype); }
+  [[nodiscard]] bool is_long() const { return conduit_datatype_is_long(this->c_dtype); }
 
-  bool is_unsigned_char() const { return conduit_datatype_is_unsigned_char(this->c_dtype); }
-  bool is_unsigned_short() const { return conduit_datatype_is_unsigned_short(this->c_dtype); }
-  bool is_unsigned_int() const { return conduit_datatype_is_unsigned_int(this->c_dtype); }
-  bool is_unsigned_long() const { return conduit_datatype_is_unsigned_long(this->c_dtype); }
+  [[nodiscard]] bool is_unsigned_char() const
+  {
+    return conduit_datatype_is_unsigned_char(this->c_dtype);
+  }
+  [[nodiscard]] bool is_unsigned_short() const
+  {
+    return conduit_datatype_is_unsigned_short(this->c_dtype);
+  }
+  [[nodiscard]] bool is_unsigned_int() const
+  {
+    return conduit_datatype_is_unsigned_int(this->c_dtype);
+  }
+  [[nodiscard]] bool is_unsigned_long() const
+  {
+    return conduit_datatype_is_unsigned_long(this->c_dtype);
+  }
 
-  bool is_float() const { return conduit_datatype_is_float(this->c_dtype); }
-  bool is_double() const { return conduit_datatype_is_double(this->c_dtype); }
+  [[nodiscard]] bool is_float() const { return conduit_datatype_is_float(this->c_dtype); }
+  [[nodiscard]] bool is_double() const { return conduit_datatype_is_double(this->c_dtype); }
 
-  bool is_string() const { return conduit_datatype_is_string(this->c_dtype); }
-  bool is_char8_str() const { return conduit_datatype_is_char8_str(this->c_dtype); }
+  [[nodiscard]] bool is_string() const { return conduit_datatype_is_string(this->c_dtype); }
+  [[nodiscard]] bool is_char8_str() const { return conduit_datatype_is_char8_str(this->c_dtype); }
 
-  bool is_little_endian() const { return conduit_datatype_is_little_endian(this->c_dtype); }
-  bool is_big_endian() const { return conduit_datatype_is_big_endian(this->c_dtype); }
-  bool endianness_matches_machine() const
+  [[nodiscard]] bool is_little_endian() const
+  {
+    return conduit_datatype_is_little_endian(this->c_dtype);
+  }
+  [[nodiscard]] bool is_big_endian() const { return conduit_datatype_is_big_endian(this->c_dtype); }
+  [[nodiscard]] bool endianness_matches_machine() const
   {
     return conduit_datatype_endianness_matches_machine(this->c_dtype);
   }
@@ -1163,58 +1191,70 @@ public:
   /// scalar coercion
 
   /// convert to a signed integer types
-  conduit_int8 to_int8() const { return this->to_type<conduit_int8, conduit_int16>(); }
+  [[nodiscard]] conduit_int8 to_int8() const
+  {
+    return this->to_type<conduit_int8, conduit_int16>();
+  }
 
-  conduit_int16 to_int16() const { return this->to_type<conduit_int16>(); }
+  [[nodiscard]] conduit_int16 to_int16() const { return this->to_type<conduit_int16>(); }
 
-  conduit_int32 to_int32() const { return this->to_type<conduit_int32>(); }
+  [[nodiscard]] conduit_int32 to_int32() const { return this->to_type<conduit_int32>(); }
 
-  conduit_int64 to_int64() const { return this->to_type<conduit_int64>(); }
+  [[nodiscard]] conduit_int64 to_int64() const { return this->to_type<conduit_int64>(); }
 
   /// convert to a unsigned integer types
-  conduit_uint8 to_uint8() const { return this->to_type<conduit_uint8, conduit_uint16>(); }
+  [[nodiscard]] conduit_uint8 to_uint8() const
+  {
+    return this->to_type<conduit_uint8, conduit_uint16>();
+  }
 
-  conduit_uint16 to_uint16() const { return this->to_type<conduit_uint16>(); }
+  [[nodiscard]] conduit_uint16 to_uint16() const { return this->to_type<conduit_uint16>(); }
 
-  conduit_uint32 to_uint32() const { return this->to_type<conduit_uint32>(); }
+  [[nodiscard]] conduit_uint32 to_uint32() const { return this->to_type<conduit_uint32>(); }
 
-  conduit_uint64 to_uint64() const { return this->to_type<conduit_uint64>(); }
+  [[nodiscard]] conduit_uint64 to_uint64() const { return this->to_type<conduit_uint64>(); }
 
   /// convert to a floating point type
-  conduit_float32 to_float32() const { return this->to_type<conduit_float32>(); }
+  [[nodiscard]] conduit_float32 to_float32() const { return this->to_type<conduit_float32>(); }
 
-  conduit_float64 to_float64() const { return this->to_type<conduit_float64>(); }
+  [[nodiscard]] conduit_float64 to_float64() const { return this->to_type<conduit_float64>(); }
 
-  conduit_index_t to_index_t() const { return this->to_type<conduit_index_t>(); }
+  [[nodiscard]] conduit_index_t to_index_t() const { return this->to_type<conduit_index_t>(); }
 
   /// convert to c integer types
-  char to_char() const { return this->to_type<char, conduit_int16>(); }
+  [[nodiscard]] char to_char() const { return this->to_type<char, conduit_int16>(); }
 
-  short to_short() const { return this->to_type<short>(); }
+  [[nodiscard]] short to_short() const { return this->to_type<short>(); }
 
-  int to_int() const { return this->to_type<int>(); }
+  [[nodiscard]] int to_int() const { return this->to_type<int>(); }
 
-  long to_long() const { return this->to_type<long>(); }
+  [[nodiscard]] long to_long() const { return this->to_type<long>(); }
 
   /// convert to c signed integer types
-  signed char to_signed_char() const { return this->to_type<signed char, conduit_int16>(); }
+  [[nodiscard]] signed char to_signed_char() const
+  {
+    return this->to_type<signed char, conduit_int16>();
+  }
 
-  signed short to_signed_short() const { return this->to_type<signed short>(); }
+  [[nodiscard]] signed short to_signed_short() const { return this->to_type<signed short>(); }
 
-  signed int to_signed_int() const { return this->to_type<signed int>(); }
+  [[nodiscard]] signed int to_signed_int() const { return this->to_type<signed int>(); }
 
-  signed long to_signed_long() const { return this->to_type<signed long>(); }
+  [[nodiscard]] signed long to_signed_long() const { return this->to_type<signed long>(); }
 
   /// convert to c unsigned integer types
-  unsigned char to_unsigned_char() const { return this->to_type<unsigned char, conduit_uint16>(); }
-  unsigned short to_unsigned_short() const { return this->to_type<unsigned short>(); }
-  unsigned int to_unsigned_int() const { return this->to_type<unsigned int>(); }
-  unsigned long to_unsigned_long() const { return this->to_type<unsigned long>(); }
+  [[nodiscard]] unsigned char to_unsigned_char() const
+  {
+    return this->to_type<unsigned char, conduit_uint16>();
+  }
+  [[nodiscard]] unsigned short to_unsigned_short() const { return this->to_type<unsigned short>(); }
+  [[nodiscard]] unsigned int to_unsigned_int() const { return this->to_type<unsigned int>(); }
+  [[nodiscard]] unsigned long to_unsigned_long() const { return this->to_type<unsigned long>(); }
 
   /// convert to c floating point types
-  float to_float() const { return this->to_type<float>(); }
+  [[nodiscard]] float to_float() const { return this->to_type<float>(); }
 
-  double to_double() const { return this->to_type<double>(); }
+  [[nodiscard]] double to_double() const { return this->to_type<double>(); }
 
   //-----------------------------------------------------------------------------
   //
@@ -1229,19 +1269,19 @@ public:
   ///  These methods provide general info about the node.
   //-----------------------------------------------------------------------------
 
-  DataType dtype() const { return { this->c_dtype() }; }
-  const conduit_datatype* c_dtype() const { return conduit_node_dtype(this->c_node); }
+  [[nodiscard]] DataType dtype() const { return { this->c_dtype() }; }
+  [[nodiscard]] const conduit_datatype* c_dtype() const { return conduit_node_dtype(this->c_node); }
 
   //-------------------------------------------------------------------------
   /// contiguous checks
   //-------------------------------------------------------------------------
 
   /// Does this node has a contiguous data layout?
-  bool is_contiguous() const { return conduit_node_is_contiguous(this->c_node); }
+  [[nodiscard]] bool is_contiguous() const { return conduit_node_is_contiguous(this->c_node); }
 
   /// true if node hierarchy's memory contiguously follows
   /// the given node's memory
-  bool contiguous_with(const Node& n) const
+  [[nodiscard]] bool contiguous_with(const Node& n) const
   {
     return conduit_node_contiguous_with_node(this->c_node, n.c_node);
   }
@@ -1254,7 +1294,10 @@ public:
   }
 
   /// is this node compatible with given node
-  bool compatible(const Node& n) const { return conduit_node_compatible(this->c_node, n.c_node); }
+  [[nodiscard]] bool compatible(const Node& n) const
+  {
+    return conduit_node_compatible(this->c_node, n.c_node);
+  }
 
   /// check for differences between this node and the given node, storing
   //  the results digest in the provided data node
@@ -1278,7 +1321,7 @@ public:
   /// node's memory properties
   void info(Node& nres) const { conduit_node_info(this->c_node, nres.c_node); }
 
-  Node info() const
+  [[nodiscard]] Node info() const
   {
     Node ret;
     this->info(ret);
@@ -1298,26 +1341,29 @@ public:
   //-----------------------------------------------------------------------------
   // -- data structure print methods ---
   //-----------------------------------------------------------------------------
-  std::string to_json() const { return conduit_node_to_json(this->c_node); }
-  std::string to_json_with_options(const Node& options) const
+  [[nodiscard]] std::string to_json() const { return conduit_node_to_json(this->c_node); }
+  [[nodiscard]] std::string to_json_with_options(const Node& options) const
   {
     return conduit_node_to_json_with_options(this->c_node, options.c_node);
   }
 
-  std::string to_string() const { return conduit_node_to_string(this->c_node); }
-  std::string to_string_with_options(const Node& options) const
+  [[nodiscard]] std::string to_string() const { return conduit_node_to_string(this->c_node); }
+  [[nodiscard]] std::string to_string_with_options(const Node& options) const
   {
     return conduit_node_to_string_with_options(this->c_node, options.c_node);
   }
 
-  std::string to_summary_string() const { return conduit_node_to_summary_string(this->c_node); }
-  std::string to_summary_string_with_options(const Node& options) const
+  [[nodiscard]] std::string to_summary_string() const
+  {
+    return conduit_node_to_summary_string(this->c_node);
+  }
+  [[nodiscard]] std::string to_summary_string_with_options(const Node& options) const
   {
     return conduit_node_to_summary_string_with_options(this->c_node, options.c_node);
   }
 
-  std::string to_yaml() const { return conduit_node_to_yaml(this->c_node); }
-  std::string to_yaml_with_options(const Node& options) const
+  [[nodiscard]] std::string to_yaml() const { return conduit_node_to_yaml(this->c_node); }
+  [[nodiscard]] std::string to_yaml_with_options(const Node& options) const
   {
     return conduit_node_to_yaml_with_options(this->c_node, options.c_node);
   }
@@ -1350,7 +1396,7 @@ public:
   }
 
   // NOLINTNEXTLINE(readability-const-return-type)
-  const Node child(conduit_index_t idx) const
+  [[nodiscard]] const Node child(conduit_index_t idx) const
   {
     CATALYST_CONDUIT_WRAP_EXCEP(return Node(conduit_node_child(this->c_node, idx)));
   }
@@ -1378,22 +1424,22 @@ public:
   const Node operator[](conduit_index_t idx) const { return child(idx); }
 
   /// returns the number of children (list and object interfaces)
-  conduit_index_t number_of_children() const
+  [[nodiscard]] conduit_index_t number_of_children() const
   {
     return conduit_node_number_of_children(this->c_node);
   }
-  conduit_index_t number_of_elements() const
+  [[nodiscard]] conduit_index_t number_of_elements() const
   {
     return conduit_node_number_of_elements(this->c_node);
   }
 
   void reset() { conduit_node_reset(this->c_node); }
   void move(Node& other) { conduit_node_move(this->c_node, other.c_node); }
-  void swap(Node& other) { conduit_node_swap(this->c_node, other.c_node); }
+  void swap(Node& other) noexcept { conduit_node_swap(this->c_node, other.c_node); }
 
   // conduit_node_name uses strdup, which allocates memory
   // on the heap. Must free the result here after copying.
-  std::string name() const
+  [[nodiscard]] std::string name() const
   {
     char* name = conduit_node_name(this->c_node);
     if (!name)
@@ -1408,7 +1454,7 @@ public:
 
   // conduit_node_path uses strdup, which allocates memory
   // on the heap. Must free the result here after copying.
-  std::string path() const
+  [[nodiscard]] std::string path() const
   {
     char* path = conduit_node_path(this->c_node);
     if (!path)
@@ -1423,12 +1469,12 @@ public:
   }
 
   /// checks if a node has a direct child with given name
-  bool has_child(const std::string& name) const
+  [[nodiscard]] bool has_child(const std::string& name) const
   {
     return conduit_node_has_child(this->c_node, name.c_str());
   }
   /// checks if given path exists in the Node hierarchy
-  bool has_path(const std::string& path) const
+  [[nodiscard]] bool has_path(const std::string& path) const
   {
     return conduit_node_has_path(this->c_node, path.c_str());
   }
@@ -1476,7 +1522,7 @@ public:
   //-----------------------------------------------------------------------------
 
 #define catalyst_conduit_as(dname)                                                                 \
-  conduit_##dname as_##dname() const                                                               \
+  [[nodiscard]] conduit_##dname as_##dname() const                                                 \
   {                                                                                                \
     CATALYST_CONDUIT_WRAP_EXCEP(return conduit_node_as_##dname(this->c_node));                     \
   }
@@ -1500,11 +1546,11 @@ public:
 #undef catalyst_conduit_as
 
 #define catalyst_conduit_as_ptr(dname)                                                             \
-  conduit_##dname* as_##dname##_ptr()                                                              \
+  [[nodiscard]] conduit_##dname* as_##dname##_ptr()                                                \
   {                                                                                                \
     CATALYST_CONDUIT_WRAP_EXCEP(return conduit_node_as_##dname##_ptr(this->c_node));               \
   }                                                                                                \
-  const conduit_##dname* as_##dname##_ptr() const                                                  \
+  [[nodiscard]] const conduit_##dname* as_##dname##_ptr() const                                    \
   {                                                                                                \
     CATALYST_CONDUIT_WRAP_EXCEP(return conduit_node_as_##dname##_ptr(this->c_node));               \
   }
@@ -1528,25 +1574,25 @@ public:
 #undef catalyst_conduit_as_ptr
 
   // char8_str cases
-  char* as_char8_str()
+  [[nodiscard]] char* as_char8_str()
   {
     CATALYST_CONDUIT_WRAP_EXCEP(return conduit_node_as_char8_str(this->c_node));
   }
-  const char* as_char8_str() const
+  [[nodiscard]] const char* as_char8_str() const
   {
     CATALYST_CONDUIT_WRAP_EXCEP(return conduit_node_as_char8_str(this->c_node));
   }
-  std::string as_string() const
+  [[nodiscard]] std::string as_string() const
   {
     CATALYST_CONDUIT_WRAP_EXCEP(return std::string(conduit_node_as_char8_str(this->c_node)));
   }
 
   // direct data pointer access
   void* data_ptr() { return conduit_node_data_ptr(this->c_node); }
-  const void* data_ptr() const { return conduit_node_data_ptr(this->c_node); }
+  [[nodiscard]] const void* data_ptr() const { return conduit_node_data_ptr(this->c_node); }
 
   void* element_ptr(conduit_index_t idx) { return conduit_node_element_ptr(this->c_node, idx); }
-  const void* element_ptr(conduit_index_t idx) const
+  [[nodiscard]] const void* element_ptr(conduit_index_t idx) const
   {
     return conduit_node_element_ptr(this->c_node, idx);
   }
@@ -1702,4 +1748,5 @@ inline Node cpp_node(conduit_node* n)
 }
 
 }
+
 #endif
diff --git a/src/catalyst/catalyst_stub.cpp b/src/catalyst/catalyst_stub.cpp
index 92ffa106dc6381124a79f5de3ba2652ca24f3b1b..1232279e937e54b76b775e537ac94d9ad9ae10f0 100644
--- a/src/catalyst/catalyst_stub.cpp
+++ b/src/catalyst/catalyst_stub.cpp
@@ -35,7 +35,7 @@ enum catalyst_status catalyst_stub_about(conduit_node* params)
   conduit_node_set_path_char8_str(params, "catalyst/version", CATALYST_VERSION);
   conduit_node_set_path_char8_str(params, "catalyst/abi_version", CATALYST_ABI_VERSION);
   conduit_node_set_path_char8_str(params, "catalyst/implementation", "stub");
-#if defined(CATALYST_USE_MPI)
+#ifdef CATALYST_USE_MPI
   conduit_node_set_path_int32(params, "catalyst/use_mpi", 1);
 #else
   conduit_node_set_path_int32(params, "catalyst/use_mpi", 0);
diff --git a/src/tools/replay/catalyst_replay.cpp b/src/tools/replay/catalyst_replay.cpp
index a9b435101f01909e4a72270725a58b9f1cedec04..950c820a6e0cb29edea1267a6aee1ccc9b491a5b 100644
--- a/src/tools/replay/catalyst_replay.cpp
+++ b/src/tools/replay/catalyst_replay.cpp
@@ -5,6 +5,9 @@
 #endif
 
 #if defined(_WIN32) && !defined(__CYGWIN__)
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
 #include "windows.h"
 #define PATH_SEP '\\'
 #else
@@ -12,6 +15,7 @@
 #define PATH_SEP '/'
 #endif
 
+#include <algorithm>
 #include <iostream>
 #include <regex>
 #include <sstream>
@@ -21,7 +25,7 @@
 #include <cstdlib>
 
 // NOLINTNEXTLINE(misc-no-recursion)
-void replace_mpi_comm(conduit_cpp::Node& params, std::uint64_t communicator, int depth = 0)
+static void replace_mpi_comm(conduit_cpp::Node& params, std::uint64_t communicator, int depth = 0)
 try
 {
   if (params.has_path("mpi_comm"))
@@ -35,7 +39,8 @@ try
   }
   else if (depth == 0) // for now, we'll only go 1 deep in the tree.
   {
-    for (conduit_index_t max = params.number_of_children(), cc = 0; cc < max; ++cc)
+    const conduit_index_t max = params.number_of_children();
+    for (conduit_index_t cc = 0; cc < max; ++cc)
     {
       auto child = params[cc];
       replace_mpi_comm(child, communicator, depth + 1);
@@ -48,7 +53,7 @@ catch (conduit_cpp::Error const& e)
   abort();
 }
 
-void replay_catalyst_initialize(
+static void replay_catalyst_initialize(
   const std::string& node_dir, int num_ranks, int rank, std::uint64_t communicator)
 {
   conduit_cpp::Node params;
@@ -65,12 +70,12 @@ void replay_catalyst_initialize(
   catalyst_initialize(c_node(&params));
 }
 
-void replay_catalyst_execute(
+static void replay_catalyst_execute(
   const std::string& node_dir, int num_ranks, int rank, unsigned long num_execute_invoc_per_rank)
 {
   for (unsigned long i = 0; i < num_execute_invoc_per_rank; i++)
   {
-    conduit_cpp::Node params;
+    const conduit_cpp::Node params;
     std::stringstream node_path;
     node_path << node_dir << "execute_invc" << i << "_params.conduit_bin"
               << "." << num_ranks << "." << rank;
@@ -81,9 +86,9 @@ void replay_catalyst_execute(
   }
 }
 
-void replay_catalyst_finalize(const std::string& node_dir, int num_ranks, int rank)
+static void replay_catalyst_finalize(const std::string& node_dir, int num_ranks, int rank)
 {
-  conduit_cpp::Node params;
+  const conduit_cpp::Node params;
   std::stringstream node_path;
   node_path << node_dir << "finalize_params.conduit_bin"
             << "." << num_ranks << "." << rank;
@@ -96,21 +101,26 @@ void replay_catalyst_finalize(const std::string& node_dir, int num_ranks, int ra
 // Write out the number of node files for the
 // initialize, execute, and finalize stages to a stringstream.
 // These values are included when we error out.
-void write_num_nodes_per_stage(
+static void write_num_nodes_per_stage(
   std::ostream& ss, unsigned num_initialize, unsigned num_execute, unsigned num_finalize)
 {
-  ss << "Number of node files for initialization stage: " << num_initialize << std::endl
-     << "Number of node files for execute stage: " << num_execute << std::endl
-     << "Number of node files for finalize stage: " << num_finalize << std::endl;
+  ss << "Number of node files for initialization stage: " << num_initialize
+     << "\n"
+        "Number of node files for execute stage: "
+     << num_execute
+     << "\n"
+        "Number of node files for finalize stage: "
+     << num_finalize << '\n';
 }
 
-void write_catalyst_data_dump_dir(std::ostream& ss, const std::string& catalyst_data_dump_directory)
+static void write_catalyst_data_dump_dir(
+  std::ostream& ss, const std::string& catalyst_data_dump_directory)
 {
-  ss << "catalyst_data_dump_directory: " << catalyst_data_dump_directory << std::endl;
+  ss << "catalyst_data_dump_directory: " << catalyst_data_dump_directory << '\n';
 }
 
 // Parses relevant data from the filename passed in using regex matching.
-int parse_fname(const std::regex& fname_patterns, const std::string& fname, int num_ranks,
+static int parse_fname(const std::regex& fname_patterns, const std::string& fname, int num_ranks,
   unsigned& num_initialize, unsigned& num_execute, unsigned& num_finalize,
   unsigned long& num_execute_invoc_per_rank)
 {
@@ -145,13 +155,10 @@ int parse_fname(const std::regex& fname_patterns, const std::string& fname, int
     unsigned long execute_invc_num;
     std::stringstream(matches[3]) >> execute_invc_num;
 
-    if (execute_invc_num + 1 > num_execute_invoc_per_rank)
-    {
-      num_execute_invoc_per_rank = execute_invc_num + 1;
-    }
+    num_execute_invoc_per_rank = std::max(execute_invc_num + 1, num_execute_invoc_per_rank);
   }
 
-  std::string stage = matches[1];
+  const std::string stage = matches[1];
 
   if (stage == "initialize")
   {
@@ -176,7 +183,7 @@ int parse_fname(const std::regex& fname_patterns, const std::string& fname, int
 // and calls parse_fname to extract the relevant data from the filename. This
 // includes things like the number of ranks that were used, which stage the
 // data is from, etc.
-int parse_directory(const std::string& catalyst_data_dump_directory,
+static int parse_directory(const std::string& catalyst_data_dump_directory,
   const std::regex& fname_patterns, int num_ranks, unsigned& num_initialize, unsigned& num_execute,
   unsigned& num_finalize, unsigned long& num_execute_invoc_per_rank)
 {
@@ -213,7 +220,7 @@ int parse_directory(const std::string& catalyst_data_dump_directory,
 
 #else
 // POSIX implementation. See above for documentation.
-int parse_directory(const std::string& catalyst_data_dump_directory,
+static int parse_directory(const std::string& catalyst_data_dump_directory,
   const std::regex& fname_patterns, int num_ranks, unsigned& num_initialize, unsigned& num_execute,
   unsigned& num_finalize, unsigned long& num_execute_invoc_per_rank)
 {
@@ -226,8 +233,8 @@ int parse_directory(const std::string& catalyst_data_dump_directory,
 
   for (dirent* item = readdir(dir); item; item = readdir(dir))
   {
-    int status = parse_fname(fname_patterns, item->d_name, num_ranks, num_initialize, num_execute,
-      num_finalize, num_execute_invoc_per_rank);
+    const int status = parse_fname(fname_patterns, item->d_name, num_ranks, num_initialize,
+      num_execute, num_finalize, num_execute_invoc_per_rank);
 
     if (status != 0)
     {
@@ -245,7 +252,7 @@ int parse_directory(const std::string& catalyst_data_dump_directory,
 // Opens the data dump directory and makes sure that the data
 // was output correctly. This includes things like making sure that
 // there was the correct number of files written out for each stage.
-int validate_data_dump(const std::string& catalyst_data_dump_directory, int num_ranks,
+static int validate_data_dump(const std::string& catalyst_data_dump_directory, int num_ranks,
   unsigned long& num_execute_invoc_per_rank)
 {
   // First check that all files in this directory were generated
@@ -278,7 +285,7 @@ int validate_data_dump(const std::string& catalyst_data_dump_directory, int num_
   // Check that none are 0
   if (!(num_initialize && num_execute && num_finalize))
   {
-    std::cerr << "ERROR: Missing node data for at least one stage." << std::endl;
+    std::cerr << "ERROR: Missing node data for at least one stage.\n";
     write_num_nodes_per_stage(std::cerr, num_initialize, num_execute, num_finalize);
     write_catalyst_data_dump_dir(std::cerr, catalyst_data_dump_directory);
     return 1;
@@ -286,13 +293,20 @@ int validate_data_dump(const std::string& catalyst_data_dump_directory, int num_
 
   // Check that they're called the correct number of times.
   // Initialize and finalize should be called once per rank
-  if (!(num_ranks == num_initialize && num_ranks == num_finalize))
+  if (num_ranks != num_initialize || num_ranks != num_finalize)
   {
-    std::cerr << "ERROR: Mismatch in the number of calls to initialize or finalize." << std::endl
-              << "Number of calls to initialize: " << num_initialize << std::endl
-              << "Number of calls to finalize: " << num_finalize << std::endl
-              << "Number of ranks: " << num_ranks << std::endl
-              << "These should all match." << std::endl;
+    std::cerr << "ERROR: Mismatch in the number of calls to initialize or finalize."
+              << "\n"
+                 "Number of calls to initialize: "
+              << num_initialize
+              << "\n"
+                 "Number of calls to finalize: "
+              << num_finalize
+              << "\n"
+                 "Number of ranks: "
+              << num_ranks
+              << "\n"
+                 "These should all match.\n";
     write_catalyst_data_dump_dir(std::cerr, catalyst_data_dump_directory);
     return 1;
   }
@@ -300,9 +314,13 @@ int validate_data_dump(const std::string& catalyst_data_dump_directory, int num_
   // Execute is different since there are timesteps.
   if (num_execute != num_ranks * num_execute_invoc_per_rank)
   {
-    std::cerr << "ERROR: Unexpected number of calls to execute." << std::endl
-              << "Expected: " << num_ranks * num_execute_invoc_per_rank << std::endl
-              << "Got: " << num_execute << std::endl;
+    std::cerr << "ERROR: Unexpected number of calls to execute."
+              << "\n"
+                 "Expected: "
+              << num_ranks * num_execute_invoc_per_rank
+              << "\n"
+                 "Got: "
+              << num_execute << '\n';
     write_catalyst_data_dump_dir(std::cerr, catalyst_data_dump_directory);
     return 1;
   }
@@ -313,12 +331,12 @@ int validate_data_dump(const std::string& catalyst_data_dump_directory, int num_
 // Makes sure that the catalyst_data_dump_directory string is formatted
 // correctly. This includes things like making sure that it isn't empty,
 // and that it ends with a slash.
-int validate_data_dump_str(std::string& catalyst_data_dump_directory)
+static int validate_data_dump_str(std::string& catalyst_data_dump_directory)
 {
-  size_t path_len = catalyst_data_dump_directory.size();
+  const size_t path_len = catalyst_data_dump_directory.size();
   if (!path_len)
   {
-    std::cerr << "ERROR: Empty data_dump_directory path detected." << std::endl;
+    std::cerr << "ERROR: Empty data_dump_directory path detected.\n";
     return 1;
   }
 
@@ -326,9 +344,9 @@ int validate_data_dump_str(std::string& catalyst_data_dump_directory)
 }
 
 // Format the data_dump_directory for consistency
-void clean_data_dump_str(std::string& catalyst_data_dump_directory)
+static void clean_data_dump_str(std::string& catalyst_data_dump_directory)
 {
-  size_t path_len = catalyst_data_dump_directory.size();
+  const size_t path_len = catalyst_data_dump_directory.size();
 
   if (catalyst_data_dump_directory[path_len - 1] != PATH_SEP)
   {
@@ -336,7 +354,7 @@ void clean_data_dump_str(std::string& catalyst_data_dump_directory)
   }
 }
 
-void exit_gracefully_if_needed(int /*rank*/, int status)
+static void exit_gracefully_if_needed(int /*rank*/, int status)
 {
 #ifdef CATALYST_USE_MPI
   MPI_Bcast(&status, 1, MPI_INT, 0, MPI_COMM_WORLD);
@@ -361,24 +379,26 @@ int main(int argc, char** argv)
   (void)argv;
 #endif
 
-  int num_ranks = 1;
-  int rank = 0;
   int status = 0;
   unsigned long num_execute_invoc_per_rank = 0;
   std::string catalyst_data_dump_directory;
 
 #ifdef CATALYST_USE_MPI
+  int num_ranks = 1;
+  int rank = 0;
   MPI_Comm_rank(MPI_COMM_WORLD, &rank);
   MPI_Comm_size(MPI_COMM_WORLD, &num_ranks);
 
   auto communicator = static_cast<std::uint64_t>(MPI_Comm_c2f(MPI_COMM_WORLD));
 #else
+  const int num_ranks = 1;
+  const int rank = 0;
   const std::uint64_t communicator = 0;
 #endif
 
   if (rank == 0 && argc != 2)
   {
-    std::cerr << "ERROR: Expected 1 argument, the data dump directory." << std::endl;
+    std::cerr << "ERROR: Expected 1 argument, the data dump directory.\n";
     status = 1;
   }
   exit_gracefully_if_needed(rank, status);
diff --git a/tests/abi_tests/test_catalyst_abi.cpp b/tests/abi_tests/test_catalyst_abi.cpp
index 3180bb690faf8f4e560a86f0e88bfcb5aa2112b6..370ada3be049a1b5978f1ae1314122cee073ca54 100644
--- a/tests/abi_tests/test_catalyst_abi.cpp
+++ b/tests/abi_tests/test_catalyst_abi.cpp
@@ -73,12 +73,12 @@ static int test_catalyst_abi()
   {
     using func_types = funcinfo<decltype(catalyst_initialize)>;
     abi_require(&catalyst_initialize, "catalyst_initialize must be defined");
-    static_assert(std::is_same<func_types::return_t, enum catalyst_status>::value,
+    static_assert(std::is_same_v<func_types::return_t, enum catalyst_status>,
       "Catalyst API functions must return catalyst_status");
-    abi_require(std::tuple_size<func_types::argument_t>::value == 1,
-      "catalyst_initialize must take one argument");
+    abi_require(
+      std::tuple_size_v<func_types::argument_t> == 1, "catalyst_initialize must take one argument");
     static_assert(
-      std::is_same<std::tuple_element<0, func_types::argument_t>::type, const conduit_node*>::value,
+      std::is_same_v<std::tuple_element_t<0, func_types::argument_t>, const conduit_node*>,
       "catalyst_initialize should take a const conduit_node*");
   }
 
@@ -86,12 +86,12 @@ static int test_catalyst_abi()
   {
     using func_types = funcinfo<decltype(catalyst_execute)>;
     abi_require(&catalyst_execute, "catalyst_execute must be defined");
-    static_assert(std::is_same<func_types::return_t, enum catalyst_status>::value,
+    static_assert(std::is_same_v<func_types::return_t, enum catalyst_status>,
       "Catalyst API functions must return catalyst_status");
-    abi_require(std::tuple_size<func_types::argument_t>::value == 1,
-      "catalyst_execute must take one argument");
+    abi_require(
+      std::tuple_size_v<func_types::argument_t> == 1, "catalyst_execute must take one argument");
     static_assert(
-      std::is_same<std::tuple_element<0, func_types::argument_t>::type, const conduit_node*>::value,
+      std::is_same_v<std::tuple_element_t<0, func_types::argument_t>, const conduit_node*>,
       "catalyst_execute should take a const conduit_node*");
   }
 
@@ -99,12 +99,12 @@ static int test_catalyst_abi()
   {
     using func_types = funcinfo<decltype(catalyst_finalize)>;
     abi_require(&catalyst_finalize, "catalyst_finalize must be defined");
-    static_assert(std::is_same<func_types::return_t, enum catalyst_status>::value,
+    static_assert(std::is_same_v<func_types::return_t, enum catalyst_status>,
       "Catalyst API functions must return catalyst_status");
-    abi_require(std::tuple_size<func_types::argument_t>::value == 1,
-      "catalyst_finalize must take one argument");
+    abi_require(
+      std::tuple_size_v<func_types::argument_t> == 1, "catalyst_finalize must take one argument");
     static_assert(
-      std::is_same<std::tuple_element<0, func_types::argument_t>::type, const conduit_node*>::value,
+      std::is_same_v<std::tuple_element_t<0, func_types::argument_t>, const conduit_node*>,
       "catalyst_finalize should take a const conduit_node*");
   }
 
@@ -112,12 +112,11 @@ static int test_catalyst_abi()
   {
     using func_types = funcinfo<decltype(catalyst_about)>;
     abi_require(&catalyst_about, "catalyst_about must be defined");
-    static_assert(std::is_same<func_types::return_t, enum catalyst_status>::value,
+    static_assert(std::is_same_v<func_types::return_t, enum catalyst_status>,
       "Catalyst API functions must return catalyst_status");
     abi_require(
-      std::tuple_size<func_types::argument_t>::value == 1, "catalyst_about must take one argument");
-    static_assert(
-      std::is_same<std::tuple_element<0, func_types::argument_t>::type, conduit_node*>::value,
+      std::tuple_size_v<func_types::argument_t> == 1, "catalyst_about must take one argument");
+    static_assert(std::is_same_v<std::tuple_element_t<0, func_types::argument_t>, conduit_node*>,
       "catalyst_about should take a conduit_node*");
   }
 
@@ -125,12 +124,11 @@ static int test_catalyst_abi()
   {
     using func_types = funcinfo<decltype(catalyst_results)>;
     abi_require(&catalyst_results, "catalyst_results must be defined");
-    static_assert(std::is_same<func_types::return_t, enum catalyst_status>::value,
+    static_assert(std::is_same_v<func_types::return_t, enum catalyst_status>,
       "Catalyst API functions must return catalyst_status");
-    abi_require(std::tuple_size<func_types::argument_t>::value == 1,
-      "catalyst_results must take one argument");
-    static_assert(
-      std::is_same<std::tuple_element<0, func_types::argument_t>::type, conduit_node*>::value,
+    abi_require(
+      std::tuple_size_v<func_types::argument_t> == 1, "catalyst_results must take one argument");
+    static_assert(std::is_same_v<std::tuple_element_t<0, func_types::argument_t>, conduit_node*>,
       "catalyst_results should take a conduit_node*");
   }
 
@@ -211,7 +209,7 @@ static int test_catalyst_impl()
   // version
   {
     static_assert(
-      std::is_same<decltype(catalyst_impl::version), int>::value, "the version must be an int");
+      std::is_same_v<decltype(catalyst_impl::version), int>, "the version must be an int");
     abi_require(offsetof(catalyst_impl, version) == offsets[0],
       "the offset of the catalyst_impl::version is not expected");
   }
@@ -219,7 +217,7 @@ static int test_catalyst_impl()
   // initialize
   {
     static_assert(
-      std::is_same<decltype(catalyst_impl::initialize), decltype(&catalyst_initialize)>::value,
+      std::is_same_v<decltype(catalyst_impl::initialize), decltype(&catalyst_initialize)>,
       "the initialize member must be a compatible function pointer");
     abi_require(offsetof(catalyst_impl, initialize) == offsets[1],
       "the offset of the catalyst_impl::initialize is not expected");
@@ -227,8 +225,7 @@ static int test_catalyst_impl()
 
   // execute
   {
-    static_assert(
-      std::is_same<decltype(catalyst_impl::execute), decltype(&catalyst_execute)>::value,
+    static_assert(std::is_same_v<decltype(catalyst_impl::execute), decltype(&catalyst_execute)>,
       "the execute member must be a compatible function pointer");
     abi_require(offsetof(catalyst_impl, execute) == offsets[2],
       "the offset of the catalyst_impl::execute is not expected");
@@ -236,8 +233,7 @@ static int test_catalyst_impl()
 
   // finalize
   {
-    static_assert(
-      std::is_same<decltype(catalyst_impl::finalize), decltype(&catalyst_finalize)>::value,
+    static_assert(std::is_same_v<decltype(catalyst_impl::finalize), decltype(&catalyst_finalize)>,
       "the finalize member must be a compatible function pointer");
     abi_require(offsetof(catalyst_impl, finalize) == offsets[3],
       "the offset of the catalyst_impl::finalize is not expected");
@@ -245,7 +241,7 @@ static int test_catalyst_impl()
 
   // about
   {
-    static_assert(std::is_same<decltype(catalyst_impl::about), decltype(&catalyst_about)>::value,
+    static_assert(std::is_same_v<decltype(catalyst_impl::about), decltype(&catalyst_about)>,
       "the about member must be a compatible function pointer");
     abi_require(offsetof(catalyst_impl, about) == offsets[4],
       "the offset of the catalyst_impl::about is not expected");
@@ -253,8 +249,7 @@ static int test_catalyst_impl()
 
   // results
   {
-    static_assert(
-      std::is_same<decltype(catalyst_impl::results), decltype(&catalyst_results)>::value,
+    static_assert(std::is_same_v<decltype(catalyst_impl::results), decltype(&catalyst_results)>,
       "the results member must be a compatible function pointer");
     abi_require(offsetof(catalyst_impl, results) == offsets[5],
       "the offset of the catalyst_impl::results is not expected");
@@ -262,7 +257,7 @@ static int test_catalyst_impl()
 
   // conduit_is_external
   {
-    static_assert(std::is_same<decltype(catalyst_impl::conduit_is_external), conduit_uint64>::value,
+    static_assert(std::is_same_v<decltype(catalyst_impl::conduit_is_external), conduit_uint64>,
       "the conduit_is_external member must be a conduit_uint64");
     abi_require(offsetof(catalyst_impl, conduit_is_external) == offsets[6],
       "the offset of the catalyst_impl::conduit_is_external is not expected");
@@ -273,40 +268,38 @@ static int test_catalyst_impl()
 
 static int test_catalyst_stub()
 {
-  int ret = EXIT_SUCCESS;
+  const int ret = EXIT_SUCCESS;
 
   // Only add assertions to this list; removal or modification of any
   // checks constitutes an ABI break.
 
   // initialize
   {
-    static_assert(
-      std::is_same<decltype(catalyst_stub_initialize), decltype(catalyst_initialize)>::value,
+    static_assert(std::is_same_v<decltype(catalyst_stub_initialize), decltype(catalyst_initialize)>,
       "the stub initialize function must be a compatible function");
   }
 
   // execute
   {
-    static_assert(
-      std::is_same<decltype(catalyst_stub_finalize), decltype(catalyst_finalize)>::value,
+    static_assert(std::is_same_v<decltype(catalyst_stub_finalize), decltype(catalyst_finalize)>,
       "the stub finalize function must be a compatible function");
   }
 
   // finalize
   {
-    static_assert(std::is_same<decltype(catalyst_stub_execute), decltype(catalyst_execute)>::value,
+    static_assert(std::is_same_v<decltype(catalyst_stub_execute), decltype(catalyst_execute)>,
       "the stub execute function must be a compatible function");
   }
 
   // about
   {
-    static_assert(std::is_same<decltype(catalyst_stub_about), decltype(catalyst_about)>::value,
+    static_assert(std::is_same_v<decltype(catalyst_stub_about), decltype(catalyst_about)>,
       "the stub about function must be a compatible function");
   }
 
   // results
   {
-    static_assert(std::is_same<decltype(catalyst_stub_results), decltype(catalyst_results)>::value,
+    static_assert(std::is_same_v<decltype(catalyst_stub_results), decltype(catalyst_results)>,
       "the stub results function must be a compatible function");
   }
 
@@ -324,14 +317,13 @@ static int test_catalyst_python_tools_abi()
   {
     using func_types = funcinfo<decltype(PyCatalystConduit_Node_Wrap)>;
     abi_require(&PyCatalystConduit_Node_Wrap, "PyCatalystConduit_Node_Wrap must be defined");
-    static_assert(std::is_same<func_types::return_t, catalyst_py_object*>::value,
+    static_assert(std::is_same_v<func_types::return_t, catalyst_py_object*>,
       "PyCatalystConduit_Node_Wrap must return a catalyst_py_object* instance");
-    abi_require(std::tuple_size<func_types::argument_t>::value == 2,
+    abi_require(std::tuple_size_v<func_types::argument_t> == 2,
       "PyCatalystConduit_Node_Wrap must take two arguments");
-    static_assert(
-      std::is_same<std::tuple_element<0, func_types::argument_t>::type, conduit_node*>::value,
+    static_assert(std::is_same_v<std::tuple_element_t<0, func_types::argument_t>, conduit_node*>,
       "PyCatalystConduit_Node_Wrap should take as a first argument a conduit_node*");
-    static_assert(std::is_same<std::tuple_element<1, func_types::argument_t>::type, int>::value,
+    static_assert(std::is_same_v<std::tuple_element_t<1, func_types::argument_t>, int>,
       "PyCatalystConduit_Node_Wrap should take as a second argument an int");
   }
 
diff --git a/tests/catalyst_tests/catalyst_conduit/test_catalyst_conduit.cpp b/tests/catalyst_tests/catalyst_conduit/test_catalyst_conduit.cpp
index 01a166b0e189a637c84cb60c4536ac448da26e12..467e4509ebc3b0969fea35aecfdcf89ca7d397c0 100644
--- a/tests/catalyst_tests/catalyst_conduit/test_catalyst_conduit.cpp
+++ b/tests/catalyst_tests/catalyst_conduit/test_catalyst_conduit.cpp
@@ -8,7 +8,7 @@
 #include <cstdio>
 #include <cstdlib>
 
-int test_cpp_node_wrapping_data()
+static int test_cpp_node_wrapping_data()
 {
   int ret = EXIT_SUCCESS;
 
@@ -30,7 +30,7 @@ int test_cpp_node_wrapping_data()
     }
     else
     {
-      int value = child_node.as_int();
+      const int value = child_node.as_int();
       if (value != 2)
       {
         ret = EXIT_FAILURE;
@@ -41,7 +41,7 @@ int test_cpp_node_wrapping_data()
   return ret;
 }
 
-int test_cpp_node_wrapping_on_child_node()
+static int test_cpp_node_wrapping_on_child_node()
 {
   int ret = EXIT_SUCCESS;
 
@@ -65,7 +65,7 @@ int test_cpp_node_wrapping_on_child_node()
     }
     else
     {
-      int value = sub_node.as_int();
+      const int value = sub_node.as_int();
       if (value != 5)
       {
         ret = EXIT_FAILURE;
@@ -76,9 +76,9 @@ int test_cpp_node_wrapping_on_child_node()
   return ret;
 }
 
-int test_cpp_node_wrapping_destructor()
+static int test_cpp_node_wrapping_destructor()
 {
-  int ret = EXIT_SUCCESS;
+  const int ret = EXIT_SUCCESS;
 
   auto* first_node = new conduit_cpp::Node();
   conduit_node* first_node_c_node = conduit_cpp::c_node(first_node);
@@ -97,12 +97,13 @@ int test_cpp_node_wrapping_destructor()
   return ret;
 }
 
-int test_cpp_node_copy()
+static int test_cpp_node_copy()
 {
-  int ret = EXIT_SUCCESS;
+  const int ret = EXIT_SUCCESS;
 
-  conduit_cpp::Node n;
-  conduit_cpp::Node clone = n;
+  const conduit_cpp::Node n;
+  // NOLINTNEXTLINE(performance-unnecessary-copy-initialization): test copy ctor
+  const conduit_cpp::Node clone = n;
   (void)clone;
 
   return ret;
diff --git a/tests/catalyst_tests/impls/double.cpp b/tests/catalyst_tests/impls/double.cpp
index a88e1b0023b21cdd22e62477ce710b2153f83fb0..30babec5f499d8d903d200c400568fe1d924e85b 100644
--- a/tests/catalyst_tests/impls/double.cpp
+++ b/tests/catalyst_tests/impls/double.cpp
@@ -58,7 +58,7 @@ enum catalyst_status catalyst_finalize_double(const conduit_node* params)
 //-----------------------------------------------------------------------------
 enum catalyst_status catalyst_about_double(conduit_node* params)
 {
-  enum catalyst_status err = catalyst_stub_about(params);
+  const enum catalyst_status err = catalyst_stub_about(params);
 
   conduit_node_set_path_char8_str(params, "catalyst/implementation", "test");
   conduit_node_set_path_double(params, "data", data);
@@ -69,7 +69,7 @@ enum catalyst_status catalyst_about_double(conduit_node* params)
 //-----------------------------------------------------------------------------
 enum catalyst_status catalyst_results_double(conduit_node* params)
 {
-  enum catalyst_status err = catalyst_stub_results(params);
+  const enum catalyst_status err = catalyst_stub_results(params);
 
   conduit_node_set_path_char8_str(params, "catalyst/implementation", "test");
   conduit_node_set_path_double(params, "data", data);
diff --git a/tests/conduit_tests/t_conduit_node.cpp b/tests/conduit_tests/t_conduit_node.cpp
index 70cc92988e43dde9cdaaee6590e12bb1fdc19cbf..2b112823cdc9bcd309766441cd046ffc6778b853 100644
--- a/tests/conduit_tests/t_conduit_node.cpp
+++ b/tests/conduit_tests/t_conduit_node.cpp
@@ -548,10 +548,10 @@ TEST(conduit_node, check_invalid_index_error_with_const)
 {
   const Node n;
 
-  EXPECT_THROW(n.child(0), conduit_cpp::Error);
-  EXPECT_THROW(n[0], conduit_cpp::Error);
-  EXPECT_THROW(n.child(1), conduit_cpp::Error);
-  EXPECT_THROW(n[1], conduit_cpp::Error);
+  EXPECT_THROW((void)n.child(0), conduit_cpp::Error);
+  EXPECT_THROW((void)n[0], conduit_cpp::Error);
+  EXPECT_THROW((void)n.child(1), conduit_cpp::Error);
+  EXPECT_THROW((void)n[1], conduit_cpp::Error);
 }
 
 //-----------------------------------------------------------------------------
@@ -1053,49 +1053,49 @@ TEST(conduit_node, check_as_native_and_native_ptr_throw)
 {
   Node n_int;
   Node n_float;
-  n_int = (int)3;
-  n_float = (float)3.14;
+  n_int = 3;
+  n_float = 3.14F;
 
   // Check non-pointer methods
-  EXPECT_THROW(n_int.as_char(), conduit_cpp::Error);
-  EXPECT_THROW(n_int.as_short(), conduit_cpp::Error);
-  EXPECT_THROW(n_float.as_int(), conduit_cpp::Error);
-  EXPECT_THROW(n_int.as_long(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int.as_char(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int.as_short(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_float.as_int(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int.as_long(), conduit_cpp::Error);
 
-  EXPECT_THROW(n_int.as_signed_char(), conduit_cpp::Error);
-  EXPECT_THROW(n_int.as_signed_short(), conduit_cpp::Error);
-  EXPECT_THROW(n_float.as_signed_int(), conduit_cpp::Error);
-  EXPECT_THROW(n_int.as_signed_long(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int.as_signed_char(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int.as_signed_short(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_float.as_signed_int(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int.as_signed_long(), conduit_cpp::Error);
 
-  EXPECT_THROW(n_int.as_unsigned_char(), conduit_cpp::Error);
-  EXPECT_THROW(n_int.as_unsigned_short(), conduit_cpp::Error);
-  EXPECT_THROW(n_int.as_unsigned_int(), conduit_cpp::Error);
-  EXPECT_THROW(n_int.as_unsigned_long(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int.as_unsigned_char(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int.as_unsigned_short(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int.as_unsigned_int(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int.as_unsigned_long(), conduit_cpp::Error);
 
-  EXPECT_THROW(n_int.as_float(), conduit_cpp::Error);
-  EXPECT_THROW(n_int.as_double(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int.as_float(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int.as_double(), conduit_cpp::Error);
 
-  EXPECT_THROW(n_int.as_char8_str(), conduit_cpp::Error);
-  EXPECT_THROW(n_int.as_string(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int.as_char8_str(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int.as_string(), conduit_cpp::Error);
 
   // Check pointer methods
-  EXPECT_THROW(n_int.as_char_ptr(), conduit_cpp::Error);
-  EXPECT_THROW(n_int.as_short_ptr(), conduit_cpp::Error);
-  EXPECT_THROW(n_float.as_int_ptr(), conduit_cpp::Error);
-  EXPECT_THROW(n_int.as_long_ptr(), conduit_cpp::Error);
-
-  EXPECT_THROW(n_int.as_signed_char_ptr(), conduit_cpp::Error);
-  EXPECT_THROW(n_int.as_signed_short_ptr(), conduit_cpp::Error);
-  EXPECT_THROW(n_float.as_signed_int_ptr(), conduit_cpp::Error);
-  EXPECT_THROW(n_int.as_signed_long_ptr(), conduit_cpp::Error);
-
-  EXPECT_THROW(n_int.as_unsigned_char_ptr(), conduit_cpp::Error);
-  EXPECT_THROW(n_int.as_unsigned_short_ptr(), conduit_cpp::Error);
-  EXPECT_THROW(n_int.as_unsigned_int_ptr(), conduit_cpp::Error);
-  EXPECT_THROW(n_int.as_unsigned_long_ptr(), conduit_cpp::Error);
-
-  EXPECT_THROW(n_int.as_float_ptr(), conduit_cpp::Error);
-  EXPECT_THROW(n_int.as_double_ptr(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int.as_char_ptr(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int.as_short_ptr(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_float.as_int_ptr(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int.as_long_ptr(), conduit_cpp::Error);
+
+  EXPECT_THROW((void)n_int.as_signed_char_ptr(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int.as_signed_short_ptr(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_float.as_signed_int_ptr(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int.as_signed_long_ptr(), conduit_cpp::Error);
+
+  EXPECT_THROW((void)n_int.as_unsigned_char_ptr(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int.as_unsigned_short_ptr(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int.as_unsigned_int_ptr(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int.as_unsigned_long_ptr(), conduit_cpp::Error);
+
+  EXPECT_THROW((void)n_int.as_float_ptr(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int.as_double_ptr(), conduit_cpp::Error);
 }
 
 // -----------------------------------------------------------------------------
@@ -1103,30 +1103,30 @@ TEST(conduit_node, check_as_native_ptr_const_throw)
 {
   Node n_int;
   Node n_float;
-  n_int = (int)3;
-  n_float = (float)3.14;
+  n_int = 3;
+  n_float = 3.14F;
 
   // Construct const equivalents
   const Node n_int_const(n_int);
   const Node n_float_const(n_float);
 
-  EXPECT_THROW(n_int_const.as_char_ptr(), conduit_cpp::Error);
-  EXPECT_THROW(n_int_const.as_short_ptr(), conduit_cpp::Error);
-  EXPECT_THROW(n_float_const.as_int_ptr(), conduit_cpp::Error);
-  EXPECT_THROW(n_int_const.as_long_ptr(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int_const.as_char_ptr(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int_const.as_short_ptr(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_float_const.as_int_ptr(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int_const.as_long_ptr(), conduit_cpp::Error);
 
-  EXPECT_THROW(n_int_const.as_signed_char_ptr(), conduit_cpp::Error);
-  EXPECT_THROW(n_int_const.as_signed_short_ptr(), conduit_cpp::Error);
-  EXPECT_THROW(n_float_const.as_signed_int_ptr(), conduit_cpp::Error);
-  EXPECT_THROW(n_int_const.as_signed_long_ptr(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int_const.as_signed_char_ptr(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int_const.as_signed_short_ptr(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_float_const.as_signed_int_ptr(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int_const.as_signed_long_ptr(), conduit_cpp::Error);
 
-  EXPECT_THROW(n_int_const.as_unsigned_char_ptr(), conduit_cpp::Error);
-  EXPECT_THROW(n_int_const.as_unsigned_short_ptr(), conduit_cpp::Error);
-  EXPECT_THROW(n_int_const.as_unsigned_int_ptr(), conduit_cpp::Error);
-  EXPECT_THROW(n_int_const.as_unsigned_long_ptr(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int_const.as_unsigned_char_ptr(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int_const.as_unsigned_short_ptr(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int_const.as_unsigned_int_ptr(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int_const.as_unsigned_long_ptr(), conduit_cpp::Error);
 
-  EXPECT_THROW(n_int_const.as_float_ptr(), conduit_cpp::Error);
-  EXPECT_THROW(n_int_const.as_double_ptr(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int_const.as_float_ptr(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int_const.as_double_ptr(), conduit_cpp::Error);
 }
 
 // -----------------------------------------------------------------------------
@@ -1138,32 +1138,32 @@ TEST(conduit_node, check_as_bitwidth_and_as_bitwidth_ptr_throw)
   n_float32 = (float32)3.14;
 
   // Check non-pointer methods
-  EXPECT_THROW(n_int32.as_int8(), conduit_cpp::Error);
-  EXPECT_THROW(n_int32.as_int16(), conduit_cpp::Error);
-  EXPECT_THROW(n_float32.as_int32(), conduit_cpp::Error);
-  EXPECT_THROW(n_int32.as_int64(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int32.as_int8(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int32.as_int16(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_float32.as_int32(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int32.as_int64(), conduit_cpp::Error);
 
-  EXPECT_THROW(n_int32.as_uint8(), conduit_cpp::Error);
-  EXPECT_THROW(n_int32.as_uint16(), conduit_cpp::Error);
-  EXPECT_THROW(n_int32.as_uint32(), conduit_cpp::Error);
-  EXPECT_THROW(n_int32.as_uint64(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int32.as_uint8(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int32.as_uint16(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int32.as_uint32(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int32.as_uint64(), conduit_cpp::Error);
 
-  EXPECT_THROW(n_int32.as_float32(), conduit_cpp::Error);
-  EXPECT_THROW(n_int32.as_float64(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int32.as_float32(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int32.as_float64(), conduit_cpp::Error);
 
   // Check pointer methods
-  EXPECT_THROW(n_int32.as_int8_ptr(), conduit_cpp::Error);
-  EXPECT_THROW(n_int32.as_int16_ptr(), conduit_cpp::Error);
-  EXPECT_THROW(n_float32.as_int32_ptr(), conduit_cpp::Error);
-  EXPECT_THROW(n_int32.as_int64_ptr(), conduit_cpp::Error);
-
-  EXPECT_THROW(n_int32.as_uint8_ptr(), conduit_cpp::Error);
-  EXPECT_THROW(n_int32.as_uint16_ptr(), conduit_cpp::Error);
-  EXPECT_THROW(n_int32.as_uint32_ptr(), conduit_cpp::Error);
-  EXPECT_THROW(n_int32.as_uint64_ptr(), conduit_cpp::Error);
-
-  EXPECT_THROW(n_int32.as_float32_ptr(), conduit_cpp::Error);
-  EXPECT_THROW(n_int32.as_float64_ptr(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int32.as_int8_ptr(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int32.as_int16_ptr(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_float32.as_int32_ptr(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int32.as_int64_ptr(), conduit_cpp::Error);
+
+  EXPECT_THROW((void)n_int32.as_uint8_ptr(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int32.as_uint16_ptr(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int32.as_uint32_ptr(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int32.as_uint64_ptr(), conduit_cpp::Error);
+
+  EXPECT_THROW((void)n_int32.as_float32_ptr(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int32.as_float64_ptr(), conduit_cpp::Error);
 }
 
 //-----------------------------------------------------------------------------
@@ -1178,18 +1178,18 @@ TEST(conduit_node, check_as_bitwidth_ptr_const_throw)
   const Node n_int32_const(n_int32);
   const Node n_float32_const(n_float32);
 
-  EXPECT_THROW(n_int32_const.as_int8_ptr(), conduit_cpp::Error);
-  EXPECT_THROW(n_int32_const.as_int16_ptr(), conduit_cpp::Error);
-  EXPECT_THROW(n_float32_const.as_int32_ptr(), conduit_cpp::Error);
-  EXPECT_THROW(n_int32_const.as_int64_ptr(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int32_const.as_int8_ptr(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int32_const.as_int16_ptr(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_float32_const.as_int32_ptr(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int32_const.as_int64_ptr(), conduit_cpp::Error);
 
-  EXPECT_THROW(n_int32_const.as_uint8_ptr(), conduit_cpp::Error);
-  EXPECT_THROW(n_int32_const.as_uint16_ptr(), conduit_cpp::Error);
-  EXPECT_THROW(n_int32_const.as_uint32_ptr(), conduit_cpp::Error);
-  EXPECT_THROW(n_int32_const.as_uint64_ptr(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int32_const.as_uint8_ptr(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int32_const.as_uint16_ptr(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int32_const.as_uint32_ptr(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int32_const.as_uint64_ptr(), conduit_cpp::Error);
 
-  EXPECT_THROW(n_int32_const.as_float32_ptr(), conduit_cpp::Error);
-  EXPECT_THROW(n_int32_const.as_float64_ptr(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int32_const.as_float32_ptr(), conduit_cpp::Error);
+  EXPECT_THROW((void)n_int32_const.as_float64_ptr(), conduit_cpp::Error);
 }
 
 //-----------------------------------------------------------------------------
diff --git a/thirdparty/.clang-tidy b/thirdparty/.clang-tidy
index bd6d14452a4f6171350b3f5b3141929f7fadc5a4..19ee2cef2163b972e190458b79070da2b899952a 100644
--- a/thirdparty/.clang-tidy
+++ b/thirdparty/.clang-tidy
@@ -1,12 +1,18 @@
 ---
 Checks: "-*,\
 bugprone-*,\
+-bugprone-assignment-in-if-condition,\
 -bugprone-branch-clone,\
 -bugprone-easily-swappable-parameters,\
+-bugprone-empty-catch,\
 -bugprone-implicit-widening-of-multiplication-result,\
+-bugprone-inc-dec-in-conditions,\
 -bugprone-macro-parentheses,\
 -bugprone-narrowing-conversions,\
+-bugprone-nondeterministic-pointer-iteration-order,\
 -bugprone-reserved-identifier,\
 -bugprone-signed-char-misuse,\
+-bugprone-switch-missing-default-case,\
+-bugprone-unused-local-non-trivial-variable,\
 "
 ...