diff --git a/include/aidge/operator/Add.hpp b/include/aidge/operator/Add.hpp
index 0c285402929ab7b071d732180891de1b738dc4a8..c53cd7a5383bf6075e8cb5f4fa7869958dedee54 100644
--- a/include/aidge/operator/Add.hpp
+++ b/include/aidge/operator/Add.hpp
@@ -30,7 +30,7 @@ namespace Aidge {
 class Add_Op : public OperatorTensor,
     public Registrable<Add_Op, std::string, std::unique_ptr<OperatorImpl>(const Add_Op&)> {
 public:
-    static constexpr const char* Type = "Add";
+    static const std::string Type;
 
     Add_Op(const IOIndex_t nbIn)
         : OperatorTensor(Type, nbIn, 0, 1)
@@ -86,10 +86,10 @@ public:
         }
     }
 
-    static const std::vector<std::string> getInputsName(){
+    static const std::vector<std::string> getInputsName() {
         return {"data_input_0", "data_input_n"};
     }
-    static const std::vector<std::string> getOutputsName(){
+    static const std::vector<std::string> getOutputsName() {
         return {"data_output"};
     }
 };
diff --git a/include/aidge/operator/AvgPooling.hpp b/include/aidge/operator/AvgPooling.hpp
index f0f9f6c54ed1953ed31b713ce19edc7a8e594d4a..64f583ac243d2e9d28b49aa3e61406917870d82f 100644
--- a/include/aidge/operator/AvgPooling.hpp
+++ b/include/aidge/operator/AvgPooling.hpp
@@ -36,7 +36,7 @@ class AvgPooling_Op : public OperatorTensor,
                                        std::array<DimSize_t, DIM>> {
 
 public:
-    static constexpr const char *Type = "AvgPooling";
+    static const std::string Type;
 
     AvgPooling_Op() = delete;
 
@@ -146,6 +146,9 @@ public:
     }
 };
 
+template <DimIdx_t DIM>
+const std::string AvgPooling_Op<DIM>::Type = "AvgPooling";
+
 template <std::array<DimSize_t, 1>::size_type DIM>
 inline std::shared_ptr<Node> AvgPooling(const std::array<DimSize_t, DIM> &kernel_dims,
                                            const std::string& name = "",
diff --git a/include/aidge/operator/BatchNorm.hpp b/include/aidge/operator/BatchNorm.hpp
index 09a9bb9efac81431673ef3449f717fbcb9af5108..3613aa12b9623652555ed3411b3d89e104721623 100644
--- a/include/aidge/operator/BatchNorm.hpp
+++ b/include/aidge/operator/BatchNorm.hpp
@@ -33,7 +33,7 @@ class BatchNorm_Op : public OperatorTensor,
                 public Registrable<BatchNorm_Op<DIM>, std::string, std::unique_ptr<OperatorImpl>(const BatchNorm_Op<DIM> &)>,
                 public StaticAttributes<BatchNormAttr, float, float> {
 public:
-    static constexpr const char *Type = "BatchNorm";
+    static const std::string Type;
 
     BatchNorm_Op() = delete;
 
@@ -113,6 +113,9 @@ public:
     }
 };
 
