diff --git a/.github/workflows/cmake.yml b/.github/workflows/cmake.yml
index 93061cfef..334424e55 100644
--- a/.github/workflows/cmake.yml
+++ b/.github/workflows/cmake.yml
@@ -2,9 +2,8 @@ name: CMake
 
 on:
   push:
-    branches: [ master ]
   pull_request:
-    branches: [ master ]
+
 env:
   # Customize the CMake build type here (Release, Debug, RelWithDebInfo, etc.)
   BUILD_TYPE: Release
@@ -58,5 +57,5 @@ jobs:
       working-directory: ${{github.workspace}}/build/test
       # Execute tests defined by the CMake configuration.
       # See https://cmake.org/cmake/help/latest/manual/ctest.1.html for more detail
-      run: ctest
+      run: ctest --output-on-failure
 
diff --git a/.gitignore b/.gitignore
index f982ca422..8d678b029 100644
--- a/.gitignore
+++ b/.gitignore
@@ -39,3 +39,5 @@ packaging/
 .vscode
 .code-workspace
 CXXGraph.code-workspace
+# ignore Visual Studio files
+/.vs
diff --git a/include/CXXGraph/Edge/DirectedEdge.h b/include/CXXGraph/Edge/DirectedEdge.h
index 76c8e5930..79e19b5b0 100755
--- a/include/CXXGraph/Edge/DirectedEdge.h
+++ b/include/CXXGraph/Edge/DirectedEdge.h
@@ -17,11 +17,11 @@
 /***	 License: MPL v2.0 ***/
 /***********************************************************/
 
-#ifndef __CXXGRAPH_DIRECTEDEDGE_H__
-#define __CXXGRAPH_DIRECTEDEDGE_H__
+#ifndef CXXGRAPH_DIRECTEDEDGE_H
+#define CXXGRAPH_DIRECTEDEDGE_H
 
 #pragma once
 
 #include "DirectedEdge_impl.hpp"
 
-#endif  // __CXXGRAPH_DIRECTEDEDGE_H__
+#endif  // CXXGRAPH_DIRECTEDEDGE_H
diff --git a/include/CXXGraph/Edge/DirectedEdge_decl.h b/include/CXXGraph/Edge/DirectedEdge_decl.h
index b4611c3af..f33eabd1b 100644
--- a/include/CXXGraph/Edge/DirectedEdge_decl.h
+++ b/include/CXXGraph/Edge/DirectedEdge_decl.h
@@ -17,8 +17,8 @@
 /***	 License: MPL v2.0 ***/
 /***********************************************************/
 
-#ifndef __CXXGRAPH_DIRECTEDEDGE_DECL_H__
-#define __CXXGRAPH_DIRECTEDEDGE_DECL_H__
+#ifndef CXXGRAPH_DIRECTEDEDGE_DECL_H_
+#define CXXGRAPH_DIRECTEDEDGE_DECL_H_
 
 #pragma once
 
