diff --git a/compiler/DirectedGraph/DirectedGraph.hh b/compiler/DirectedGraph/DirectedGraph.hh
index 4aa09108d4..0a6724d575 100644
--- a/compiler/DirectedGraph/DirectedGraph.hh
+++ b/compiler/DirectedGraph/DirectedGraph.hh
@@ -25,10 +25,10 @@
 // to represent the time dependency between computations.
 //===========================================================
 
-template <typename N, typename Comparator = std::less<N>>
+template <typename N>
 class digraph {
     using TWeights      = std::set<int>;
-    using TDestinations = std::map<N, TWeights, Comparator>;
+    using TDestinations = std::map<N, TWeights>;
 
     static inline const TWeights gEmptyWeights;
 
@@ -38,8 +38,8 @@ class digraph {
     // have integer values attached.
     class internalgraph {
        private:
-        std::set<N, Comparator>                fNodes;        // {n1,n2,...}
-        std::map<N, TDestinations, Comparator> fConnections;  // {(ni -{d1,d2,...}-> nj),...}
+        std::set<N>                fNodes;        // {n1,n2,...}
+        std::map<N, TDestinations> fConnections;  // {(ni -{d1,d2,...}-> nj),...}
 
        public:
 #if 0
@@ -70,13 +70,10 @@ class digraph {
         //----------------------------------------------------------------------
 
         // returns the set of nodes of the graph
-        [[nodiscard]] const std::set<N, Comparator>& nodes() const { return fNodes; }
+        [[nodiscard]] const std::set<N>& nodes() const { return fNodes; }
 
         // returns the set of nodes of the graph
-        [[nodiscard]] const std::map<N, TDestinations, Comparator>& connections() const
-        {
-            return fConnections;
-        }
+        [[nodiscard]] const std::map<N, TDestinations>& connections() const { return fConnections; }
 
         // Returns the destinations of node n in the graph
         [[nodiscard]] const TDestinations& destinations(const N& n) const
@@ -208,10 +205,10 @@ class digraph {
     //--------------------------------------------------------------------------
 
     // returns the set of nodes of the graph
-    [[nodiscard]] const std::set<N, Comparator>& nodes() const { return fContent->nodes(); }
+    [[nodiscard]] const std::set<N>& nodes() const { return fContent->nodes(); }
 
     // returns the set of nodes of the graph
-    [[nodiscard]] const std::map<N, TDestinations, Comparator>& connections() const
+    [[nodiscard]] const std::map<N, TDestinations>& connections() const
     {
         return fContent->connections();
     }
diff --git a/compiler/DirectedGraph/DirectedGraphAlgorythm.hh b/compiler/DirectedGraph/DirectedGraphAlgorythm.hh
index 96f198fc50..7afc8f2716 100644
--- a/compiler/DirectedGraph/DirectedGraphAlgorythm.hh
+++ b/compiler/DirectedGraph/DirectedGraphAlgorythm.hh
@@ -27,7 +27,7 @@
 //===========================================================
 //===========================================================
 
-template <typename N, typename Comparator = std::less<N>>
+template <typename N>
 class Tarjan {
     // Additional information associated to each node
     // during the visit
@@ -38,12 +38,12 @@ class Tarjan {
         int  fNum2    = 0;
     };
 
-    const digraph<N, Comparator>       fGraph;
-    int                                fGroup;
-    std::stack<N>                      fStack;
-    std::map<N, tarjanAux, Comparator> fAux;
-    std::set<std::set<N, Comparator>>  fPartition;
-    int                                fCycleCount;
+    const digraph<N>       fGraph;
+    int                    fGroup;
+    std::stack<N>          fStack;
+    std::map<N, tarjanAux> fAux;
+    std::set<std::set<N>>  fPartition;
+    int                    fCycleCount;
 
     // visit a specific node n of the graph
     void visit(const N& v)
@@ -77,8 +77,8 @@ class Tarjan {
         if (x.fNum1 == x.fNum2) {
             // std::cout << "the node " << v << " is the root of a cycle" << std::endl;
 
-            std::set<N, Comparator> cycle;
-            bool                    finished = false;
+            std::set<N> cycle;
+            bool        finished = false;
             do {
                 const N& w = fStack.top();
                 fStack.pop();
@@ -95,7 +95,7 @@ class Tarjan {
     }
 
    public:
-    explicit Tarjan(const digraph<N, Comparator>& g) : fGraph(g), fGroup(0), fCycleCount(0)
+    explicit Tarjan(const digraph<N>& g) : fGraph(g), fGroup(0), fCycleCount(0)
     {
         for (const auto& n : fGraph.nodes()) {
             if (fAux.find(n) == fAux.end()) {
@@ -104,7 +104,7 @@ class Tarjan {
         }
     }
 
-    [[nodiscard]] const std::set<std::set<N, Comparator>>& partition() const { return fPartition; }
+    [[nodiscard]] const std::set<std::set<N>>& partition() const { return fPartition; }
 
     [[nodiscard]] int cycles() const { return fCycleCount; }
 };
@@ -116,10 +116,10 @@ class Tarjan {
 //===========================================================
 //===========================================================
 
-template <typename N, typename Comparator = std::less<N>>
-inline int cycles(const digraph<N, Comparator>& g)
+template <typename N>
+inline int cycles(const digraph<N>& g)
 {
-    Tarjan<N, Comparator> T(g);
+    Tarjan<N> T(g);
     return T.cycles();
 }
 
@@ -132,12 +132,12 @@ inline int cycles(const digraph<N, Comparator>& g)
 //===========================================================
 //===========================================================
 
-template <typename N, typename Comparator = std::less<N>>
-inline digraph<digraph<N, Comparator>> graph2dag(const digraph<N, Comparator>& g)
+template <typename N>
+inline digraph<digraph<N>> graph2dag(const digraph<N>& g)
 {
-    Tarjan<N, Comparator>                           T(g);  // the partition of g
-    std::map<N, digraph<N, Comparator>, Comparator> M;  // std::mapping between nodes and supernodes
-    digraph<digraph<N, Comparator>>                 sg;  // the resulting supergraph
+    Tarjan<N>               T(g);  // the partition of g
+    std::map<N, digraph<N>> M;     // std::mapping between nodes and supernodes
+    digraph<digraph<N>>     sg;    // the resulting supergraph
 
     // build the graph of supernodes
 
@@ -145,7 +145,7 @@ inline digraph<digraph<N, Comparator>> graph2dag(const digraph<N, Comparator>& g
     // create also a std::mapping in order to retrieve the supernode a node
     /// belongs to.
     for (const auto& s : T.partition()) {
-        digraph<N, Comparator> sn;            // the supernode graph
+        digraph<N> sn;                        // the supernode graph
         for (const N& n : s) {                // for each node of a cycle
             M.insert(std::make_pair(n, sn));  // remember its supernode
             sn.add(n);                        // and add it to the super node
@@ -155,11 +155,11 @@ inline digraph<digraph<N, Comparator>> graph2dag(const digraph<N, Comparator>& g
 
     // compute the destinations between the supernodes
     for (const auto& n1 : g.nodes()) {
-        digraph<N, Comparator> sn1(M[n1]);
+        digraph<N> sn1(M[n1]);
         for (const auto& c : g.destinations(n1)) {
-            const N&               n2  = c.first;
-            const auto&            W12 = c.second;
-            digraph<N, Comparator> sn2(M[n2]);
+            const N&    n2  = c.first;
+            const auto& W12 = c.second;
+            digraph<N>  sn2(M[n2]);
             if (sn1 == sn2) {
                 // the connection is inside the same supernode
                 sn1.add(n1, n2, W12);
@@ -182,13 +182,13 @@ inline digraph<digraph<N, Comparator>> graph2dag(const digraph<N, Comparator>& g
 //===========================================================
 //===========================================================
 
-template <typename N, typename Comparator = std::less<N>>
-inline digraph<digraph<N, Comparator>> graph2dag2(const digraph<N, Comparator>& g)
+template <typename N>
+inline digraph<digraph<N>> graph2dag2(const digraph<N>& g)
 {
-    Tarjan<N, Comparator>                           T(g);  // the partition of g
-    std::map<N, digraph<N, Comparator>, Comparator> M;  // std::mapping between nodes and supernodes
-    digraph<digraph<N, Comparator>>                 sg;  // the resulting supergraph
-    std::map<std::pair<digraph<N, Comparator>, digraph<N, Comparator>>, int, Comparator>
+    Tarjan<N>               T(g);  // the partition of g
+    std::map<N, digraph<N>> M;     // std::mapping between nodes and supernodes
+    digraph<digraph<N>>     sg;    // the resulting supergraph
+    std::map<std::pair<digraph<N>, digraph<N>>, int>
         CC;  // count of destinations between supernodes
 
     // build the graph of supernodes
@@ -197,7 +197,7 @@ inline digraph<digraph<N, Comparator>> graph2dag2(const digraph<N, Comparator>&
     // create also a std::mapping in order to retrieve the supernode a node
     /// belongs to.
     for (const auto& s : T.partition()) {
-        digraph<N, Comparator> sn;            // the supernode graph
+        digraph<N> sn;                        // the supernode graph
         for (const N& n : s) {                // for each node of a cycle
             M.insert(std::make_pair(n, sn));  // remember its supernode
             sn.add(n);                        // and add it to the super node
@@ -207,9 +207,9 @@ inline digraph<digraph<N, Comparator>> graph2dag2(const digraph<N, Comparator>&
 
     // compute the number of destinations between the supernodes
     for (const auto& n1 : g.nodes()) {              // for each node n1
-        digraph<N, Comparator> sn1(M[n1]);          // retrieve the supernode
+        digraph<N> sn1(M[n1]);                      // retrieve the supernode
         for (const auto& c : g.destinations(n1)) {  // for each destination of n
-            digraph<N, Comparator> sn2(M[c.first]);
+            digraph<N> sn2(M[c.first]);
             if (sn1 == sn2) {
                 // the connection is inside the same supernode
                 sn1.add(n1, c.first, c.second);
@@ -237,17 +237,17 @@ inline digraph<digraph<N, Comparator>> graph2dag2(const digraph<N, Comparator>&
 //===========================================================
 //===========================================================
 
-template <typename N, typename Comparator = std::less<N>>
-inline std::vector<std::vector<N>> parallelize(const digraph<N, Comparator>& g)
+template <typename N>
+inline std::vector<std::vector<N>> parallelize(const digraph<N>& g)
 {
     //-----------------------------------------------------------
     // Find the level of a node n -> {m1,m2,...} such that
     //		level(n -> {})			= 0
     //		level(n -> {m1,m2,...})	= 1 + std::max(level(mi))
     //-----------------------------------------------------------
-    using Levelfun = std::function<int(const N&, std::map<N, int, Comparator>&)>;
+    using Levelfun = std::function<int(const N&, std::map<N, int>&)>;
 
-    Levelfun level = [&g, &level](const N& n1, std::map<N, int, Comparator>& levelcache) -> int {
+    Levelfun level = [&g, &level](const N& n1, std::map<N, int>& levelcache) -> int {
         auto p = levelcache.find(n1);
         if (p != levelcache.end()) {
             return p->second;
@@ -277,8 +277,8 @@ inline std::vector<std::vector<N>> parallelize(const digraph<N, Comparator>& g)
     return v;
 }
 
-template <typename N, typename Comparator = std::less<N>>
-inline std::vector<std::vector<N>> rparallelize(const digraph<N, Comparator>& G)
+template <typename N>
+inline std::vector<std::vector<N>> rparallelize(const digraph<N>& G)
 {
     std::vector<std::vector<N>> P = parallelize(G);
     int                         i = 0;
@@ -300,8 +300,8 @@ inline std::vector<std::vector<N>> rparallelize(const digraph<N, Comparator>& G)
 //===========================================================
 //===========================================================
 
-template <typename N, typename Comparator = std::less<N>>
-inline std::vector<N> serialize(const digraph<N, Comparator>& G)
+template <typename N>
+inline std::vector<N> serialize(const digraph<N>& G)
 {
     //------------------------------------------------------------------------
     // visit : a local std::function (simulated using a lambda) to visit a graph
@@ -310,10 +310,9 @@ inline std::vector<N> serialize(const digraph<N, Comparator>& G)
     // V : std::set of already visited nodes
     // S : serialized std::vector of nodes
     //------------------------------------------------------------------------
-    using Visitfun = std::function<void(const digraph<N, Comparator>&, const N&,
-                                        std::set<N, Comparator>&, std::vector<N>&)>;
-    Visitfun visit = [&visit](const digraph<N, Comparator>& g, const N& n,
-                              std::set<N, Comparator>& V, std::vector<N>& S) {
+    using Visitfun =
+        std::function<void(const digraph<N>&, const N&, std::set<N>&, std::vector<N>&)>;
+    Visitfun visit = [&visit](const digraph<N>& g, const N& n, std::set<N>& V, std::vector<N>& S) {
         if (V.find(n) == V.end()) {
             V.insert(n);
             for (const auto& p : g.destinations(n)) {
@@ -323,8 +322,8 @@ inline std::vector<N> serialize(const digraph<N, Comparator>& G)
         }
     };
 
-    std::vector<N>          S;
-    std::set<N, Comparator> V;
+    std::vector<N> S;
+    std::set<N>    V;
     for (const N& n : G.nodes()) {
         visit(G, n, V, S);
     }
@@ -338,13 +337,11 @@ inline std::vector<N> serialize(const digraph<N, Comparator>& G)
 //===========================================================
 //===========================================================
 
-template <typename N, typename M, typename Comparator1 = std::less<N>,
-          typename Comparator2 = std::less<M>>
-inline digraph<M, Comparator2> mapnodes(const digraph<N, Comparator1>& g,
-                                        std::function<M(const N&)>     foo)
+template <typename N, typename M>
+inline digraph<M> mapnodes(const digraph<N>& g, std::function<M(const N&)> foo)
 {
-    digraph<M, Comparator2>                  r;
-    std::map<N, M, Comparator1, Comparator2> cache;
+    digraph<M>     r;
+    std::map<N, M> cache;
     // create a new graph with the transformed nodes
     for (const auto& n1 : g.nodes()) {
         M n2 = foo(n1);
@@ -369,10 +366,10 @@ inline digraph<M, Comparator2> mapnodes(const digraph<N, Comparator1>& g,
 //===========================================================
 //===========================================================
 
-template <typename N, typename Comparator = std::less<N>>
-inline digraph<N, Comparator> reverse(const digraph<N, Comparator>& g)
+template <typename N>
+inline digraph<N> reverse(const digraph<N>& g)
 {
-    digraph<N, Comparator> r;
+    digraph<N> r;
     // copy the destinations
     for (const auto& n : g.nodes()) {
         r.add(n);
@@ -393,11 +390,11 @@ inline digraph<N, Comparator> reverse(const digraph<N, Comparator>& g)
 //===========================================================
 //===========================================================
 
-template <typename N, typename Comparator = std::less<N>>
-inline digraph<N, Comparator> mapconnections(const digraph<N, Comparator>&                                             G,
+template <typename N>
+inline digraph<N> mapconnections(const digraph<N>&                                             G,
                                  std::function<bool(const N&, const N&, const std::set<int>&)> keep)
 {
-    digraph<N, Comparator> R;
+    digraph<N> R;
     for (const N& n : G.nodes()) {
         R.add(n);
         for (const auto& c : G.destinations(n)) {
@@ -425,9 +422,9 @@ inline digraph<N, Comparator> mapconnections(const digraph<N, Comparator>&
  * @param L resulting graph of left nodes
  * @param R resulting graph of right nodes
  */
-template <typename N, typename Comparator = std::less<N>>
-void splitgraph(const digraph<N, Comparator>& G, std::function<bool(const N&)> left,
-                digraph<N, Comparator>& L, digraph<N, Comparator>& R)
+template <typename N>
+void splitgraph(const digraph<N>& G, std::function<bool(const N&)> left, digraph<N>& L,
+                digraph<N>& R)
 {
     for (auto n : G.nodes()) {
         if (left(n)) {
@@ -462,14 +459,14 @@ void splitgraph(const digraph<N, Comparator>& G, std::function<bool(const N&)> l
  * @param S the set of nodes to keep with their dependencies
  * @return the resulting subgraph
  */
-template <typename N, typename Comparator = std::less<N>>
-digraph<N, Comparator> subgraph(const digraph<N, Comparator>& G, const std::set<N, Comparator>& S)
+template <typename N>
+digraph<N> subgraph(const digraph<N>& G, const std::set<N>& S)
 {
-    digraph<N, Comparator>  R;     // the (R)esulting graph
-    std::set<N, Comparator> W{S};  // nodes (W)aiting to be processed
-    std::set<N, Comparator> P;     // nodes already (P)rocessed
+    digraph<N>  R;     // the (R)esulting graph
+    std::set<N> W{S};  // nodes (W)aiting to be processed
+    std::set<N> P;     // nodes already (P)rocessed
     while (!W.empty()) {
-        std::set<N, Comparator> M;  // (M)ore nodes to process at next iteration
+        std::set<N> M;  // (M)ore nodes to process at next iteration
         for (auto n : W) {
             R.add(n);     // add n to the resulting graph
             P.insert(n);  // mark n as processed
@@ -492,10 +489,10 @@ digraph<N, Comparator> subgraph(const digraph<N, Comparator>& G, const std::set<
 //===========================================================
 //===========================================================
 
-template <typename N, typename Comparator = std::less<N>>
-inline digraph<N, Comparator> cut(const digraph<N, Comparator>& G, int dm)
+template <typename N>
+inline digraph<N> cut(const digraph<N>& G, int dm)
 {
-    digraph<N, Comparator> R;
+    digraph<N> R;
     for (const auto& n1 : G.nodes()) {
         R.add(n1);
         for (const auto& c : G.destinations(n1)) {
@@ -526,11 +523,11 @@ inline digraph<N, Comparator> cut(const digraph<N, Comparator>& G, int dm)
 //===========================================================
 //===========================================================
 
-template <typename N, typename Comparator = std::less<N>>
-inline digraph<N, Comparator> chain(const digraph<N, Comparator>& g, bool strict)
+template <typename N>
+inline digraph<N> chain(const digraph<N>& g, bool strict)
 {
-    const digraph<N, Comparator> h = reverse(g);
-    digraph<N, Comparator>       r;
+    const digraph<N> h = reverse(g);
+    digraph<N>       r;
     for (const auto& n : g.nodes()) {
         if (!strict) {
             r.add(n);
@@ -546,10 +543,10 @@ inline digraph<N, Comparator> chain(const digraph<N, Comparator>& g, bool strict
     return r;
 }
 
-template <typename N, typename Comparator = std::less<N>>
-inline std::vector<N> roots(const digraph<N, Comparator>& G)
+template <typename N>
+inline std::vector<N> roots(const digraph<N>& G)
 {
-    std::map<N, int, Comparator> R;
+    std::map<N, int> R;
     for (const N& n : G.nodes()) {
         for (const auto& c : G.destinations(n)) {
             R[c.first]++;
@@ -564,8 +561,8 @@ inline std::vector<N> roots(const digraph<N, Comparator>& G)
     return V;
 }
 
-template <typename N, typename Comparator = std::less<N>>
-inline std::vector<N> leaves(const digraph<N, Comparator>& G)
+template <typename N>
+inline std::vector<N> leaves(const digraph<N>& G)
 {
     std::vector<N> L;
     for (const N& n : G.nodes()) {
@@ -590,7 +587,7 @@ inline std::vector<N> leaves(const digraph<N, Comparator>& G)
 //===========================================================
 //===========================================================
 
-template <typename N, typename Comparator = std::less<N>>
+template <typename N>
 inline std::ostream& operator<<(std::ostream& file, const std::list<N>& L)
 {
     std::string sep = "";
@@ -609,7 +606,7 @@ inline std::ostream& operator<<(std::ostream& file, const std::list<N>& L)
 //===========================================================
 //===========================================================
 
-template <typename N, typename Comparator = std::less<N>>
+template <typename N>
 inline std::ostream& operator<<(std::ostream& file, const std::vector<N>& V)
 {
     std::string sep = "";
@@ -628,7 +625,7 @@ inline std::ostream& operator<<(std::ostream& file, const std::vector<N>& V)
 //===========================================================
 //===========================================================
 
-template <typename N, typename Comparator = std::less<N>>
+template <typename N>
 inline std::ostream& operator<<(std::ostream& file, const std::set<N>& S)
 {
     std::string sep = "";
@@ -647,8 +644,7 @@ inline std::ostream& operator<<(std::ostream& file, const std::set<N>& S)
 //===========================================================
 //===========================================================
 
-template <typename N, typename M, typename Comparator1 = std::less<N>,
-          typename Comparator2 = std::less<N>>
+template <typename N, typename M>
 inline std::ostream& operator<<(std::ostream& file, const std::pair<N, M>& V)
 {
     return file << "std::pair{" << V.first << ", " << V.second << "}";
@@ -660,9 +656,8 @@ inline std::ostream& operator<<(std::ostream& file, const std::pair<N, M>& V)
 //===========================================================
 //===========================================================
 
-template <typename N, typename Comparator = std::less<N>>
-inline std::ostream& dotfile(std::ostream& file, const digraph<N, Comparator>& g,
-                             bool clusters = false)
+template <typename N>
+inline std::ostream& dotfile(std::ostream& file, const digraph<N>& g, bool clusters = false)
 {
     file << "digraph mygraph {" << std::endl;
     for (const N& n : g.nodes()) {
@@ -682,8 +677,8 @@ inline std::ostream& dotfile(std::ostream& file, const digraph<N, Comparator>& g
     }
 
     if (clusters) {
-        Tarjan<N, Comparator> T(g);
-        int                   ccount = 0;  // cluster count
+        Tarjan<N> T(g);
+        int       ccount = 0;  // cluster count
         for (const auto& s : T.partition()) {
             file << "\t"
                  << "subgraph cluster" << ccount++ << " { " << std::endl;
@@ -704,8 +699,8 @@ inline std::ostream& dotfile(std::ostream& file, const digraph<N, Comparator>& g
 //===========================================================
 //===========================================================
 
-template <typename N, typename Comparator = std::less<N>>
-inline std::ostream& operator<<(std::ostream& file, const digraph<N, Comparator>& g)
+template <typename N>
+inline std::ostream& operator<<(std::ostream& file, const digraph<N>& g)
 {
     std::string sep = "";
 
diff --git a/compiler/DirectedGraph/Schedule.hh b/compiler/DirectedGraph/Schedule.hh
index 93551e3e72..b34836711a 100644
--- a/compiler/DirectedGraph/Schedule.hh
+++ b/compiler/DirectedGraph/Schedule.hh
@@ -30,12 +30,11 @@
  *
  * @tparam N
  */
-template <typename N, typename Comparator = std::less<N>>
+template <typename N>
 class schedule {
    private:
-    std::vector<N> fElements;  // ordered set of elements
-    std::map<N, int, Comparator>
-        fOrder;  // order of each element (starting at 1, 0 indicates not in schedule)
+    std::vector<N>   fElements;  // ordered set of elements
+    std::map<N, int> fOrder;  // order of each element (starting at 1, 0 indicates not in schedule)
 
    public:
     // number of elements in the schedule
@@ -64,7 +63,7 @@ class schedule {
     }
 
     // append all the elements of a schedule
-    schedule& append(const schedule<N, Comparator>& S)
+    schedule& append(const schedule<N>& S)
     {
         for (const N& n : S.elements()) {
             append(n);
@@ -81,8 +80,8 @@ class schedule {
  * @param S the schedule
  * @return std::ostream& the output stream
  */
-template <typename N, typename Comparator = std::less<N>>
-inline std::ostream& operator<<(std::ostream& file, const schedule<N, Comparator>& S)
+template <typename N>
+inline std::ostream& operator<<(std::ostream& file, const schedule<N>& S)
 {
     std::string sep = "";
 
@@ -101,11 +100,11 @@ inline std::ostream& operator<<(std::ostream& file, const schedule<N, Comparator
  * @param G the graph we want to schedule
  * @return schedule<N> the deep first schedule of G
  */
-template <typename N, typename Comparator = std::less<N>>
-inline schedule<N, Comparator> dfschedule(const digraph<N, Comparator>& G)
+template <typename N>
+inline schedule<N> dfschedule(const digraph<N>& G)
 {
-    schedule<N, Comparator> S;
-    std::set<N, Comparator> V;  // set of visited nodes
+    schedule<N> S;
+    std::set<N> V;  // set of visited nodes
 
     // recursive deep first visit (pseudo local function using a lambda)
     std::function<void(const N&)> dfvisit = [&](const N& n) {
@@ -133,11 +132,11 @@ inline schedule<N, Comparator> dfschedule(const digraph<N, Comparator>& G)
  * @return schedule<N> the breadth first schedule of G
  */
 
-template <typename N, typename Comparator = std::less<N>>
-inline schedule<N, Comparator> bfschedule(const digraph<N, Comparator>& G)
+template <typename N>
+inline schedule<N> bfschedule(const digraph<N>& G)
 {
     std::vector<std::vector<N>> P = parallelize(G);
-    schedule<N, Comparator>     S;
+    schedule<N>                 S;
 
     for (uint64_t i = 0; i < P.size(); i++) {
         for (const N& n : P[i]) {
@@ -158,8 +157,8 @@ inline schedule<N, Comparator> bfschedule(const digraph<N, Comparator>& G)
  * @param S
  * @return int
  */
-template <typename N, typename Comparator = std::less<N>>
-inline int schedulingcost(const digraph<N, Comparator>& G, const schedule<N, Comparator>& S)
+template <typename N>
+inline int schedulingcost(const digraph<N>& G, const schedule<N>& S)
 {
     int cost = 0;
     for (const N& n : G.nodes()) {
@@ -180,13 +179,13 @@ inline int schedulingcost(const digraph<N, Comparator>& G, const schedule<N, Com
  * @param G the graph we want to schedule
  * @return schedule<N> the deep first schedule of G
  */
-template <typename N, typename Comparator = std::less<N>>
-inline schedule<N, Comparator> dfcyclesschedule(const digraph<N, Comparator>& G)
+template <typename N>
+inline schedule<N> dfcyclesschedule(const digraph<N>& G)
 {
-    digraph<digraph<N, Comparator>>  H  = graph2dag(G);
-    schedule<digraph<N, Comparator>> SH = dfschedule(H);
-    schedule<N, Comparator>          S;
-    for (const digraph<N, Comparator>& n : SH.elements()) {
+    digraph<digraph<N>>  H  = graph2dag(G);
+    schedule<digraph<N>> SH = dfschedule(H);
+    schedule<N>          S;
+    for (const digraph<N>& n : SH.elements()) {
         S.append(dfschedule(cut(n, 1)));
     }
     return S;
@@ -199,13 +198,13 @@ inline schedule<N, Comparator> dfcyclesschedule(const digraph<N, Comparator>& G)
  * @param G the graph we want to schedule
  * @return schedule<N> the deep first schedule of G
  */
-template <typename N, typename Comparator = std::less<N>>
-inline schedule<N, Comparator> bfcyclesschedule(const digraph<N, Comparator>& G)
+template <typename N>
+inline schedule<N> bfcyclesschedule(const digraph<N>& G)
 {
-    digraph<digraph<N, Comparator>>  H  = graph2dag(G);
-    schedule<digraph<N, Comparator>> SH = bfschedule(H);
-    schedule<N, Comparator>          S;
-    for (const digraph<N, Comparator>& n : SH.elements()) {
+    digraph<digraph<N>>  H  = graph2dag(G);
+    schedule<digraph<N>> SH = bfschedule(H);
+    schedule<N>          S;
+    for (const digraph<N>& n : SH.elements()) {
         S.append(dfschedule(cut(n, 1)));
     }
     return S;
diff --git a/compiler/documentator/doc.cpp b/compiler/documentator/doc.cpp
index fd317a74aa..8f45e885c1 100644
--- a/compiler/documentator/doc.cpp
+++ b/compiler/documentator/doc.cpp
@@ -319,8 +319,8 @@ static void printLatexHeader(istream& latexheader, const string& faustversion, o
 static void printDocMetadata(const Tree expr, ostream& docout)
 {
     if (gGlobal->gMetaDataSet.count(expr)) {
-        string                     sep  = "";
-        set<Tree, CTreeComparator> mset = gGlobal->gMetaDataSet[expr];
+        string    sep  = "";
+        set<Tree> mset = gGlobal->gMetaDataSet[expr];
         for (set<Tree>::iterator j = mset.begin(); j != mset.end(); j++) {
             docout << sep << unquote(tree2str(*j));
             sep = ", ";
diff --git a/compiler/draw/sigToGraph.cpp b/compiler/draw/sigToGraph.cpp
index 447d0d30bd..9c5253e7e8 100644
--- a/compiler/draw/sigToGraph.cpp
+++ b/compiler/draw/sigToGraph.cpp
@@ -38,7 +38,7 @@
 
 using namespace std;
 
-static void   recdraw(Tree sig, set<Tree, CTreeComparator>& drawn, ostream& fout);
+static void   recdraw(Tree sig, set<Tree>& drawn, ostream& fout);
 static string nodeattr(Type t);
 static string edgeattr(Type t);
 static string sigLabel(Tree sig);
@@ -48,7 +48,7 @@ static string sigLabel(Tree sig);
  */
 void sigToGraph(Tree L, ostream& fout)
 {
-    set<Tree, CTreeComparator> alreadyDrawn;
+    set<Tree> alreadyDrawn;
 
     fout << "strict digraph loopgraph {\n"
          << "    rankdir=LR; node [fontsize=10];" << endl;
@@ -70,7 +70,7 @@ void sigToGraph(Tree L, ostream& fout)
 /**
  * Draw recursively a signal
  */
-static void recdraw(Tree sig, set<Tree, CTreeComparator>& drawn, ostream& fout)
+static void recdraw(Tree sig, set<Tree>& drawn, ostream& fout)
 {
     // cerr << ++gGlobal->TABBER << "ENTER REC DRAW OF " << sig << "$" << *sig << endl;
     tvec subsig;
diff --git a/compiler/generator/code_container.cpp b/compiler/generator/code_container.cpp
index c8e5de1c0a..230d2e59c2 100644
--- a/compiler/generator/code_container.cpp
+++ b/compiler/generator/code_container.cpp
@@ -132,8 +132,7 @@ bool CodeContainer::getLoopProperty(Tree sig, CodeLoop*& l)
     return fLoopProperty.get(sig, l);
 }
 
-void CodeContainer::listAllLoopProperties(Tree sig, set<CodeLoop*>& L,
-                                          set<Tree, CTreeComparator>& visited)
+void CodeContainer::listAllLoopProperties(Tree sig, set<CodeLoop*>& L, set<Tree>& visited)
 {
     if (visited.count(sig) == 0) {
         visited.insert(sig);
@@ -179,8 +178,8 @@ void CodeContainer::closeLoop(Tree sig)
     faustassert(fCurLoop);
 
     // fix the missing dependencies
-    set<CodeLoop*>             L;
-    set<Tree, CTreeComparator> V;
+    set<CodeLoop*> L;
+    set<Tree>      V;
     listAllLoopProperties(sig, L, V);
     for (CodeLoop* l : L) {
         fCurLoop->fBackwardLoopDependencies.insert(l);
diff --git a/compiler/generator/code_container.hh b/compiler/generator/code_container.hh
index 612be408c5..e27a12409c 100644
--- a/compiler/generator/code_container.hh
+++ b/compiler/generator/code_container.hh
@@ -176,7 +176,7 @@ class CodeContainer : public virtual Garbageable {
     void printHeader(std::ostream& dst)
     {
         // defines the metadata we want to print as comments at the begin of in the file
-        std::set<Tree, CTreeComparator> selectedKeys;
+        std::set<Tree> selectedKeys;
         selectedKeys.insert(tree("name"));
         selectedKeys.insert(tree("author"));
         selectedKeys.insert(tree("copyright"));
@@ -280,9 +280,9 @@ class CodeContainer : public virtual Garbageable {
 
     void setLoopProperty(Tree sig, CodeLoop* l);   ///< Store the loop used to compute a signal
     bool getLoopProperty(Tree sig, CodeLoop*& l);  ///< Returns the loop used to compute a signal
-    void listAllLoopProperties(Tree sig, std::set<CodeLoop*>&,
-                               std::set<Tree, CTreeComparator>&
-                                   visited);  ///< Returns all the loop used to compute a signal
+    void listAllLoopProperties(
+        Tree            sig, std::set<CodeLoop*>&,
+        std::set<Tree>& visited);  ///< Returns all the loop used to compute a signal
 
     void printGraphDotFormat(std::ostream& fout);
 
diff --git a/compiler/generator/compile.cpp b/compiler/generator/compile.cpp
index 1008807aa9..09c7e7dc70 100644
--- a/compiler/generator/compile.cpp
+++ b/compiler/generator/compile.cpp
@@ -128,7 +128,7 @@ static string wdel(const string& s)
 void Compiler::generateMetaData()
 {
     // Add global metadata
-    for (map<Tree, set<Tree, CTreeComparator>>::iterator i = gGlobal->gMetaDataSet.begin();
+    for (map<Tree, set<Tree>>::iterator i = gGlobal->gMetaDataSet.begin();
          i != gGlobal->gMetaDataSet.end(); i++) {
         if (i->first != tree("author")) {
             stringstream str1, str2;
@@ -138,8 +138,7 @@ void Compiler::generateMetaData()
             string res2 = unquote(str2.str());
             fJSON.declare(res1.c_str(), res2.c_str());
         } else {
-            for (set<Tree, CTreeComparator>::iterator j = i->second.begin(); j != i->second.end();
-                 j++) {
+            for (set<Tree>::iterator j = i->second.begin(); j != i->second.end(); j++) {
                 if (j == i->second.begin()) {
                     stringstream str1, str2;
                     str1 << *(i->first);
diff --git a/compiler/generator/compile_scal.cpp b/compiler/generator/compile_scal.cpp
index 0e70bcfd3c..65548f903a 100644
--- a/compiler/generator/compile_scal.cpp
+++ b/compiler/generator/compile_scal.cpp
@@ -273,7 +273,7 @@ void ScalarCompiler::conditionStatistics(Tree l)
 
 void ScalarCompiler::conditionStatistics(Tree l)
 {
-    map<Tree, int, CTreeComparator>
+    map<Tree, int>
         fConditionStatistics;  // used with the new X,Y:enable --> sigEnable(X*Y,Y>0) primitive
     for (const auto& p : fConditionProperty) {
         for (Tree lc = p.second; !isNil(lc); lc = tl(lc)) {
diff --git a/compiler/generator/compile_scal.hh b/compiler/generator/compile_scal.hh
index a161eb8c17..aa0b9d160e 100644
--- a/compiler/generator/compile_scal.hh
+++ b/compiler/generator/compile_scal.hh
@@ -49,15 +49,15 @@ class ScalarCompiler : public Compiler {
     property<std::pair<std::string, std::string> >
         fInstanceInitProperty;  // property added to solve 20101208 kjetil bug
 
-    std::map<Tree, Tree, CTreeComparator>
+    std::map<Tree, Tree>
         fConditionProperty;  // used with the new X,Y:enable --> sigControl(X*Y,Y>0) primitive
 
-    static std::map<std::string, int>    fIDCounters;
-    Tree                                 fSharingKey;
-    OccMarkup*                           fOccMarkup;
-    int                                  fMaxIota;
-    std::map<std::string, std::string>   fIotaCache;
-    std::map<Tree, int, CTreeComparator> fScheduleOrder;
+    static std::map<std::string, int>  fIDCounters;
+    Tree                               fSharingKey;
+    OccMarkup*                         fOccMarkup;
+    int                                fMaxIota;
+    std::map<std::string, std::string> fIotaCache;
+    std::map<Tree, int>                fScheduleOrder;
 
    public:
     ScalarCompiler(const std::string& name, const std::string& super, int numInputs, int numOutputs)
diff --git a/compiler/generator/instructions_compiler.cpp b/compiler/generator/instructions_compiler.cpp
index 3fd1845003..fa378fa2c7 100644
--- a/compiler/generator/instructions_compiler.cpp
+++ b/compiler/generator/instructions_compiler.cpp
@@ -264,7 +264,7 @@ void InstructionsCompiler::conditionStatistics(Tree l)
 
 void InstructionsCompiler::conditionStatistics(Tree l)
 {
-    map<Tree, int, CTreeComparator>
+    map<Tree, int>
         fConditionStatistics;  // used with the new X,Y:enable --> sigEnable(X*Y,Y != 0) primitive
     for (const auto& p : fConditionProperty) {
         for (Tree lc = p.second; !isNil(lc); lc = tl(lc)) {
diff --git a/compiler/generator/instructions_compiler.hh b/compiler/generator/instructions_compiler.hh
index 3ee05bf68d..d3b2cd9945 100644
--- a/compiler/generator/instructions_compiler.hh
+++ b/compiler/generator/instructions_compiler.hh
@@ -49,7 +49,7 @@ class InstructionsCompiler : public virtual Garbageable {
     property<std::pair<std::string, std::string>> fInstanceInitProperty;
     property<std::string>                         fTableProperty;
 
-    std::map<Tree, Tree, CTreeComparator>
+    std::map<Tree, Tree>
         fConditionProperty;  // used with the new X,Y:enable --> sigControl(X*Y,Y>0) primitive
 
     Tree       fSharingKey;
diff --git a/compiler/generator/klass.cpp b/compiler/generator/klass.cpp
index 5795ee7a88..a16cb7e434 100644
--- a/compiler/generator/klass.cpp
+++ b/compiler/generator/klass.cpp
@@ -88,7 +88,7 @@ void Klass::openLoop(Tree recsymbol, const string& size)
     // cerr << "\nOPEN REC LOOP(" << *recsymbol << ", " << size << ") ----> " << fTopLoop << endl;
 }
 
-void Klass::listAllLoopProperties(Tree sig, set<Loop*>& L, set<Tree, CTreeComparator>& visited)
+void Klass::listAllLoopProperties(Tree sig, set<Loop*>& L, set<Tree>& visited)
 {
     if (visited.count(sig) == 0) {
         visited.insert(sig);
@@ -115,8 +115,8 @@ void Klass::closeLoop(Tree sig)
     faustassert(fTopLoop);
 
     // fix the missing dependencies
-    set<Loop*>                 L;
-    set<Tree, CTreeComparator> V;
+    set<Loop*> L;
+    set<Tree>  V;
     listAllLoopProperties(sig, L, V);
     for (Loop* l : L) {
         fTopLoop->fBackwardLoopDependencies.insert(l);
diff --git a/compiler/generator/klass.hh b/compiler/generator/klass.hh
index 699fbf3db3..b03267ee3a 100644
--- a/compiler/generator/klass.hh
+++ b/compiler/generator/klass.hh
@@ -136,9 +136,9 @@ class Klass {
 
     void setLoopProperty(Tree sig, Loop* l);   ///< Store the loop used to compute a signal
     bool getLoopProperty(Tree sig, Loop*& l);  ///< Returns the loop used to compute a signal
-    void listAllLoopProperties(Tree sig, std::set<Loop*>&,
-                               std::set<Tree, CTreeComparator>&
-                                   visited);  ///< Returns all the loop used to compute a signal
+    void listAllLoopProperties(
+        Tree            sig, std::set<Loop*>&,
+        std::set<Tree>& visited);  ///< Returns all the loop used to compute a signal
 
     const std::string& getClassName() const
     {
diff --git a/compiler/generator/occurrences.hh b/compiler/generator/occurrences.hh
index f0477bcd54..833d73c13b 100644
--- a/compiler/generator/occurrences.hh
+++ b/compiler/generator/occurrences.hh
@@ -56,9 +56,9 @@ class Occurrences : public virtual Garbageable {
  * second om.mark(root) then om.retrieve(subtree)
  */
 class OccMarkup : public virtual Garbageable {
-    Tree                                  fRootTree;    ///< occurrences computed within this tree
-    Tree                                  fPropKey;     ///< key used to store occurrences property
-    std::map<Tree, Tree, CTreeComparator> fConditions;  ///< condition associated to each tree
+    Tree                 fRootTree;    ///< occurrences computed within this tree
+    Tree                 fPropKey;     ///< key used to store occurrences property
+    std::map<Tree, Tree> fConditions;  ///< condition associated to each tree
 
     void         incOcc(Tree env, int v, int r, int d, Tree xc,
                         Tree t);                    ///< inc the occurrence of t in context v,r
@@ -67,7 +67,7 @@ class OccMarkup : public virtual Garbageable {
 
    public:
     OccMarkup() : fRootTree(nullptr), fPropKey(nullptr) {}
-    OccMarkup(std::map<Tree, Tree, CTreeComparator> conditions)
+    OccMarkup(std::map<Tree, Tree> conditions)
         : fRootTree(nullptr), fPropKey(nullptr), fConditions(conditions)
     {
     }
diff --git a/compiler/global.hh b/compiler/global.hh
index f8c8a20bec..8ddf4db0c0 100644
--- a/compiler/global.hh
+++ b/compiler/global.hh
@@ -82,9 +82,8 @@ struct comp_str {
     bool operator()(Tree s1, Tree s2) const { return (strcmp(tree2str(s1), tree2str(s2)) < 0); }
 };
 
-typedef std::map<Tree, std::set<Tree, CTreeComparator>, comp_str> MetaDataSet;
-typedef std::map<Tree, std::set<Tree, CTreeComparator>, CTreeComparator>
-    FunMDSet;  // foo -> {(file/foo/key,value)...}
+typedef std::map<Tree, std::set<Tree>, comp_str> MetaDataSet;
+typedef std::map<Tree, std::set<Tree>>           FunMDSet;  // foo -> {(file/foo/key,value)...}
 
 // Global outside of the global context
 extern std::vector<std::string> gWarningMessages;
@@ -256,7 +255,7 @@ struct global {
     bool gLstMdocTagsSwitch;      // mdoc listing management
     bool gLstDistributedSwitch;   // mdoc listing management
 
-    std::unordered_map<Tree, std::set<Tree, CTreeComparator>> gDependencies;
+    std::unordered_map<Tree, std::set<Tree>> gDependencies;
 
     bool gAutoDifferentiate;
 
@@ -292,8 +291,8 @@ struct global {
     // Tree is used to identify the same nodes during Box tree traversal,
     // but gBoxCounter is then used to generate unique IDs
 
-    std::map<Tree, std::pair<int, std::string>, CTreeComparator> gBoxTable;
-    int                                                          gBoxCounter;
+    std::map<Tree, std::pair<int, std::string>> gBoxTable;
+    int                                         gBoxCounter;
     // To keep the box tree traversing trace
     std::vector<std::string> gBoxTrace;
 
@@ -302,8 +301,8 @@ struct global {
     // ------------
     // Tree is used to identify the same nodes during Signal tree traversal,
     // but gSignalCounter is then used to generate unique IDs
-    std::map<Tree, std::pair<int, std::string>, CTreeComparator> gSignalTable;
-    int                                                          gSignalCounter;
+    std::map<Tree, std::pair<int, std::string>> gSignalTable;
+    int                                         gSignalCounter;
     // To keep the signal tree traversing trace
     std::vector<std::string> gSignalTrace;
 
@@ -544,15 +543,14 @@ struct global {
     std::map<std::string, int> gIDCounters;
 
     // Internal state during drawing
-    Occur*                          gOccurrences;
-    bool                            gFoldingFlag;     // true with complex block-diagrams
-    std::stack<Tree>                gPendingExp;      // Expressions that need to be drawn
-    std::set<Tree, CTreeComparator> gDrawnExp;        // Expressions drawn or scheduled so far
-    const char*                     gDevSuffix;       // .svg or .ps used to choose output device
-    std::string                     gSchemaFileName;  // name of schema file beeing generated
-    Tree                            gInverter[6];
-    std::map<Tree, std::string, CTreeComparator>
-        gBackLink;  // link to enclosing file for sub schema
+    Occur*                      gOccurrences;
+    bool                        gFoldingFlag;     // true with complex block-diagrams
+    std::stack<Tree>            gPendingExp;      // Expressions that need to be drawn
+    std::set<Tree>              gDrawnExp;        // Expressions drawn or scheduled so far
+    const char*                 gDevSuffix;       // .svg or .ps used to choose output device
+    std::string                 gSchemaFileName;  // name of schema file beeing generated
+    Tree                        gInverter[6];
+    std::map<Tree, std::string> gBackLink;  // link to enclosing file for sub schema
 
     // FIR
     std::map<Typed::VarType, BasicTyped*>
diff --git a/compiler/libcode.cpp b/compiler/libcode.cpp
index 9853febf25..56fd8316bb 100644
--- a/compiler/libcode.cpp
+++ b/compiler/libcode.cpp
@@ -985,7 +985,7 @@ static void generateCodeAux1(unique_ptr<ostream>& helpers, unique_ptr<ifstream>&
 static void printHeader(ostream& dst)
 {
     // defines the metadata we want to print as comments at the begin of in the C++ file
-    set<Tree, CTreeComparator> selectedKeys;
+    set<Tree> selectedKeys;
     selectedKeys.insert(tree("name"));
     selectedKeys.insert(tree("author"));
     selectedKeys.insert(tree("copyright"));
diff --git a/compiler/normalize/aterm.hh b/compiler/normalize/aterm.hh
index e894cb109c..738963561c 100644
--- a/compiler/normalize/aterm.hh
+++ b/compiler/normalize/aterm.hh
@@ -42,8 +42,7 @@
  */
 
 class aterm : public virtual Garbageable {
-    std::map<Tree, mterm, CTreeComparator>
-        fSig2MTerms;  ///< mapping between signatures and corresponding mterms
+    std::map<Tree, mterm> fSig2MTerms;  ///< mapping between signatures and corresponding mterms
 
    public:
     aterm();        ///< create an empty aterm (equivalent to 0)
diff --git a/compiler/normalize/mterm.hh b/compiler/normalize/mterm.hh
index ecb85e9662..e98dc47c80 100644
--- a/compiler/normalize/mterm.hh
+++ b/compiler/normalize/mterm.hh
@@ -41,8 +41,8 @@
  */
 
 class mterm : public virtual Garbageable {
-    Tree                                 fCoef;     ///< constant part of the term (usually 1 or -1)
-    std::map<Tree, int, CTreeComparator> fFactors;  ///< non constant terms and their power
+    Tree                fCoef;     ///< constant part of the term (usually 1 or -1)
+    std::map<Tree, int> fFactors;  ///< non constant terms and their power
 
    public:
     mterm();                ///< create a 0 mterm
diff --git a/compiler/parser/sourcereader.cpp b/compiler/parser/sourcereader.cpp
index 2fc58eca9c..891091a470 100644
--- a/compiler/parser/sourcereader.cpp
+++ b/compiler/parser/sourcereader.cpp
@@ -75,7 +75,7 @@ extern const char* FAUSTfilename;
 
 static bool standardArgList(Tree args)
 {
-	map<Tree, int, CTreeComparator> L;
+	map<Tree, int> L;
 	while (isList(args)) {
 		if (!isBoxIdent(hd(args))) return false;
 		if (++L[hd(args)] > 1) return false;
@@ -434,8 +434,8 @@ Tree SourceReader::expandRec(Tree ldef, set<string>& visited, Tree lresult)
 
 Tree formatDefinitions(Tree rldef)
 {
-    map<Tree, list<Tree>, CTreeComparator> dic;
-    map<Tree, list<Tree> , CTreeComparator>::iterator p;
+    map<Tree, list<Tree>> dic;
+    map<Tree, list<Tree> >::iterator p;
     Tree ldef2 = gGlobal->nil;
     Tree file;
 
diff --git a/compiler/signals/recursivness.cpp b/compiler/signals/recursivness.cpp
index b452304e10..8dc8852bc5 100644
--- a/compiler/signals/recursivness.cpp
+++ b/compiler/signals/recursivness.cpp
@@ -141,7 +141,7 @@ static int position(Tree env, Tree t, int p)
  * @param sig the signal to analyze
  * @return the set of symbols
  */
-static Tree symlistVisit(Tree sig, set<Tree, CTreeComparator>& visited)
+static Tree symlistVisit(Tree sig, set<Tree>& visited)
 {
     Tree S;
 
@@ -180,7 +180,7 @@ Tree symlist(Tree sig)
     Tree S;
 
     if (!gGlobal->gSymListProp->get(sig, S)) {
-        set<Tree, CTreeComparator> visited;
+        set<Tree> visited;
         S = symlistVisit(sig, visited);
         gGlobal->gSymListProp->set(sig, S);
     }
diff --git a/compiler/tlib/tree.hh b/compiler/tlib/tree.hh
index f92b0ea55e..eabcee300f 100644
--- a/compiler/tlib/tree.hh
+++ b/compiler/tlib/tree.hh
@@ -84,6 +84,17 @@ typedef CTree* Tree;
 
 typedef std::vector<Tree> tvec;
 
+namespace std {
+
+// The std::less <CTree*>comparison function is redefined to provide an unique and stable ordering
+// for all CTree instances and so maintain determinism.
+template <>
+struct less<CTree*> {
+    bool operator()(const CTree* lhs, const CTree* rhs) const;
+};
+
+} 
+
 /**
  * A CTree = (Node x [CTree]) is the association of a content Node and a list of subtrees
  * called branches. In order to maximize the sharing of trees, hashconsing techniques are used.
@@ -107,17 +118,10 @@ class LIBFAUST_API CTree : public virtual Garbageable {
 
    public:
     static bool gDetails;  ///< CTree::print() print with more details when true
-    static unsigned int
-        gVisitTime;  ///< Should be incremented for each new visit to keep track of visited tree
-
-    struct TreeComparator {
-        bool operator()(const Tree& lhs, const Tree& rhs) const
-        {
-            return lhs->serial() < rhs->serial();
-        }
-    };
+    ///< Should be incremented for each new visit to keep track of visited tree
+    static unsigned int gVisitTime;
 
-    typedef std::map<Tree, Tree, TreeComparator> plist;
+    typedef std::map<Tree, Tree> plist;
 
    protected:
     // fields
@@ -134,11 +138,12 @@ class LIBFAUST_API CTree : public virtual Garbageable {
     CTree() : fNext(nullptr), fType(nullptr), fHashKey(0), fSerial(0), fAperture(0), fVisitTime(0)
     {
     }
-    CTree(size_t hk, const Node& n,
-          const tvec& br);  ///< construction is private, uses tree::make instead
+    ///< construction is private, uses tree::make instead
+    CTree(size_t hk, const Node& n, const tvec& br);
+
+    ///< used to check if an equivalent tree already exists
+    bool equiv(const Node& n, const tvec& br) const;
 
-    bool          equiv(const Node& n,
-                        const tvec& br) const;  ///< used to check if an equivalent tree already exists
     static size_t calcTreeHash(
         const Node& n,
         const tvec& br);  ///< compute the hash key of a tree according to its node and branches
@@ -198,7 +203,14 @@ class LIBFAUST_API CTree : public virtual Garbageable {
     }
 };
 
-using CTreeComparator = CTree::TreeComparator;
+// The comparison function relies on lhs->serial() which provides an unique and stable ordering
+// for all CTree instances and so maintain determinism.
+namespace std {
+inline bool less<CTree*>::operator()(const CTree* lhs, const CTree* rhs) const
+{
+    return lhs->serial() < rhs->serial();
+}
+};
 
 //---------------------------------API---------------------------------------
 // To build trees
diff --git a/compiler/transform/sigDependenciesGraph.cpp b/compiler/transform/sigDependenciesGraph.cpp
index 6b5a6fa22f..d99a32bf4a 100644
--- a/compiler/transform/sigDependenciesGraph.cpp
+++ b/compiler/transform/sigDependenciesGraph.cpp
@@ -11,8 +11,8 @@
  */
 class SigDependenciesGraph : public SignalVisitor {
    protected:
-    digraph<Tree, CTreeComparator> fGraph;
-    bool                           fFullGraph;
+    digraph<Tree> fGraph;
+    bool          fFullGraph;
 
    public:
     SigDependenciesGraph(bool full) : SignalVisitor(), fFullGraph(full)
@@ -21,7 +21,7 @@ class SigDependenciesGraph : public SignalVisitor {
         fMessage = "SigDependenciesGraph";
     }
 
-    digraph<Tree, CTreeComparator> getGraph() { return fGraph; }
+    digraph<Tree> getGraph() { return fGraph; }
 
    protected:
     void visit(Tree t) override;
@@ -124,9 +124,9 @@ void SigDependenciesGraph::visit(Tree t)
  * of a list of signals
  *
  * @param L list of signals
- * @return digraph<Tree, CTreeComparator>
+ * @return digraph<Tree>
  */
-digraph<Tree, CTreeComparator> immediateGraph(Tree L)
+digraph<Tree> immediateGraph(Tree L)
 {
     SigDependenciesGraph g(false);
     g.mapself(L);
@@ -137,9 +137,9 @@ digraph<Tree, CTreeComparator> immediateGraph(Tree L)
  * @brief Compute the full Graph (all dependencies) of a list of signals
  *
  * @param L list of signals
- * @return digraph<Tree, CTreeComparator>
+ * @return digraph<Tree>
  */
-digraph<Tree, CTreeComparator> fullGraph(Tree L)
+digraph<Tree> fullGraph(Tree L)
 {
     SigDependenciesGraph g(true);
     g.mapself(L);
@@ -154,6 +154,6 @@ digraph<Tree, CTreeComparator> fullGraph(Tree L)
  */
 std::vector<Tree> compilationOrder(Tree L)
 {
-    digraph<Tree, CTreeComparator> G = immediateGraph(L);
+    digraph<Tree> G = immediateGraph(L);
     return serialize(G);
 }
diff --git a/compiler/transform/sigDependenciesGraph.hh b/compiler/transform/sigDependenciesGraph.hh
index 617e7eea5a..cf464c3892 100644
--- a/compiler/transform/sigDependenciesGraph.hh
+++ b/compiler/transform/sigDependenciesGraph.hh
@@ -9,7 +9,7 @@
  * @param L list of signals
  * @return digraph<Tree>
  */
-digraph<Tree, CTreeComparator> immediateGraph(Tree L);
+digraph<Tree> immediateGraph(Tree L);
 
 /**
  * @brief Compute the full Graph of a list of signals
@@ -17,7 +17,7 @@ digraph<Tree, CTreeComparator> immediateGraph(Tree L);
  * @param L list of signals
  * @return digraph<Tree>
  */
-digraph<Tree, CTreeComparator> fullGraph(Tree L);
+digraph<Tree> fullGraph(Tree L);
 
 /**
  * @brief Compute in which order the list of signals L should be compiled
diff --git a/compiler/transform/sigNewConstantPropagation.cpp b/compiler/transform/sigNewConstantPropagation.cpp
index bc81f3ba79..2ce6cc8385 100644
--- a/compiler/transform/sigNewConstantPropagation.cpp
+++ b/compiler/transform/sigNewConstantPropagation.cpp
@@ -40,9 +40,9 @@ class SigNewConstantPropagation final : public SignalIdentity {
 };
 static void explainInterval(Tree sig)
 {
-    digraph<Tree, CTreeComparator>  G = fullGraph(list1(sig));
-    schedule<Tree, CTreeComparator> S = dfcyclesschedule(G);
-    int                             i = 0;
+    digraph<Tree>  G = fullGraph(list1(sig));
+    schedule<Tree> S = dfcyclesschedule(G);
+    int            i = 0;
     std::cerr << "\n\n EXPLAIN INTERVAL: " << getCertifiedSigType(sig)->getInterval()
               << " FOR SIGNAL " << sig << " = " << ppsig(sig, 10) << std::endl;
     for (Tree s : S.elements()) {
diff --git a/compiler/transform/sigRecursiveDependencies.cpp b/compiler/transform/sigRecursiveDependencies.cpp
index dc239f8fec..23d82fd2fc 100644
--- a/compiler/transform/sigRecursiveDependencies.cpp
+++ b/compiler/transform/sigRecursiveDependencies.cpp
@@ -59,9 +59,9 @@
  *
  * @param underVisit, stack of projections under visit (prevent infinite loops)
  * @param sig
- * @return std::set<Tree, CTreeComparator> set of dependencies of sig
+ * @return std::set<Tree> set of dependencies of sig
  */
-static std::set<Tree, CTreeComparator> sigDependencies(std::vector<Tree>& underVisit, Tree sig)
+static std::set<Tree> sigDependencies(std::vector<Tree>& underVisit, Tree sig)
 {
     int  i;
     Tree rec, id, le;
@@ -70,7 +70,7 @@ static std::set<Tree, CTreeComparator> sigDependencies(std::vector<Tree>& underV
         return gGlobal->gDependencies[sig];
     } else if (isProj(sig, &i, rec)) {
         // 2) sig is a projection, its dependencies are itself and the dependecies of its definition
-        std::set<Tree, CTreeComparator> deps;
+        std::set<Tree> deps;
         if (std::find(underVisit.begin(), underVisit.end(), sig) == underVisit.end()) {
             // we mark the projection under visit and compute the dependencies of its definition
             underVisit.push_back(sig);
@@ -85,9 +85,9 @@ static std::set<Tree, CTreeComparator> sigDependencies(std::vector<Tree>& underV
     } else {
         // 3) sig is not a projection but is any other expression,
         // its dependencies are the dependencies of its branches
-        std::set<Tree, CTreeComparator> deps;
+        std::set<Tree> deps;
         for (Tree b : sig->branches()) {
-            std::set<Tree, CTreeComparator> depsb = sigDependencies(underVisit, b);
+            std::set<Tree> depsb = sigDependencies(underVisit, b);
             deps.insert(depsb.begin(), depsb.end());
         }
         gGlobal->gDependencies[sig] = deps;
@@ -99,9 +99,9 @@ static std::set<Tree, CTreeComparator> sigDependencies(std::vector<Tree>& underV
  * @brief compute the set of recursive dependencies of a signal
  *
  * @param sig
- * @return std::set<Tree, CTreeComparator>
+ * @return std::set<Tree>
  */
-std::set<Tree, CTreeComparator> signalDependencies(Tree sig)
+std::set<Tree> signalDependencies(Tree sig)
 {
     std::vector<Tree> underVisit;
     return sigDependencies(underVisit, sig);
@@ -117,8 +117,8 @@ std::set<Tree, CTreeComparator> signalDependencies(Tree sig)
  */
 bool isSignalRecursive(Tree proj)
 {
-    std::set<Tree, CTreeComparator> deps   = signalDependencies(getProjDefinition(proj));
-    bool                            answer = deps.find(proj) != deps.end();
+    std::set<Tree> deps   = signalDependencies(getProjDefinition(proj));
+    bool           answer = deps.find(proj) != deps.end();
 #if 0
     if (answer) {
         std::cerr << "\nSignal " << *proj << " is recursive. Its dependencies are: (";
@@ -147,8 +147,8 @@ bool isSignalRecursive(Tree proj)
  */
 bool isDependingOn(Tree sig, Tree proj)
 {
-    std::set<Tree, CTreeComparator> deps   = signalDependencies(sig);
-    bool                            answer = deps.find(proj) != deps.end();
+    std::set<Tree> deps   = signalDependencies(sig);
+    bool           answer = deps.find(proj) != deps.end();
     return answer;
 }
 
@@ -192,7 +192,7 @@ Tree getProjFinalDefinition(Tree proj)
  */
 void printDependencies(const std::string& msg, Tree sig)
 {
-    std::set<Tree, CTreeComparator> deps = signalDependencies(sig);
+    std::set<Tree> deps = signalDependencies(sig);
     std::cerr << msg << " dependencies of " << ppsig(sig, 20) << " are: (";
     for (Tree d : deps) {
         std::cerr << *d << " ";
diff --git a/compiler/transform/sigRecursiveDependencies.hh b/compiler/transform/sigRecursiveDependencies.hh
index 19d56b1209..c5f8d6d89e 100644
--- a/compiler/transform/sigRecursiveDependencies.hh
+++ b/compiler/transform/sigRecursiveDependencies.hh
@@ -42,7 +42,7 @@
  * @param sig
  * @return std::set<Tree>
  */
-std::set<Tree, CTreeComparator> signalDependencies(Tree sig);
+std::set<Tree> signalDependencies(Tree sig);
 
 /**
  * @brief true if signal is a recursive projection that depends on itself, false otherwise
diff --git a/compiler/transform/signalRenderer.hh b/compiler/transform/signalRenderer.hh
index b82eb2e1ac..4faf27a3d3 100644
--- a/compiler/transform/signalRenderer.hh
+++ b/compiler/transform/signalRenderer.hh
@@ -120,11 +120,11 @@ struct SignalRenderer : public SignalVisitor {
      * @tparam REAL
      */
     struct SignalBuilder : public SignalVisitor {
-        std::map<Tree, DelayedSig<int>, CTreeComparator>&  fIntDelays;
-        std::map<Tree, DelayedSig<REAL>, CTreeComparator>& fRealDelays;
-        std::map<Tree, inputControl, CTreeComparator>&     fInputControls;
-        std::map<Tree, outputControl, CTreeComparator>&    fOutputControls;
-        int&                                               fNumInputs;
+        std::map<Tree, DelayedSig<int>>&  fIntDelays;
+        std::map<Tree, DelayedSig<REAL>>& fRealDelays;
+        std::map<Tree, inputControl>&     fInputControls;
+        std::map<Tree, outputControl>&    fOutputControls;
+        int&                              fNumInputs;
 
         void allocateDelayLine(Tree x, Tree y)
         {
@@ -150,10 +150,10 @@ struct SignalRenderer : public SignalVisitor {
             }
         }
 
-        SignalBuilder(std::map<Tree, DelayedSig<int>, CTreeComparator>&  int_delays,
-                      std::map<Tree, DelayedSig<REAL>, CTreeComparator>& real_delays,
-                      std::map<Tree, inputControl, CTreeComparator>&     inputs_control,
-                      std::map<Tree, outputControl, CTreeComparator>& outputs_control, int& inputs)
+        SignalBuilder(std::map<Tree, DelayedSig<int>>&  int_delays,
+                      std::map<Tree, DelayedSig<REAL>>& real_delays,
+                      std::map<Tree, inputControl>&     inputs_control,
+                      std::map<Tree, outputControl>& outputs_control, int& inputs)
             : fIntDelays(int_delays),
               fRealDelays(real_delays),
               fInputControls(inputs_control),
@@ -245,18 +245,18 @@ struct SignalRenderer : public SignalVisitor {
         }
     }
 
-    bool             fVisitGen{false};  // wether to visit gen signal for tables
-    std::stack<Node> fValueStack;
-    std::map<Tree, DelayedSig<int>, CTreeComparator>  fIntDelays;
-    std::map<Tree, DelayedSig<REAL>, CTreeComparator> fRealDelays;
-    std::map<Tree, inputControl, CTreeComparator>     fInputControls;
-    std::map<Tree, outputControl, CTreeComparator>    fOutputControls;
-    int                                               fNumInputs  = 0;
-    int                                               fSampleRate = -1;
-    int                                               fSample     = 0;
-    int                                               fIOTA       = 0;
-    FAUSTFLOAT**                                      fInputs     = nullptr;
-    Tree                                              fOutputSig;
+    bool                             fVisitGen{false};  // wether to visit gen signal for tables
+    std::stack<Node>                 fValueStack;
+    std::map<Tree, DelayedSig<int>>  fIntDelays;
+    std::map<Tree, DelayedSig<REAL>> fRealDelays;
+    std::map<Tree, inputControl>     fInputControls;
+    std::map<Tree, outputControl>    fOutputControls;
+    int                              fNumInputs  = 0;
+    int                              fSampleRate = -1;
+    int                              fSample     = 0;
+    int                              fIOTA       = 0;
+    FAUSTFLOAT**                     fInputs     = nullptr;
+    Tree                             fOutputSig;
 
     void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs);
 
diff --git a/compiler/transform/treeTraversal.hh b/compiler/transform/treeTraversal.hh
index f16dc50403..6bdf754759 100644
--- a/compiler/transform/treeTraversal.hh
+++ b/compiler/transform/treeTraversal.hh
@@ -50,7 +50,7 @@ class TreeTraversal : public Garbageable {
     explicit TreeTraversal(const std::string& msg = "TreeTraversal") : fMessage(msg) {}
     virtual ~TreeTraversal() = default;
 
-    std::map<Tree, int, CTreeComparator> fVisited;  // visiting counter
+    std::map<Tree, int> fVisited;  // visiting counter
 
     virtual void self(Tree t)
     {