+template <DimIdx_t DIM>
+const std::string BatchNorm_Op<DIM>::Type = "BatchNorm";
+
 template <DimSize_t DIM>
 inline std::shared_ptr<Node> BatchNorm(const float epsilon = 1.0e-5F,
                                        const float momentum = 0.1F,
diff --git a/include/aidge/operator/Concat.hpp b/include/aidge/operator/Concat.hpp
index 01d590aa7425cb62ab665c0078019a6c8ab4a66a..391191f668ca99c705d22434d5bb798863b35430 100644
--- a/include/aidge/operator/Concat.hpp
+++ b/include/aidge/operator/Concat.hpp
@@ -32,7 +32,7 @@ class Concat_Op : public OperatorTensor,
     public Registrable<Concat_Op, std::string, std::unique_ptr<OperatorImpl>(const Concat_Op&)>,
     public StaticAttributes<ConcatAttr, DimSize_t> {
 public:
-    static constexpr const char* Type = "Concat";
+    static const std::string Type;
 
     using Attributes_ = StaticAttributes<ConcatAttr, DimSize_t>;
     template <ConcatAttr e>
diff --git a/include/aidge/operator/Conv.hpp b/include/aidge/operator/Conv.hpp
index 4f0fb1ea2717c1fdf4443c450000ec3a56bb9b5b..8129e49f083032f5781f169605b02dc3140bff12 100644
--- a/include/aidge/operator/Conv.hpp
+++ b/include/aidge/operator/Conv.hpp
@@ -36,7 +36,7 @@ class Conv_Op : public OperatorTensor,
                                        DimSize_t, std::array<DimSize_t, DIM>> {
 
 public:
-    static constexpr const char *Type = "Conv";
+    static const std::string Type;
 
     Conv_Op() = delete;
 
@@ -186,6 +186,9 @@ public:
     }
 };
 
+template <DimIdx_t DIM>
+const std::string Conv_Op<DIM>::Type = "Conv";
+
 template <std::array<DimSize_t, 1>::size_type DIM>
 inline std::shared_ptr<Node> Conv(DimSize_t inChannels,
                                   DimSize_t outChannels,
diff --git a/include/aidge/operator/ConvDepthWise.hpp b/include/aidge/operator/ConvDepthWise.hpp
index ca6401e0ed3ac888f12858853f0d8f494c226041..98ecfa8c8a85e60d8136af6cd5cc04a24c601124 100644
--- a/include/aidge/operator/ConvDepthWise.hpp
+++ b/include/aidge/operator/ConvDepthWise.hpp
@@ -37,7 +37,7 @@ class ConvDepthWise_Op : public OperatorTensor,
                                        DimSize_t,
                                        std::array<DimSize_t, DIM>> {
 public:
-    static constexpr const char *Type = "ConvDepthWise";
+    static const std::string Type;
 
     ConvDepthWise_Op() = delete;
 
@@ -168,6 +168,9 @@ public:
     }
 };
 
+template <DimIdx_t DIM>
+const std::string ConvDepthWise_Op<DIM>::Type = "ConvDepthWise";
+
 template <std::array<DimSize_t, 1>::size_type DIM>
 inline std::shared_ptr<Node> ConvDepthWise(const DimSize_t nbChannels,
                                            const std::array<DimSize_t, DIM> &kernelDims,
diff --git a/include/aidge/operator/Div.hpp b/include/aidge/operator/Div.hpp
index ba76c0bdecfaf86644a3336a1076064b96b36046..a3c0eca6721ad5a46c4d6618b0692f5452e9ea44 100644
--- a/include/aidge/operator/Div.hpp
+++ b/include/aidge/operator/Div.hpp
@@ -29,7 +29,7 @@ class Div_Op : public OperatorTensor,
     public Registrable<Div_Op, std::string, std::unique_ptr<OperatorImpl>(const Div_Op&)> {
 
 public:
-    static constexpr const char* Type = "Div";
+    static const std::string Type;
 
     Div_Op() : OperatorTensor(Type, 2, 0, 1) {}
 
diff --git a/include/aidge/operator/FC.hpp b/include/aidge/operator/FC.hpp
index 4cece292cb322c0a58f96380eb0f0083771d3c19..764642f4916319f4073aa5bb1317ceb646c6dbc0 100644
--- a/include/aidge/operator/FC.hpp
+++ b/include/aidge/operator/FC.hpp
@@ -35,7 +35,7 @@ class FC_Op : public OperatorTensor,
                                  std::unique_ptr<OperatorImpl>(const FC_Op &)>,
               public StaticAttributes<FCAttr, DimSize_t, bool> {
 public:
-    static constexpr const char* Type = "FC";
+    static const std::string Type;
 
     FC_Op() = delete;
 
diff --git a/include/aidge/operator/GenericOperator.hpp b/include/aidge/operator/GenericOperator.hpp
index 505c5344990453c8f4ab84fa3893e75b216d7a54..0d0008c6307cd98fd5bba3d3480e7d225c70aa01 100644
--- a/include/aidge/operator/GenericOperator.hpp
+++ b/include/aidge/operator/GenericOperator.hpp
@@ -36,7 +36,7 @@ private:
     ComputeDimsFunc mComputeOutputDims;
 
 public:
-    GenericOperator_Op(const char *type, IOIndex_t nbData, IOIndex_t nbParam, IOIndex_t nbOut)
+    GenericOperator_Op(const std::string& type, IOIndex_t nbData, IOIndex_t nbParam, IOIndex_t nbOut)
         : OperatorTensor(type, nbData, nbParam, nbOut)
     {}
 
@@ -125,7 +125,7 @@ public:
  * @param name (optional) name of the Operator.
  * @return std::shared_ptr<Node> Node associated with the Generic Operator.
  */
-inline std::shared_ptr<Node> GenericOperator(const char *type, IOIndex_t nbData, IOIndex_t nbParam, IOIndex_t nbOut,
+inline std::shared_ptr<Node> GenericOperator(const std::string& type, IOIndex_t nbData, IOIndex_t nbParam, IOIndex_t nbOut,
                                              const std::string& name = "") {
     return std::make_shared<Node>(std::make_shared<GenericOperator_Op>(type, nbData, nbParam, nbOut), name);
 }
diff --git a/include/aidge/operator/Identity.hpp b/include/aidge/operator/Identity.hpp
index c5cd9bb62e0097c9a0e646caaf14cddd73bf512d..c0be78646f7dccf732c49e4aea45bf139b49ad9e 100644
--- a/include/aidge/operator/Identity.hpp
+++ b/include/aidge/operator/Identity.hpp
@@ -37,7 +37,7 @@ namespace Aidge {
 class Identity_Op : public OperatorTensor,
     public Registrable<Identity_Op, std::string, std::unique_ptr<OperatorImpl>(const Identity_Op&)> {
 public:
-    static constexpr const char* Type = "Identity";
+    static const std::string Type;
 
     Identity_Op()
             : OperatorTensor(Type, 1, 0, 0)
@@ -105,9 +105,11 @@ public:
     }
     void setBackend(const std::string& name) override final {
         // setBackend do nothing, Identity node has no backend it just pass the same Tensor
+        (void) name;
     }
     void setDataType(const DataType& dataType) const override final {
         // setDatatype do nothing, Identity node has no backend it just pass the same Tensor
+        (void) dataType;
     }
 
     static const std::vector<std::string> getInputsName(){
diff --git a/include/aidge/operator/LeakyReLU.hpp b/include/aidge/operator/LeakyReLU.hpp
index 800c8c61d876b6f33cce1af3365179b7eb14b68d..eee5733326efbd8b9cbb475e2b45a779df7a0cdf 100644
--- a/include/aidge/operator/LeakyReLU.hpp
+++ b/include/aidge/operator/LeakyReLU.hpp
@@ -33,7 +33,7 @@ class LeakyReLU_Op : public OperatorTensor,
     public Registrable<LeakyReLU_Op, std::string, std::unique_ptr<OperatorImpl>(const LeakyReLU_Op&)>,
     public StaticAttributes<LeakyReLUAttr, float> {
 public:
-    static constexpr const char* Type = "LeakyReLU";
+    static const std::string Type;
 
     LeakyReLU_Op() = delete;
 
diff --git a/include/aidge/operator/MatMul.hpp b/include/aidge/operator/MatMul.hpp
index 23c12d45802e25f29891c48164acfb2d3ad137ac..cf9305d0df9433a189f14608fbe36141f251adec 100644
--- a/include/aidge/operator/MatMul.hpp
+++ b/include/aidge/operator/MatMul.hpp
@@ -35,7 +35,7 @@ class MatMul_Op : public OperatorTensor,
                                  std::unique_ptr<OperatorImpl>(const MatMul_Op &)>,
               public StaticAttributes<MatMulAttr, DimSize_t> {
 public:
-    static constexpr const char* Type = "MatMul";
+    static const std::string Type;
 
     MatMul_Op() = delete;
 
diff --git a/include/aidge/operator/MaxPooling.hpp b/include/aidge/operator/MaxPooling.hpp
index ad50a27a94a2217c94445fb556c84ec7f121c6b9..4235aee0ba944b68413e00558dc2c77cea77f04a 100644
--- a/include/aidge/operator/MaxPooling.hpp
+++ b/include/aidge/operator/MaxPooling.hpp
@@ -36,7 +36,7 @@ class MaxPooling_Op : public OperatorTensor,
                                        std::array<DimSize_t, DIM>,
                                        bool> {
 public:
-    static constexpr const char *Type = "MaxPooling";
+    static const std::string Type;
 
     MaxPooling_Op() = delete;
 
@@ -120,6 +120,9 @@ public:
     }
 };
 
+template <DimIdx_t DIM>
+const std::string MaxPooling_Op<DIM>::Type = "MaxPooling";
+
 template <std::array<DimSize_t, 1>::size_type DIM>
 inline std::shared_ptr<Node> MaxPooling(const std::array<DimSize_t, DIM> &kernel_dims,
                                            const std::string& name = "",
diff --git a/include/aidge/operator/Mul.hpp b/include/aidge/operator/Mul.hpp
index 5b9ab4eb8c3924133f32ddfeb0a5f05963381771..01b199e4ecce3508f58447419f35d23bed5fcf5c 100644
--- a/include/aidge/operator/Mul.hpp
+++ b/include/aidge/operator/Mul.hpp
@@ -31,7 +31,7 @@ namespace Aidge {
 class Mul_Op : public OperatorTensor,
     public Registrable<Mul_Op, std::string, std::unique_ptr<OperatorImpl>(const Mul_Op&)> {
 public:
-    static constexpr const char* Type = "Mul";
+    static const std::string Type;
 
     Mul_Op() : OperatorTensor(Type, 2, 0, 1) {}
 
diff --git a/include/aidge/operator/Operator.hpp b/include/aidge/operator/Operator.hpp
index b0f8435bd0126cf3fba9f956a432017585a4d873..1fd8172b5a5fcb4efc8cb1c7db5941a548f94d00 100644
--- a/include/aidge/operator/Operator.hpp
+++ b/include/aidge/operator/Operator.hpp
@@ -44,7 +44,7 @@ private:
 
 public:
     Operator() = delete;
-    Operator(const char* type, const IOIndex_t nbData, const IOIndex_t nbParam, const IOIndex_t nbOut, const OperatorType operatorType = OperatorType::Data)
+    Operator(const std::string& type, const IOIndex_t nbData, const IOIndex_t nbParam, const IOIndex_t nbOut, const OperatorType operatorType = OperatorType::Data)
     : mType(type),
       mOperatorType(operatorType),
       mNbData(nbData),
diff --git a/include/aidge/operator/OperatorTensor.hpp b/include/aidge/operator/OperatorTensor.hpp
index a55d7ac2842f948d923f9e1e54d2ffed1fd0f954..218a380f2b5b3014fba4053363f94fda13b6e47a 100644
--- a/include/aidge/operator/OperatorTensor.hpp
+++ b/include/aidge/operator/OperatorTensor.hpp
@@ -40,7 +40,7 @@ protected:
 public:
     OperatorTensor() = delete;
 
-    OperatorTensor(const char* type, const IOIndex_t nbData, const IOIndex_t nbParam,
+    OperatorTensor(const std::string& type, const IOIndex_t nbData, const IOIndex_t nbParam,
                    const IOIndex_t nbOut)
         : Operator(type, nbData, nbParam, nbOut, OperatorType::Tensor),
           mInputs(std::vector<std::shared_ptr<Tensor>>(nbData + nbParam, nullptr)),
diff --git a/include/aidge/operator/Pad.hpp b/include/aidge/operator/Pad.hpp
index 279b8b3d2c173d18c65c17e50385954a88fde77e..38829bab613981565bc20b88e299fa1e197f1c08 100644
--- a/include/aidge/operator/Pad.hpp
+++ b/include/aidge/operator/Pad.hpp
@@ -37,7 +37,7 @@ class Pad_Op : public OperatorTensor,
                                        PadBorderType,
                                        double> {
 public:
-    static constexpr const char *Type = "Pad";
+    static const std::string Type;
 
     Pad_Op() = delete;
 
@@ -113,6 +113,9 @@ public:
     }
 };
 
+template <DimIdx_t DIM>
+const std::string Pad_Op<DIM>::Type = "Pad";
+
 template <std::array<DimSize_t, 1>::size_type DIM>
 inline std::shared_ptr<Node> Pad(const std::array<DimSize_t, 2*DIM> &beginEndTuples,
                                            const std::string& name = "",
diff --git a/include/aidge/operator/Pow.hpp b/include/aidge/operator/Pow.hpp
index 0b0ae82f012eace8b5a2d5eb362a359386495b79..97bad75dc9ca46d274def78ed79e56fab0c46b89 100644
--- a/include/aidge/operator/Pow.hpp
+++ b/include/aidge/operator/Pow.hpp
@@ -29,7 +29,7 @@ namespace Aidge {
 class Pow_Op : public OperatorTensor,
     public Registrable<Pow_Op, std::string, std::unique_ptr<OperatorImpl>(const Pow_Op&)> {
 public:
-    static constexpr const char* Type = "Pow";
+    static const std::string Type;
 
     Pow_Op() : OperatorTensor(Type, 2, 0, 1) {}
 
diff --git a/include/aidge/operator/Producer.hpp b/include/aidge/operator/Producer.hpp
index fb6a20403adc1ee5cddb5869fd9d39ef59fb776e..d6060dd6c036d515611d62fbd071c0a7430ae5e8 100644
--- a/include/aidge/operator/Producer.hpp
+++ b/include/aidge/operator/Producer.hpp
@@ -29,7 +29,7 @@ class Producer_Op
       public Registrable<Producer_Op, std::string, std::unique_ptr<OperatorImpl>(
                                           const Producer_Op &)> {
 public:
-    static constexpr const char* Type = "Producer";
+    static const std::string Type;
 
     template <std::size_t DIM>
     Producer_Op(const std::array<DimSize_t, DIM>& dims)
diff --git a/include/aidge/operator/ReLU.hpp b/include/aidge/operator/ReLU.hpp
index 3444c25fc2e1572e78a1377b3273580f494ac8f9..825e86f47bdbf016a43afbca89d140e0e170fc7c 100644
--- a/include/aidge/operator/ReLU.hpp
+++ b/include/aidge/operator/ReLU.hpp
@@ -28,7 +28,7 @@ namespace Aidge {
 class ReLU_Op : public OperatorTensor,
     public Registrable<ReLU_Op, std::string, std::unique_ptr<OperatorImpl>(const ReLU_Op&)> {
 public:
-    static constexpr const char* Type = "ReLU";
+    static const std::string Type;
 
     ReLU_Op() : OperatorTensor(Type, 1, 0, 1) {}
 
diff --git a/include/aidge/operator/Scaling.hpp b/include/aidge/operator/Scaling.hpp
index fd6d6bcfccc36829671538e1f2e31b13644e3938..2c4a5c5dc4e8bf2683acba9b57ff45a2ad590fa4 100644
--- a/include/aidge/operator/Scaling.hpp
+++ b/include/aidge/operator/Scaling.hpp
@@ -32,7 +32,7 @@ class Scaling_Op : public OperatorTensor,
     public Registrable<Scaling_Op, std::string, std::unique_ptr<OperatorImpl>(const Scaling_Op&)>,
     public StaticAttributes<ScalingAttr, float, size_t, bool> {
 public:
-    static constexpr const char* Type = "Scaling";
+    static const std::string Type;
 
     Scaling_Op() = delete;
 
diff --git a/include/aidge/operator/Slice.hpp b/include/aidge/operator/Slice.hpp
index 7bdbd8099ab79c9f1714989dc41cfc0893427bc9..b449f91af3473f5dc70015f9e1c5e86bd375dbc8 100644
--- a/include/aidge/operator/Slice.hpp
+++ b/include/aidge/operator/Slice.hpp
@@ -32,7 +32,7 @@ class Slice_Op
       public Registrable<Slice_Op<DIM>, std::string, std::unique_ptr<OperatorImpl>(const Slice_Op<DIM> &)>,
       public StaticAttributes<SliceAttr, std::size_t, std::array<DimSize_t, DIM>> {
 public:
-    static constexpr const char *Type = "Slice";
+    static const std::string Type;
 
     Slice_Op() = delete;
 
@@ -111,6 +111,9 @@ public:
     }
 };
 
+template <DimIdx_t DIM>
+const std::string Slice_Op<DIM>::Type = "Slice";
+
 template <std::size_t DIM>
 inline std::shared_ptr<Node> Slice(std::size_t beginningPos, std::array<DimSize_t, DIM> sliceDims,
                                    const std::string &name = "") {
diff --git a/include/aidge/operator/Softmax.hpp b/include/aidge/operator/Softmax.hpp
index cc19cb8210af516f349de124f65cdd55308609fb..f7a1201f5fe5227fb87fed0a9a3e5c36eeb5eeb7 100644
--- a/include/aidge/operator/Softmax.hpp
+++ b/include/aidge/operator/Softmax.hpp
@@ -29,7 +29,7 @@ namespace Aidge {
 class Softmax_Op : public OperatorTensor,
     public Registrable<Softmax_Op, std::string, std::unique_ptr<OperatorImpl>(const Softmax_Op&)> {
 public:
-    static constexpr const char* Type = "Softmax";
+    static const std::string Type;
 
     Softmax_Op() : OperatorTensor(Type, 1, 0, 1) {}
 
diff --git a/include/aidge/operator/Sqrt.hpp b/include/aidge/operator/Sqrt.hpp
index a4069b59bbe7e7586d02b71a39d811d9bf972b77..d4c95d2947b7436cdab49b8527eb7ed3be5f2644 100644
--- a/include/aidge/operator/Sqrt.hpp
+++ b/include/aidge/operator/Sqrt.hpp
@@ -34,7 +34,7 @@ public:
     const std::shared_ptr<Tensor> mOutput = std::make_shared<Tensor>();
 
 public:
-    static constexpr const char* Type = "Sqrt";
+    static const std::string Type;
 
     Sqrt_Op() : OperatorTensor(Type, 1, 0, 1) {}
 
diff --git a/include/aidge/operator/Sub.hpp b/include/aidge/operator/Sub.hpp
index becf98926d2da777c6551e8ed2fbd7b5fcf50017..5d52102d9bd1c214cd4fe9ece8e0e9d6bc4a23b7 100644
--- a/include/aidge/operator/Sub.hpp
+++ b/include/aidge/operator/Sub.hpp
@@ -34,7 +34,7 @@ public:
     const std::shared_ptr<Tensor> mOutput = std::make_shared<Tensor>();
 
 public:
-    static constexpr const char* Type = "Sub";
+    static const std::string Type;
 
     Sub_Op() : OperatorTensor(Type, 2, 0, 1) {}
 
diff --git a/src/operator/Add.cpp b/src/operator/Add.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4e638fd86da487565a89760925e45339213fa8f9
--- /dev/null
+++ b/src/operator/Add.cpp
@@ -0,0 +1,16 @@
+/********************************************************************************
+ * Copyright (c) 2023 CEA-List
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ ********************************************************************************/
+
+#include <string>
+
+#include "aidge/operator/Add.hpp"
+
+const std::string Aidge::Add_Op::Type = "Add";
\ No newline at end of file
diff --git a/src/operator/Concat.cpp b/src/operator/Concat.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..eafcd126480df6da2c0127bdbb896d3ce98d0e0a
--- /dev/null
+++ b/src/operator/Concat.cpp
@@ -0,0 +1,16 @@
+/********************************************************************************
+ * Copyright (c) 2023 CEA-List
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ ********************************************************************************/
+
+#include <string>
+
+#include "aidge/operator/Concat.hpp"
+
+const std::string Aidge::Concat_Op::Type = "Concat";
\ No newline at end of file
diff --git a/src/operator/Div.cpp b/src/operator/Div.cpp
index 273eac2e8fa9623e617d1be204ac2ae46d8da02d..85db3ac6ef66c837c86dbece288185deaca88ba6 100644
--- a/src/operator/Div.cpp
+++ b/src/operator/Div.cpp
@@ -11,6 +11,7 @@
 
 #include <cassert>
 #include <cstddef>
+#include <string>
 #include <vector>
 #include <utility>
 
@@ -19,6 +20,8 @@
 #include "aidge/utils/Types.h"
 #include "aidge/utils/ErrorHandling.hpp"
 
+const std::string Aidge::Div_Op::Type = "Div";
+
 void Aidge::Div_Op::computeOutputDims() {
     // check inputs have been associated
     if (!getInput(0) || !getInput(1)) {
diff --git a/src/operator/FC.cpp b/src/operator/FC.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..32114f5bf9e0d160db9fdc2d1971481be0b4e703
--- /dev/null
+++ b/src/operator/FC.cpp
@@ -0,0 +1,16 @@
+/********************************************************************************
+ * Copyright (c) 2023 CEA-List
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ ********************************************************************************/
+
+#include <string>
+
+#include "aidge/operator/FC.hpp"
+
+const std::string Aidge::FC_Op::Type = "FC";
\ No newline at end of file
diff --git a/src/operator/Identity.cpp b/src/operator/Identity.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f57906dd4f3564b52cde16236bda87370e8f86d7
--- /dev/null
+++ b/src/operator/Identity.cpp
@@ -0,0 +1,16 @@
+/********************************************************************************
+ * Copyright (c) 2023 CEA-List
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ ********************************************************************************/
+
+#include <string>
+
+#include "aidge/operator/Identity.hpp"
+
+const std::string Aidge::Identity_Op::Type = "Identity";
\ No newline at end of file
diff --git a/src/operator/LeakyReLU.cpp b/src/operator/LeakyReLU.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..32e050ee1595cf83b5cd0ffbfeba6153dc2243af
--- /dev/null
+++ b/src/operator/LeakyReLU.cpp
@@ -0,0 +1,16 @@
+/********************************************************************************
+ * Copyright (c) 2023 CEA-List
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ ********************************************************************************/
+
+#include <string>
+
+#include "aidge/operator/LeakyReLU.hpp"
+
+const std::string Aidge::LeakyReLU_Op::Type = "LeakyReLU";
\ No newline at end of file
diff --git a/src/operator/MatMul.cpp b/src/operator/MatMul.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..666ed3921ed1190a91935bd9f38303e23963d912
--- /dev/null
+++ b/src/operator/MatMul.cpp
@@ -0,0 +1,16 @@
+/********************************************************************************
+ * Copyright (c) 2023 CEA-List
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ ********************************************************************************/
+
+#include <string>
+
+#include "aidge/operator/MatMul.hpp"
+
+const std::string Aidge::MatMul_Op::Type = "MatMul";
\ No newline at end of file
diff --git a/src/operator/Pow.cpp b/src/operator/Pow.cpp
index c213a47a4a590026c07625aeb532d303ca8dbced..de1f0c3694f51fbd5b365573f61d3e3e2b9109ff 100644
--- a/src/operator/Pow.cpp
+++ b/src/operator/Pow.cpp
@@ -19,6 +19,8 @@
 #include "aidge/utils/Types.h"
 #include "aidge/utils/ErrorHandling.hpp"
 
+const std::string Aidge::Pow_Op::Type = "Pow";
+
 void Aidge::Pow_Op::computeOutputDims() {
     // check inputs have been associated
     if (!getInput(0) || !getInput(1)) {
diff --git a/src/operator/Producer.cpp b/src/operator/Producer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..443f2fa7d8a60cd25ccb622f2dad5b4926b88eea
--- /dev/null
+++ b/src/operator/Producer.cpp
@@ -0,0 +1,16 @@
+/********************************************************************************
+ * Copyright (c) 2023 CEA-List
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ ********************************************************************************/
+
+#include <string>
+
+#include "aidge/operator/Producer.hpp"
+
+const std::string Aidge::Producer_Op::Type = "Producer";
\ No newline at end of file
diff --git a/src/operator/ReLU.cpp b/src/operator/ReLU.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0f7874acfe7d865ea8c56d4bca02b51864480df6
--- /dev/null
+++ b/src/operator/ReLU.cpp
@@ -0,0 +1,16 @@
+/********************************************************************************
+ * Copyright (c) 2023 CEA-List
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ ********************************************************************************/
+
+#include <string>
+
+#include "aidge/operator/ReLU.hpp"
+
+const std::string Aidge::ReLU_Op::Type = "ReLU";
\ No newline at end of file
diff --git a/src/operator/Scaling.cpp b/src/operator/Scaling.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4c121e1268c1e1a62f793f38c6d816e7c6b48c25
--- /dev/null
+++ b/src/operator/Scaling.cpp
@@ -0,0 +1,16 @@
+/********************************************************************************
+ * Copyright (c) 2023 CEA-List
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ ********************************************************************************/
+
+#include <string>
+
+#include "aidge/operator/Scaling.hpp"
+
+const std::string Aidge::Scaling_Op::Type = "Scaling";
\ No newline at end of file
diff --git a/src/operator/Softmax.cpp b/src/operator/Softmax.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e88ff4bb4ec6e2cb1357d578c2d07cc4edcb59f7
--- /dev/null
+++ b/src/operator/Softmax.cpp
@@ -0,0 +1,16 @@
+/********************************************************************************
+ * Copyright (c) 2023 CEA-List
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ ********************************************************************************/
+
+#include <string>
+
+#include "aidge/operator/Softmax.hpp"
+
+const std::string Aidge::Softmax_Op::Type = "Softmax";
\ No newline at end of file
diff --git a/src/operator/Sqrt.cpp b/src/operator/Sqrt.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..dbcaba42619762f8fd00bb2f6e0aa0de11d92960
--- /dev/null
+++ b/src/operator/Sqrt.cpp
@@ -0,0 +1,16 @@
+/********************************************************************************
+ * Copyright (c) 2023 CEA-List
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ ********************************************************************************/
+
+#include <string>
+
+#include "aidge/operator/Sqrt.hpp"
+
+const std::string Aidge::Sqrt_Op::Type = "Sqrt";
\ No newline at end of file
diff --git a/src/operator/Sub.cpp b/src/operator/Sub.cpp
index 8175f1b7ae5bb5eccd36267c1d739f764bd3c236..639eaf798c1c2a9a6685e8b8d2c4a2cb00a4b57a 100644
--- a/src/operator/Sub.cpp
+++ b/src/operator/Sub.cpp
@@ -19,6 +19,8 @@
 #include "aidge/utils/Types.h"
 #include "aidge/utils/ErrorHandling.hpp"
 
+const std::string Aidge::Sub_Op::Type = "Sub";
+
 void Aidge::Sub_Op::computeOutputDims() {
     // check inputs have been associated
     if (!getInput(0) || !getInput(1)) {