@@ -42,19 +42,21 @@ std::ostream &operator<<(std::ostream &o, const DirectedEdge<T> &edge);
 template <typename T>
 class DirectedEdge : public Edge<T> {
  public:
-  DirectedEdge(const CXXGraph::id_t id, const Node<T> &node1,
+  constexpr DirectedEdge(const CXXGraph::id_t id, const Node<T> &node1,
                const Node<T> &node2);
-  DirectedEdge(const CXXGraph::id_t id, shared<const Node<T>> node1,
+  constexpr DirectedEdge(const CXXGraph::id_t id, shared<const Node<T>> node1,
                shared<const Node<T>> node2);
-  DirectedEdge(const CXXGraph::id_t id,
+  constexpr DirectedEdge(
+      const CXXGraph::id_t id,
                const std::pair<const Node<T> *, const Node<T> *> &nodepair);
-  DirectedEdge(
+  constexpr DirectedEdge(
       const CXXGraph::id_t id,
       const std::pair<shared<const Node<T>>, shared<const Node<T>>> &nodepair);
-  DirectedEdge(const Edge<T> &edge);
+  constexpr DirectedEdge(const Edge<T> &edge);
   virtual ~DirectedEdge() = default;
-  const Node<T> &getFrom() const;
-  const Node<T> &getTo() const;
+  constexpr const Node<T> &getFrom() const;
+  constexpr const Node<T> &getTo() const;
+  // 
   const std::optional<bool> isDirected() const override;
   const std::optional<bool> isWeighted() const override;
   // operator
@@ -67,4 +69,4 @@ class DirectedEdge : public Edge<T> {
 };
 }  // namespace CXXGraph
 
-#endif  // __CXXGRAPH_DIRECTEDEDGE_H__
+#endif  // CXXGRAPH_DIRECTEDEDGE_H_
diff --git a/include/CXXGraph/Edge/DirectedEdge_impl.hpp b/include/CXXGraph/Edge/DirectedEdge_impl.hpp
index 9faa1a346..9bbf50e69 100644
--- a/include/CXXGraph/Edge/DirectedEdge_impl.hpp
+++ b/include/CXXGraph/Edge/DirectedEdge_impl.hpp
@@ -26,44 +26,42 @@
 
 namespace CXXGraph {
 
-using std::make_shared;
-using std::make_unique;
-
 template <typename T>
-DirectedEdge<T>::DirectedEdge(const CXXGraph::id_t id, const Node<T> &node1,
+constexpr DirectedEdge<T>::DirectedEdge(const CXXGraph::id_t id,
+                                       const Node<T> &node1,
                               const Node<T> &node2)
     : Edge<T>(id, node1, node2) {}
 
 template <typename T>
-DirectedEdge<T>::DirectedEdge(const CXXGraph::id_t id,
+constexpr DirectedEdge<T>::DirectedEdge(const CXXGraph::id_t id,
                               shared<const Node<T>> node1,
                               shared<const Node<T>> node2)
     : Edge<T>(id, node1, node2) {}
 
 template <typename T>
-DirectedEdge<T>::DirectedEdge(
+constexpr DirectedEdge<T>::DirectedEdge(
     const CXXGraph::id_t id,
     const std::pair<const Node<T> *, const Node<T> *> &nodepair)
     : Edge<T>(id, nodepair) {}
 
 template <typename T>
-DirectedEdge<T>::DirectedEdge(
+constexpr DirectedEdge<T>::DirectedEdge(
     const CXXGraph::id_t id,
     const std::pair<shared<const Node<T>>, shared<const Node<T>>> &nodepair)
     : Edge<T>(id, nodepair) {}
 
 template <typename T>
-DirectedEdge<T>::DirectedEdge(const Edge<T> &edge)
+constexpr DirectedEdge<T>::DirectedEdge(const Edge<T> &edge)
     : DirectedEdge(edge.getId(), *(edge.getNodePair().first),
                    *(edge.getNodePair().second)) {}
 
 template <typename T>
-const Node<T> &DirectedEdge<T>::getFrom() const {
+constexpr const Node<T> &DirectedEdge<T>::getFrom() const {
   return *(Edge<T>::getNodePair().first);
 }
 
 template <typename T>
-const Node<T> &DirectedEdge<T>::getTo() const {
+constexpr const Node<T> &DirectedEdge<T>::getTo() const {
   return *(Edge<T>::getNodePair().second);
 }
 
diff --git a/include/CXXGraph/Edge/DirectedWeightedEdge_decl.h b/include/CXXGraph/Edge/DirectedWeightedEdge_decl.h
index e456c8ab4..ef3963f3e 100644
--- a/include/CXXGraph/Edge/DirectedWeightedEdge_decl.h
+++ b/include/CXXGraph/Edge/DirectedWeightedEdge_decl.h
@@ -31,7 +31,7 @@ using unique = std::unique_ptr<T>;
 template <typename T>
 using shared = std::shared_ptr<T>;
 
-// Foward Declaration
+// Forward Declaration
 template <typename T>
 class UndirectedWeightedEdge;
 
@@ -45,23 +45,25 @@ std::ostream &operator<<(std::ostream &o, const DirectedWeightedEdge<T> &edge);
 template <typename T>
 class DirectedWeightedEdge : public DirectedEdge<T>, public Weighted {
  public:
-  DirectedWeightedEdge(const CXXGraph::id_t id, const Node<T> &node1,
+  constexpr DirectedWeightedEdge(const CXXGraph::id_t id, const Node<T> &node1,
                        const Node<T> &node2, const double weight);
-  DirectedWeightedEdge(const CXXGraph::id_t id, shared<const Node<T>> node1,
+  constexpr DirectedWeightedEdge(const CXXGraph::id_t id,
+                                 shared<const Node<T>> node1,
                        shared<const Node<T>> node2, const double weight);
-  DirectedWeightedEdge(
+  constexpr DirectedWeightedEdge(
       const CXXGraph::id_t id,
       const std::pair<const Node<T> *, const Node<T> *> &nodepair,
       const double weight);
-  DirectedWeightedEdge(
+  constexpr DirectedWeightedEdge(
       const CXXGraph::id_t id,
       const std::pair<shared<const Node<T>>, shared<const Node<T>>> &nodepair,
       const double weight);
-  DirectedWeightedEdge(const DirectedEdge<T> &edge, const double weight);
-  DirectedWeightedEdge(const Edge<T> &edge, const double weight);
-  DirectedWeightedEdge(const DirectedEdge<T> &edge);
-  DirectedWeightedEdge(const Edge<T> &edge);
-  DirectedWeightedEdge(const UndirectedWeightedEdge<T> &edge);
+  constexpr DirectedWeightedEdge(const DirectedEdge<T> &edge,
+                                 const double weight);
+  constexpr DirectedWeightedEdge(const Edge<T> &edge, const double weight);
+  constexpr DirectedWeightedEdge(const DirectedEdge<T> &edge);
+  constexpr DirectedWeightedEdge(const Edge<T> &edge);
+  constexpr DirectedWeightedEdge(const UndirectedWeightedEdge<T> &edge);
   virtual ~DirectedWeightedEdge() = default;
   const std::optional<bool> isWeighted() const override;
   // operator
diff --git a/include/CXXGraph/Edge/DirectedWeightedEdge_impl.hpp b/include/CXXGraph/Edge/DirectedWeightedEdge_impl.hpp
index 8bf19f073..3ba0aa105 100644
--- a/include/CXXGraph/Edge/DirectedWeightedEdge_impl.hpp
+++ b/include/CXXGraph/Edge/DirectedWeightedEdge_impl.hpp
@@ -26,57 +26,57 @@
 
 namespace CXXGraph {
 
-using std::make_shared;
-using std::make_unique;
-
 template <typename T>
-DirectedWeightedEdge<T>::DirectedWeightedEdge(const CXXGraph::id_t id,
+constexpr DirectedWeightedEdge<T>::DirectedWeightedEdge(const CXXGraph::id_t id,
                                               const Node<T> &node1,
                                               const Node<T> &node2,
                                               const double weight)
     : DirectedEdge<T>(id, node1, node2), Weighted(weight) {}
 
 template <typename T>
-DirectedWeightedEdge<T>::DirectedWeightedEdge(const CXXGraph::id_t id,
+constexpr DirectedWeightedEdge<T>::DirectedWeightedEdge(
+    const CXXGraph::id_t id,
                                               shared<const Node<T>> node1,
                                               shared<const Node<T>> node2,
                                               const double weight)
     : DirectedEdge<T>(id, node1, node2), Weighted(weight) {}
 
 template <typename T>
-DirectedWeightedEdge<T>::DirectedWeightedEdge(
+constexpr DirectedWeightedEdge<T>::DirectedWeightedEdge(
     const CXXGraph::id_t id,
     const std::pair<const Node<T> *, const Node<T> *> &nodepair,
     const double weight)
     : DirectedEdge<T>(id, nodepair), Weighted(weight) {}
 
 template <typename T>
-DirectedWeightedEdge<T>::DirectedWeightedEdge(
+constexpr DirectedWeightedEdge<T>::DirectedWeightedEdge(
     const CXXGraph::id_t id,
     const std::pair<shared<const Node<T>>, shared<const Node<T>>> &nodepair,
     const double weight)
     : DirectedEdge<T>(id, nodepair), Weighted(weight) {}
 
 template <typename T>
-DirectedWeightedEdge<T>::DirectedWeightedEdge(const DirectedEdge<T> &edge,
+constexpr DirectedWeightedEdge<T>::DirectedWeightedEdge(
+    const DirectedEdge<T> &edge,
                                               const double weight)
     : DirectedEdge<T>(edge), Weighted(weight) {}
 
 template <typename T>
-DirectedWeightedEdge<T>::DirectedWeightedEdge(const Edge<T> &edge,
+constexpr DirectedWeightedEdge<T>::DirectedWeightedEdge(const Edge<T> &edge,
                                               const double weight)
     : DirectedEdge<T>(edge), Weighted(weight) {}
 
 template <typename T>
-DirectedWeightedEdge<T>::DirectedWeightedEdge(const DirectedEdge<T> &edge)
+constexpr DirectedWeightedEdge<T>::DirectedWeightedEdge(
+    const DirectedEdge<T> &edge)
     : DirectedEdge<T>(edge), Weighted() {}
 
 template <typename T>
-DirectedWeightedEdge<T>::DirectedWeightedEdge(const Edge<T> &edge)
+constexpr DirectedWeightedEdge<T>::DirectedWeightedEdge(const Edge<T> &edge)
     : DirectedEdge<T>(edge), Weighted() {}
 
 template <typename T>
-DirectedWeightedEdge<T>::DirectedWeightedEdge(
+constexpr DirectedWeightedEdge<T>::DirectedWeightedEdge(
     const UndirectedWeightedEdge<T> &edge)
     : DirectedEdge<T>(edge), Weighted(edge.getWeight()) {}
 
diff --git a/include/CXXGraph/Edge/Edge_decl.h b/include/CXXGraph/Edge/Edge_decl.h
index 11d90d880..4f24053a7 100644
--- a/include/CXXGraph/Edge/Edge_decl.h
+++ b/include/CXXGraph/Edge/Edge_decl.h
@@ -49,17 +49,18 @@ class Edge {
  public:
   typedef T Node_t;
 
-  Edge(const CXXGraph::id_t id, const Node<T> &node1, const Node<T> &node2);
-  Edge(const CXXGraph::id_t id, shared<const Node<T>> node1,
+  constexpr Edge(const CXXGraph::id_t id, const Node<T> &node1, const Node<T> &node2);
+  constexpr Edge(const CXXGraph::id_t id, shared<const Node<T>> node1,
        shared<const Node<T>> node2);
-  Edge(const CXXGraph::id_t id,
+  constexpr Edge(const CXXGraph::id_t id,
        const std::pair<const Node<T> *, const Node<T> *> &nodepair);
-  Edge(const CXXGraph::id_t id,
+  constexpr Edge(
+      const CXXGraph::id_t id,
        const std::pair<shared<const Node<T>>, shared<const Node<T>>> &nodepair);
   virtual ~Edge() = default;
   void setFirstNode(shared<const Node<T>> node);
   void setSecondNode(shared<const Node<T>> node);
-  unsigned long long getId() const;
+  constexpr unsigned long long getId() const;
   const std::pair<shared<const Node<T>>, shared<const Node<T>>> &getNodePair()
       const;
   shared<const Node<T>> getOtherNode(shared<const Node<T>> node) const;
@@ -67,7 +68,7 @@ class Edge {
   virtual const std::optional<bool> isWeighted() const;
   // operator
   virtual bool operator==(const Edge<T> &b) const;
-  bool operator<(const Edge<T> &b) const;
+  constexpr bool operator<(const Edge<T> &b) const;
 
   friend std::ostream &operator<< <>(std::ostream &os, const Edge<T> &edge);
 };
diff --git a/include/CXXGraph/Edge/Edge_impl.hpp b/include/CXXGraph/Edge/Edge_impl.hpp
index 7f35228b9..cd2f5b5c6 100644
--- a/include/CXXGraph/Edge/Edge_impl.hpp
+++ b/include/CXXGraph/Edge/Edge_impl.hpp
@@ -35,36 +35,30 @@ using std::make_shared;
 using std::make_unique;
 
 template <typename T>
-Edge<T>::Edge(const CXXGraph::id_t id, const Node<T> &node1,
-              const Node<T> &node2) {
-  this->nodePair.first = make_shared<const Node<T>>(node1);
-  this->nodePair.second = make_shared<const Node<T>>(node2);
-  this->id = id;
-}
+constexpr Edge<T>::Edge(const CXXGraph::id_t otherId, const Node<T> &node1,
+              const Node<T> &node2)
+    : id(otherId), nodePair{std::make_shared<const Node<T>>(node1),
+               std::make_shared<const Node<T>>(node2)}
+      {}
 
 template <typename T>
-Edge<T>::Edge(const CXXGraph::id_t id, shared<const Node<T>> node1,
-              shared<const Node<T>> node2) {
-  this->nodePair.first = node1;
-  this->nodePair.second = node2;
-  this->id = id;
-}
+constexpr Edge<T>::Edge(const CXXGraph::id_t otherId, shared<const Node<T>> node1,
+              shared<const Node<T>> node2)
+    : id(otherId), nodePair(node1, node2) {}
 
 template <typename T>
-Edge<T>::Edge(const CXXGraph::id_t id,
-              const std::pair<const Node<T> *, const Node<T> *> &nodepair) {
-  this->nodePair.first = make_shared<const Node<T>>(*(nodepair.first));
-  this->nodePair.second = make_shared<const Node<T>>(*(nodepair.second));
-  this->id = id;
-}
+constexpr Edge<T>::Edge(const CXXGraph::id_t otherId,
+              const std::pair<const Node<T> *, const Node<T> *> &nodepair) 
+    : id(otherId) 
+    , nodePair(std::make_shared<const Node<T>>(*(nodepair.first)),
+                           std::make_shared<const Node<T>>(*(nodepair.second)))
+{ }
 
 template <typename T>
-Edge<T>::Edge(
-    const CXXGraph::id_t id,
+constexpr Edge<T>::Edge(
+    const CXXGraph::id_t otherId,
     const std::pair<shared<const Node<T>>, shared<const Node<T>>> &nodepair)
-    : nodePair(nodepair) {
-  this->id = id;
-}
+    : id(otherId), nodePair(nodepair) { }
 
 template <typename T>
 void Edge<T>::setFirstNode(shared<const Node<T>> node) {
@@ -79,7 +73,7 @@ void Edge<T>::setSecondNode(shared<const Node<T>> node) {
 }
 
 template <typename T>
-unsigned long long Edge<T>::getId() const {
+constexpr unsigned long long Edge<T>::getId() const {
   return id;
 }
 
@@ -114,7 +108,7 @@ bool Edge<T>::operator==(const Edge<T> &b) const {
 }
 
 template <typename T>
-bool Edge<T>::operator<(const Edge<T> &b) const {
+constexpr bool Edge<T>::operator<(const Edge<T> &b) const {
   return (this->id < b.id);
 }
 
diff --git a/include/CXXGraph/Edge/Weighted_decl.h b/include/CXXGraph/Edge/Weighted_decl.h
index 6d6f97084..2b68d31ea 100644
--- a/include/CXXGraph/Edge/Weighted_decl.h
+++ b/include/CXXGraph/Edge/Weighted_decl.h
@@ -28,11 +28,11 @@ class Weighted {
   double weight = 0.0;
 
  public:
-  Weighted();
-  explicit Weighted(const double weight);
-  virtual ~Weighted() = default;
-  double getWeight() const;
-  void setWeight(const double weight);
+  constexpr Weighted() noexcept;
+  constexpr explicit Weighted(const double weight) noexcept;
+  virtual ~Weighted() noexcept = default;
+  constexpr double getWeight() const noexcept;
+  constexpr void setWeight(const double weight);
 };
 }  // namespace CXXGraph
 
diff --git a/include/CXXGraph/Edge/Weighted_impl.hpp b/include/CXXGraph/Edge/Weighted_impl.hpp
index bcd7cda63..3b295b1eb 100644
--- a/include/CXXGraph/Edge/Weighted_impl.hpp
+++ b/include/CXXGraph/Edge/Weighted_impl.hpp
@@ -26,17 +26,16 @@
 
 namespace CXXGraph {
 
-// inline because the implementation of non-template function in header file
-inline Weighted::Weighted() { weight = 0.0; }
+constexpr Weighted::Weighted() noexcept : weight(0.0) {}
 
-// inline because the implementation of non-template function in header file
-inline Weighted::Weighted(const double weight) { this->weight = weight; }
+constexpr Weighted::Weighted(const double inputWeight) noexcept
+    : weight(inputWeight) {}
 
-// inline because the implementation of non-template function in header file
-inline double Weighted::getWeight() const { return weight; }
+constexpr double Weighted::getWeight() const noexcept { return weight; }
 
-// inline because the implementation of non-template function in header file
-inline void Weighted::setWeight(const double weight) { this->weight = weight; }
+constexpr void Weighted::setWeight(const double inputWeight) {
+  weight = inputWeight;
+}
 
 }  // namespace CXXGraph
 
diff --git a/include/CXXGraph/Graph/Graph_impl.hpp b/include/CXXGraph/Graph/Graph_impl.hpp
index 950cd8daf..0bcba37d6 100644
--- a/include/CXXGraph/Graph/Graph_impl.hpp
+++ b/include/CXXGraph/Graph/Graph_impl.hpp
@@ -31,28 +31,21 @@
 namespace CXXGraph {
 
 using std::make_shared;
-using std::make_unique;
 
 template <typename T>
-Graph<T>::Graph() {
-  /* Caching the adjacency matrix */
-  cacheAdjMatrix();
-  cacheDegreeMatrix();
-  cacheLaplacianMatrix();
-  cacheTransitionMatrix();
-}
+Graph<T>::Graph()
+    : cachedAdjMatrix(Graph<T>::getAdjMatrix()),
+      cachedDegreeMatrix(Graph<T>::getDegreeMatrix()),
+      cachedLaplacianMatrix(Graph<T>::getLaplacianMatrix()),
+      cachedTransitionMatrix(Graph<T>::getTransitionMatrix()) {}
 
 template <typename T>
-Graph<T>::Graph(const T_EdgeSet<T> &edgeSet) {
-  for (auto edgeIt : edgeSet) {
-    this->edgeSet.insert(edgeIt);
-  }
-  /* Caching the adjacency matrix */
-  cacheAdjMatrix();
-  cacheDegreeMatrix();
-  cacheLaplacianMatrix();
-  cacheTransitionMatrix();
-}
+Graph<T>::Graph(const T_EdgeSet<T> &edgeSetToCopy)
+    : edgeSet(edgeSetToCopy),
+      cachedAdjMatrix(Graph<T>::getAdjMatrix()),
+      cachedDegreeMatrix(Graph<T>::getDegreeMatrix()),
+      cachedLaplacianMatrix(Graph<T>::getLaplacianMatrix()),
+      cachedTransitionMatrix(Graph<T>::getTransitionMatrix()) {}
 
 template <typename T>
 const T_EdgeSet<T> &Graph<T>::getEdgeSet() const {
diff --git a/include/CXXGraph/Node/Node_decl.h b/include/CXXGraph/Node/Node_decl.h
index 65edf1fb7..1668a0240 100644
--- a/include/CXXGraph/Node/Node_decl.h
+++ b/include/CXXGraph/Node/Node_decl.h
@@ -22,38 +22,39 @@
 
 #pragma once
 #include <iostream>
-
+#include <type_traits>
 #include "CXXGraph/Utility/id_t.hpp"
 
 namespace CXXGraph {
-template <typename T>
+template <typename T, typename = std::string>
 class Node;
-template <typename T>
-std::ostream &operator<<(std::ostream &os, const Node<T> &node);
-template <typename T>
+template <typename T, typename UserID>
+std::ostream &operator<<(std::ostream &os, const Node<T, UserID> &node);
+template <typename T, typename UserID>
 class Node {
  private:
   CXXGraph::id_t id = 0;
-  std::string userId = "";
+  UserID userId{};
   T data;
-  void setId(const std::string &);
+  constexpr void setId(const UserID &);
 
  public:
-  typedef T Node_t;
+  using Node_t = T;
 
-  Node(const std::string &, const T &data);
+  constexpr Node(const UserID &, const T &data);
   // Move constructor
-  explicit Node(const std::string &, T &&data) noexcept;
-  ~Node() = default;
-  const CXXGraph::id_t &getId() const;
-  const std::string &getUserId() const;
-  const T &getData() const;
-  T& getData();
-  void setData(T &&new_data);
+  constexpr explicit Node(const UserID &, T &&data) noexcept(std::is_nothrow_move_assignable<T>::value);
+  ~Node() noexcept = default;
+  constexpr const CXXGraph::id_t &getId() const;
+  constexpr const UserID &getUserId() const;
+  constexpr const T &getData() const;
+  constexpr T& getData();
+  constexpr void setData(T &&new_data);
   // operator
-  bool operator==(const Node<T> &b) const;
-  bool operator<(const Node<T> &b) const;
-  friend std::ostream &operator<< <>(std::ostream &os, const Node<T> &node);
+  constexpr bool operator==(const Node<T, UserID> &b) const;
+  constexpr bool operator<(const Node<T, UserID> &b) const;
+  
+  friend std::ostream &operator<< <>(std::ostream &os, const Node<T, UserID> &node);
 };
 
 }  // namespace CXXGraph
diff --git a/include/CXXGraph/Node/Node_impl.hpp b/include/CXXGraph/Node/Node_impl.hpp
index 058f092ef..3ff1f85c2 100644
--- a/include/CXXGraph/Node/Node_impl.hpp
+++ b/include/CXXGraph/Node/Node_impl.hpp
@@ -20,76 +20,122 @@
 #ifndef __CXXGRAPH_NODE_IMPL_H__
 #define __CXXGRAPH_NODE_IMPL_H__
 
+#if __cplusplus >= 202004L
+#include <bitset>
+#else
+#include <cstring>
+#endif
+
 #include <iomanip>
+#include <limits>
+#include <type_traits>
 
 #include "Node_decl.h"
 
 namespace CXXGraph {
+// internals not intended to be accessed by the end user
+namespace internals {
+template <typename AnyUserID>
+constexpr CXXGraph::id_t UserIdToId(const AnyUserID &id) {
+  // in C++ 23 we have constexpr hashes
+  if constexpr (__cplusplus >= 202302L) return std::hash<AnyUserID>{}(id);
+  // hashing is trivial for integral types
+  if constexpr (std::is_integral<AnyUserID>::value) {
+    // assert nothing is greater than a size_t to avoid issues with GCC and
+    // clang's 128 bit ints, a size_t is usually 64 bits
+    static_assert(std::numeric_limits<CXXGraph::id_t>::max() >=
+                  std::numeric_limits<AnyUserID>::max());
+
+    if constexpr (std::is_signed<AnyUserID>::value) {
+      // Add id to half max so that we have something unique
+      return (std::numeric_limits<CXXGraph::id_t>::max() / 2) + id;
+    }
+    return static_cast<CXXGraph::id_t>(id);
+  }
+  // typepun the float into an int
+  if constexpr (std::is_floating_point<AnyUserID>::value) {
+    // static assert to avoid long double (80 bits rather than 64)
+    static_assert(sizeof(CXXGraph::id_t) >= sizeof(AnyUserID));
+// In C++20 we can do typepunning at compile time
+#if __cplusplus >= 202004L
+    return std::bit_cast<CXXGraph::id_t>(id);
+#else   // < C++20
+    // otherwise use memcpy (not compile time)
+    CXXGraph::id_t result{};
+    std::memcpy(&result, &id, sizeof(id));
+    return result;
+#endif  // >= C++20
+  }
+  // resort back to runtime hash
+  return std::hash<AnyUserID>{}(id);
+}
+}  // namespace internals
 
-template <typename T>
+template <typename T, typename UserID>
 class Node;
 
-template <typename T>
-Node<T>::Node(const std::string &id, const T &data) {
-  this->userId = id;
-  // the userid is set as sha512 hash of the user provided id
-  setId(id);
-  this->data = data;
+template <typename T, typename UserID>
+constexpr Node<T, UserID>::Node(const UserID &otherId, const T &otherData)
+    : id(internals::UserIdToId(otherId)), userId(otherId), data(otherData) {
+  static_assert(
+      !std::is_pointer<UserID>::value,
+      "Pointer is not allowed as an ID type, did you mean std::string?");
 }
 
-template <typename T>
-Node<T>::Node(const std::string &id, T &&data) noexcept {
-  this->userId = id;
-  // the userid is set as sha512 hash of the user provided id
-  setId(id);
-  this->data = std::move(data);
+template <typename T, typename UserID>
+constexpr Node<T, UserID>::Node(const UserID &otherId, T &&otherData) noexcept(
+    std::is_nothrow_move_assignable<T>::value)
+    : id(internals::UserIdToId(otherId)), userId(otherId), data(otherData) {
+  static_assert(
+      !std::is_pointer<UserID>::value,
+      "Pointer is not allowed as an ID type, did you mean std::string?");
 }
 
-template <typename T>
-void Node<T>::setId(const std::string &inpId) {
-  this->id = std::hash<std::string>{}(inpId);
+template <typename T, typename UserID>
+constexpr void Node<T, UserID>::setId(const UserID &inputId) {
+  this->id = UserIdToId(inputId);
 }
 
-template <typename T>
-const CXXGraph::id_t &Node<T>::getId() const {
+template <typename T, typename UserID>
+constexpr const CXXGraph::id_t &Node<T, UserID>::getId() const {
   return id;
 }
 
-template <typename T>
-const std::string &Node<T>::getUserId() const {
+template <typename T, typename UserID>
+constexpr const UserID &Node<T, UserID>::getUserId() const {
   return userId;
 }
 
-template <typename T>
-const T &Node<T>::getData() const {
+template <typename T, typename UserID>
+constexpr const T &Node<T, UserID>::getData() const {
   return data;
 }
 
-template <typename T>
-T &Node<T>::getData() {
+template <typename T, typename UserID>
+constexpr T &Node<T, UserID>::getData() {
   return data;
 }
 
-template <typename T>
-void Node<T>::setData(T &&new_data) {
+template <typename T, typename UserID>
+constexpr void Node<T, UserID>::setData(T &&new_data) {
   this->data = std::move(new_data);
 }
 
 // The data type T must have an overload of the equality operator
-template <typename T>
-bool Node<T>::operator==(const Node<T> &b) const {
+template <typename T, typename UserID>
+constexpr bool Node<T, UserID>::operator==(const Node<T, UserID> &b) const {
   return (this->id == b.id && this->data == b.data);
 }
 
-template <typename T>
-bool Node<T>::operator<(const Node<T> &b) const {
+template <typename T, typename UserID>
+constexpr bool Node<T, UserID>::operator<(const Node<T, UserID> &b) const {
   return (this->id < b.id);
 }
 
 // ostream overload
 // The data type T must have an overload of the ostream operator
-template <typename T>
-std::ostream &operator<<(std::ostream &os, const Node<T> &node) {
+template <typename T, typename UserID>
+std::ostream &operator<<(std::ostream &os, const Node<T, UserID> &node) {
   os << "Node: {\n"
      << "  Id:\t" << node.userId << "\n  Data:\t" << node.data << "\n}";
   return os;
diff --git a/include/CXXGraph/Utility/Typedef.hpp b/include/CXXGraph/Utility/Typedef.hpp
index d255184ac..ad7779d27 100644
--- a/include/CXXGraph/Utility/Typedef.hpp
+++ b/include/CXXGraph/Utility/Typedef.hpp
@@ -36,7 +36,7 @@ namespace CXXGraph {
 template <typename T>
 using shared = std::shared_ptr<T>;
 
-template <typename T>
+template <typename T, typename UserID>
 class Node;
 
 template <typename T>
diff --git a/test/ConstexprTests.cpp b/test/ConstexprTests.cpp
new file mode 100644
index 000000000..061ba7780
--- /dev/null
+++ b/test/ConstexprTests.cpp
@@ -0,0 +1,26 @@
+
+#include <memory>
+
+#include "CXXGraph/CXXGraph.hpp"
+#include "gtest/gtest.h"
+
+// Boolean results will always be true
+//  functions are only here to test that this compiles
+constexpr bool IsConstexprContextCreateable() {
+	CXXGraph::Node<int, size_t> node1(1, 1);
+	return true;
+}
+
+constexpr bool IsConstexprCreateable() {
+	constexpr CXXGraph::Node<int, size_t> node1(1, 1);
+	return true;
+}
+
+
+TEST(ConstexprTests, IsConstexprContextCreateable) {
+	ASSERT_TRUE(IsConstexprContextCreateable());
+}
+
+TEST(ConstexprTests, IsConstexprCreateable) {
+	ASSERT_TRUE(IsConstexprCreateable());
+}
\ No newline at end of file