diff --git a/include/aidge/operator/Add.hpp b/include/aidge/operator/Add.hpp
index de9afab203e78f83b1edfa294af1f9b3e90f209a..2575e165b234bd425cfc57441e536b12ddb6f03c 100644
--- a/include/aidge/operator/Add.hpp
+++ b/include/aidge/operator/Add.hpp
@@ -93,13 +93,13 @@ public:
         assert(static_cast<std::size_t>(inputIdx) < NUM && "wrong inputIdx for Add operator.");
         return *(mInputs[inputIdx].get());
     }
-    inline Tensor& output(__attribute__((unused)) const IOIndex_t outputIdx) const override final { return *(mOutput.get()); }
+    inline Tensor& output(const IOIndex_t /*outputIdx*/) const override final { return *(mOutput.get()); }
 
     inline std::shared_ptr<Tensor> getInput(const IOIndex_t inputIdx) const override final {
         assert(static_cast<std::size_t>(inputIdx) < NUM && "wrong inputIdx for Add operator.");
         return mInputs[inputIdx];
     }
-    inline std::shared_ptr<Tensor> getOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
+    inline std::shared_ptr<Tensor> getOutput(const IOIndex_t /*outputIdx*/) const override final {
         assert(outputIdx == 0 && "Add Operators has only 1 outputs");
         return mOutput;
     }
@@ -108,7 +108,7 @@ public:
         assert(static_cast<std::size_t>(inputIdx) < NUM && "wrong inputIdx for Add operator.");
         return std::static_pointer_cast<Data>(mInputs[inputIdx]);
     }
-    std::shared_ptr<Data> getRawOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
+    std::shared_ptr<Data> getRawOutput(const IOIndex_t /*outputIdx*/) const override final {
         assert(outputIdx == 0 && "operator supports only 1 output");
         return std::static_pointer_cast<Data>(mOutput);
     }
diff --git a/include/aidge/operator/AvgPooling.hpp b/include/aidge/operator/AvgPooling.hpp
index 0dbd91e059656369cdf12a4dfab2a981806011d1..a431844376ca8d0551cc75387278cca4662beae6 100644
--- a/include/aidge/operator/AvgPooling.hpp
+++ b/include/aidge/operator/AvgPooling.hpp
@@ -63,7 +63,7 @@ public:
         setDatatype(DataType::Float32);
     }
 
-    constexpr void associateInput(__attribute__((unused)) const IOIndex_t inputIdx, std::shared_ptr<Data> data) override final {
+    constexpr void associateInput(const IOIndex_t /*inputIdx*/, std::shared_ptr<Data> data) override final {
         assert(inputIdx < 1 && "operators supports only 3 inputs");
         assert(strcmp(data->type(), Tensor::Type) == 0 && "input data must be of Tensor type");
 
@@ -91,28 +91,28 @@ public:
     bool outputDimsForwarded() const override final { return !(mOutput->empty()); }
 
 
-    inline Tensor& input(__attribute__((unused)) const IOIndex_t inputIdx) const override final {
+    inline Tensor& input(const IOIndex_t /*inputIdx*/) const override final {
         assert(inputIdx == 0 && "operators supports only 1 inputs");
         return *(mInput.get());
     }
-    inline Tensor& output(__attribute__((unused)) const IOIndex_t outputIdx) const override final { return *(mOutput.get()); }
+    inline Tensor& output(const IOIndex_t /*outputIdx*/) const override final { return *(mOutput.get()); }
 
 
-    inline std::shared_ptr<Tensor> getInput(__attribute__((unused)) const IOIndex_t inputIdx) const override final {
+    inline std::shared_ptr<Tensor> getInput(const IOIndex_t /*inputIdx*/) const override final {
         assert(inputIdx == 0 && "AvgPooling Operators supports only 1 inputs");
         return mInput;
     }
-    inline std::shared_ptr<Tensor> getOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
+    inline std::shared_ptr<Tensor> getOutput(const IOIndex_t /*outputIdx*/) const override final {
         assert(outputIdx == 0 && "AvgPooling Operators has only 1 outputs");
         return mOutput;
     }
 
 
-    std::shared_ptr<Data> getRawInput(__attribute__((unused)) const IOIndex_t inputIdx) const override final {
+    std::shared_ptr<Data> getRawInput(const IOIndex_t /*inputIdx*/) const override final {
         assert(inputIdx == 0 && "operators supports only 1 inputs");
         return std::static_pointer_cast<Data>(mInput);
     }
-    std::shared_ptr<Data> getRawOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
+    std::shared_ptr<Data> getRawOutput(const IOIndex_t /*outputIdx*/) const override final {
         assert(outputIdx == 0 && "operator supports only 1 output");
         return std::static_pointer_cast<Data>(mOutput);
     }
diff --git a/include/aidge/operator/BatchNorm.hpp b/include/aidge/operator/BatchNorm.hpp
index 01a6ccf4f7cf30843cac3dc819a686d3ad11530d..cecf006b08ac14b16ed181c49c999080d3079a54 100644
--- a/include/aidge/operator/BatchNorm.hpp
+++ b/include/aidge/operator/BatchNorm.hpp
@@ -65,7 +65,7 @@ public:
     //     return *in;
     // }
 
-    constexpr void associateInput(__attribute__((unused)) const IOIndex_t inputIdx, std::shared_ptr<Data> data) override final {
+    constexpr void associateInput(const IOIndex_t /*inputIdx*/, std::shared_ptr<Data> data) override final {
         assert(inputIdx < 5 && "operators supports only 5 inputs");
         assert(strcmp(data->type(), Tensor::Type) == 0 && "input data must be of Tensor type");
 
@@ -90,14 +90,14 @@ public:
         assert(inputIdx < 5 && "operators supports only 5 inputs");
         return *(mInputs[inputIdx].get()); }
 
-    inline Tensor& output(__attribute__((unused)) const IOIndex_t outputIdx) const override final { return *(mOutput.get()); }
+    inline Tensor& output(const IOIndex_t /*outputIdx*/) const override final { return *(mOutput.get()); }
 
 
     inline std::shared_ptr<Tensor> getInput(const IOIndex_t inputIdx) const override final {
         assert(inputIdx < 5 && "BatchNorm Operators supports only 5 inputs");
         return mInputs[inputIdx];
     }
-    inline std::shared_ptr<Tensor> getOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
+    inline std::shared_ptr<Tensor> getOutput(const IOIndex_t /*outputIdx*/) const override final {
         assert((outputIdx == 0) && "BatchNorm Operator has only 1 output");
         return mOutput;
     }
@@ -107,7 +107,7 @@ public:
         assert(inputIdx < 5 && "operators supports only 5 inputs");
         return std::static_pointer_cast<Data>(mInputs[inputIdx]);
     }
-    std::shared_ptr<Data> getRawOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
+    std::shared_ptr<Data> getRawOutput(const IOIndex_t /*outputIdx*/) const override final {
         assert(outputIdx == 0 && "operator supports only 1 output");
         return std::static_pointer_cast<Data>(mOutput);
     }
diff --git a/include/aidge/operator/Conv.hpp b/include/aidge/operator/Conv.hpp
index 1fcea7a4b5d654d3ec1a8661c03912b6074918c3..df0876941962cb2ac75dcf9ac5df1258ed4d1086 100644
--- a/include/aidge/operator/Conv.hpp
+++ b/include/aidge/operator/Conv.hpp
@@ -79,7 +79,7 @@ public:
 
     // }
 
-    constexpr void associateInput(__attribute__((unused)) const IOIndex_t inputIdx, std::shared_ptr<Data> data) override final {
+    constexpr void associateInput(const IOIndex_t /*inputIdx*/, std::shared_ptr<Data> data) override final {
         assert(inputIdx < 3 && "operators supports only 3 inputs");
         assert(strcmp(data->type(), Tensor::Type) == 0 && "input data must be of Tensor type");
 
@@ -114,14 +114,14 @@ public:
     inline Tensor& input(const IOIndex_t inputIdx) const override final {
         assert(inputIdx < 3 && "operators supports only 3 inputs");
         return *(mInputs[inputIdx].get()); }
-    inline Tensor& output(__attribute__((unused)) const IOIndex_t outputIdx) const override final { return *(mOutput.get()); }
+    inline Tensor& output(const IOIndex_t /*outputIdx*/) const override final { return *(mOutput.get()); }
 
 
     inline std::shared_ptr<Tensor> getInput(const IOIndex_t inputIdx) const override final {
         assert(inputIdx < 3 && "Conv Operators supports only 3 inputs");
         return mInputs[inputIdx];
     }
-    inline std::shared_ptr<Tensor> getOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
+    inline std::shared_ptr<Tensor> getOutput(const IOIndex_t /*outputIdx*/) const override final {
         assert((outputIdx == 0) && "Conv Operator has only 1 output");
         return mOutput;
     }
@@ -131,7 +131,7 @@ public:
         assert(inputIdx < 3 && "operators supports only 3 inputs");
         return std::static_pointer_cast<Data>(mInputs[inputIdx]);
     }
-    std::shared_ptr<Data> getRawOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
+    std::shared_ptr<Data> getRawOutput(const IOIndex_t /*outputIdx*/) const override final {
         assert(outputIdx == 0 && "operator supports only 1 output");
         return std::static_pointer_cast<Data>(mOutput);
     }
diff --git a/include/aidge/operator/ConvDepthWise.hpp b/include/aidge/operator/ConvDepthWise.hpp
index 4a4af179b454f231ae2ce8dbafeb319795a76861..e3102d385384a60160246636e941c779df3e557c 100644
--- a/include/aidge/operator/ConvDepthWise.hpp
+++ b/include/aidge/operator/ConvDepthWise.hpp
@@ -71,7 +71,7 @@ class ConvDepthWise_Op : public Operator,
         setDatatype(DataType::Float32);
     }
 
-    constexpr void associateInput(__attribute__((unused)) const IOIndex_t inputIdx, std::shared_ptr<Data> data) override final {
+    constexpr void associateInput(const IOIndex_t /*inputIdx*/, std::shared_ptr<Data> data) override final {
         assert(inputIdx < 3 && "operators supports only 3 inputs");
         assert(strcmp(data->type(), Tensor::Type) == 0 && "input data must be of Tensor type");
 
@@ -114,14 +114,14 @@ class ConvDepthWise_Op : public Operator,
         assert(inputIdx < 3 && "operators supports only 3 inputs");
         return *(mInputs[inputIdx].get());
     }
-    inline Tensor& output(__attribute__((unused)) const IOIndex_t outputIdx) const override final { return *(mOutput.get()); }
+    inline Tensor& output(const IOIndex_t /*outputIdx*/) const override final { return *(mOutput.get()); }
 
 
     inline std::shared_ptr<Tensor> getInput(const IOIndex_t inputIdx) const override final {
         assert(inputIdx < 3 && "ConvDepthWise Operators supports only 3 inputs");
         return mInputs[inputIdx];
     }
-    inline std::shared_ptr<Tensor> getOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
+    inline std::shared_ptr<Tensor> getOutput(const IOIndex_t /*outputIdx*/) const override final {
         assert((outputIdx == 0) && "ConvDepthWise Operator has only 1 output");
         return mOutput;
     }
@@ -131,7 +131,7 @@ class ConvDepthWise_Op : public Operator,
         assert(inputIdx < 3 && "operators supports only 3 inputs");
         return std::static_pointer_cast<Data>(mInputs[inputIdx]);
     }
-    std::shared_ptr<Data> getRawOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
+    std::shared_ptr<Data> getRawOutput(const IOIndex_t /*outputIdx*/) const override final {
         assert(outputIdx == 0 && "operator supports only 1 output");
         return std::static_pointer_cast<Data>(mOutput);
     }
diff --git a/include/aidge/operator/FC.hpp b/include/aidge/operator/FC.hpp
index 74362044349a087896cbc231f86818c89187c568..6a68a6e1816978576dc7bd858c9494c9fe1e7f12 100644
--- a/include/aidge/operator/FC.hpp
+++ b/include/aidge/operator/FC.hpp
@@ -57,7 +57,7 @@ public:
         setDatatype(DataType::Float32);
     }
 
-    void associateInput(__attribute__((unused)) const IOIndex_t inputIdx, std::shared_ptr<Data> data) override final {
+    void associateInput(const IOIndex_t /*inputIdx*/, std::shared_ptr<Data> data) override final {
         assert(inputIdx < 3 && "operators supports only 3 inputs");
         assert(strcmp(data->type(), Tensor::Type)==0 && "input data must be of Tensor type");
         if (inputIdx == 2) {
@@ -89,14 +89,14 @@ public:
     inline Tensor& input(const IOIndex_t inputIdx) const override final {
         assert(inputIdx < 3 && "operators supports only 3 inputs");
         return *(mInputs[inputIdx].get()); }
-    inline Tensor& output(__attribute__((unused)) const IOIndex_t inputIdx) const override final { return *(mOutput.get()); }
+    inline Tensor& output(const IOIndex_t /*inputIdx*/) const override final { return *(mOutput.get()); }
 
 
     inline std::shared_ptr<Tensor> getInput(const IOIndex_t inputIdx) const override final {
         assert(inputIdx < 3 && "FC Operators supports only 3 inputs");
         return mInputs[inputIdx];
     }
-    inline std::shared_ptr<Tensor> getOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
+    inline std::shared_ptr<Tensor> getOutput(const IOIndex_t /*outputIdx*/) const override final {
         assert((outputIdx == 0) && "FC Operator has only 1 output");
         return mOutput;
     }
@@ -106,7 +106,7 @@ public:
         assert(inputIdx < 3 && "operators supports only 3 inputs");
         return std::static_pointer_cast<Data>(mInputs[inputIdx]);
     }
-    std::shared_ptr<Data> getRawOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
+    std::shared_ptr<Data> getRawOutput(const IOIndex_t /*outputIdx*/) const override final {
         assert(outputIdx == 0 && "operator supports only 1 output");
         return std::static_pointer_cast<Data>(mOutput);
     }
diff --git a/include/aidge/operator/GenericOperator.hpp b/include/aidge/operator/GenericOperator.hpp
index 7efbe62a410ed21704d2a34d46a295202c43c31e..a3e1f02912fb3abdc8adeb09971ee090e875c1fb 100644
--- a/include/aidge/operator/GenericOperator.hpp
+++ b/include/aidge/operator/GenericOperator.hpp
@@ -85,7 +85,7 @@ class GenericOperator_Op
     std::vector<std::string> getParametersName() { return mParams.getParametersName(); }
 
     // Override Virtual Opertor methods
-    void associateInput(__attribute__((unused)) const IOIndex_t inputIdx, __attribute__((unused)) std::shared_ptr<Data> data) override final {
+    void associateInput(const IOIndex_t /*inputIdx*/, std::shared_ptr<Data> /*data*/) override final {
         printf("Info: using associateInput() on a GenericOperator.\n");
     }
 
diff --git a/include/aidge/operator/LeakyReLU.hpp b/include/aidge/operator/LeakyReLU.hpp
index 058f41fd85516db97a66de448d0f4b1b61254021..4270ab487d12274a8445a28135a367b776592ac6 100644
--- a/include/aidge/operator/LeakyReLU.hpp
+++ b/include/aidge/operator/LeakyReLU.hpp
@@ -53,7 +53,7 @@ public:
         setDatatype(DataType::Float32);
     }
 
-    void associateInput(__attribute__((unused)) const IOIndex_t inputIdx, std::shared_ptr<Data> data) override final {
+    void associateInput(const IOIndex_t /*inputIdx*/, std::shared_ptr<Data> data) override final {
         assert(inputIdx == 0 && "operator supports only 1 input");
         assert(strcmp(data->type(), Tensor::Type)==0 && "input data must be of Tensor type");
         mInput = std::dynamic_pointer_cast<Tensor>(data);
@@ -69,25 +69,25 @@ public:
     }
 
 
-    inline Tensor& input(__attribute__((unused)) const IOIndex_t inputIdx) const override final { return *(mInput.get()); }
-    inline Tensor& output(__attribute__((unused)) const IOIndex_t outputIdx) const override final { return *(mOutput.get()); }
+    inline Tensor& input(const IOIndex_t /*inputIdx*/) const override final { return *(mInput.get()); }
+    inline Tensor& output(const IOIndex_t /*outputIdx*/) const override final { return *(mOutput.get()); }
 
 
-    inline std::shared_ptr<Tensor> getInput(__attribute__((unused)) const IOIndex_t inputIdx) const override final {
+    inline std::shared_ptr<Tensor> getInput(const IOIndex_t /*inputIdx*/) const override final {
         assert((inputIdx == 0) && "LeakyReLU Operator has only 1 input");
         return mInput;
     }
-    inline std::shared_ptr<Tensor> getOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
+    inline std::shared_ptr<Tensor> getOutput(const IOIndex_t /*outputIdx*/) const override final {
         assert((outputIdx == 0) && "LeakyReLU Operator has only 1 output");
         return mOutput;
     }
 
 
-    std::shared_ptr<Data> getRawInput(__attribute__((unused)) const IOIndex_t inputIdx) const override final {
+    std::shared_ptr<Data> getRawInput(const IOIndex_t /*inputIdx*/) const override final {
         assert(inputIdx == 0 && "operator supports only 1 input");
         return std::static_pointer_cast<Data>(mInput);
     }
-    std::shared_ptr<Data> getRawOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
+    std::shared_ptr<Data> getRawOutput(const IOIndex_t /*outputIdx*/) const override final {
         assert(outputIdx == 0 && "operator supports only 1 output");
         return mOutput;
     }
diff --git a/include/aidge/operator/Matmul.hpp b/include/aidge/operator/Matmul.hpp
index b6181989cf8fa583bf87ac45b2af8d0491e387be..58ea91b9176a11037dfbffad92a543c2dc9301e3 100644
--- a/include/aidge/operator/Matmul.hpp
+++ b/include/aidge/operator/Matmul.hpp
@@ -55,7 +55,7 @@ public:
         setDatatype(DataType::Float32);
     }
 
-    void associateInput(__attribute__((unused)) const IOIndex_t inputIdx, std::shared_ptr<Data> data) override final {
+    void associateInput(const IOIndex_t /*inputIdx*/, std::shared_ptr<Data> data) override final {
         assert(inputIdx < 2 && "operators supports only 2 inputs");
         assert(strcmp(data->type(), Tensor::Type)==0 && "input data must be of Tensor type");
         mInputs[inputIdx] = std::dynamic_pointer_cast<Tensor>(data);
@@ -81,14 +81,14 @@ public:
     inline Tensor& input(const IOIndex_t inputIdx) const override final {
         assert(inputIdx < 2 && "operators supports only 2 inputs");
         return *(mInputs[inputIdx].get()); }
-    inline Tensor& output(__attribute__((unused)) const IOIndex_t outputIdx) const override final { return *(mOutput.get()); }
+    inline Tensor& output(const IOIndex_t /*outputIdx*/) const override final { return *(mOutput.get()); }
 
 
     inline std::shared_ptr<Tensor> getInput(const IOIndex_t inputIdx) const override final {
         assert(inputIdx < 2 && "MatMul Operators has 2 inputs");
         return mInputs[inputIdx];
     }
-    inline std::shared_ptr<Tensor> getOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
+    inline std::shared_ptr<Tensor> getOutput(const IOIndex_t /*outputIdx*/) const override final {
         assert((outputIdx == 0) && "MatMul Operators has 1 output");
         return mOutput;
     }
@@ -98,7 +98,7 @@ public:
         assert(inputIdx < 2 && "operators supports only 2 inputs");
         return std::static_pointer_cast<Data>(mInputs[inputIdx]);
     }
-    std::shared_ptr<Data> getRawOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
+    std::shared_ptr<Data> getRawOutput(const IOIndex_t /*outputIdx*/) const override final {
         assert(outputIdx == 0 && "operator supports only 1 output");
         return std::static_pointer_cast<Data>(mOutput);
     }
diff --git a/include/aidge/operator/Producer.hpp b/include/aidge/operator/Producer.hpp
index 4268b46b2f0facdaf0d167f16ae01ba8cba2c01d..cbd587037a02aa93faa5b4b58f7d52fb57bea96d 100644
--- a/include/aidge/operator/Producer.hpp
+++ b/include/aidge/operator/Producer.hpp
@@ -51,7 +51,7 @@ public:
         setDatatype(tensor->dataType());
     }
 
-    void associateInput(__attribute__((unused)) const IOIndex_t inputIdx, __attribute__((unused)) std::shared_ptr<Data> data) override final {
+    void associateInput(const IOIndex_t /*inputIdx*/, std::shared_ptr<Data> /*data*/) override final {
         assert(false && "Producer operator takes no input");
     }
 
@@ -60,29 +60,29 @@ public:
     constexpr bool outputDimsForwarded() const override final {return true;}
 
 
-    [[noreturn]] inline Tensor& input(__attribute__((unused)) const IOIndex_t inputIdx) const override final {
+    [[noreturn]] inline Tensor& input(const IOIndex_t /*inputIdx*/) const override final {
       assert(false);
       exit(-1);
     }
-    inline Tensor& output(__attribute__((unused)) const IOIndex_t outputIdx) const override final { return *(mOutput.get()); }
+    inline Tensor& output(const IOIndex_t /*outputIdx*/) const override final { return *(mOutput.get()); }
 
 
-    inline std::shared_ptr<Tensor> getInput(__attribute__((unused)) const IOIndex_t inputIdx) const override final {
+    inline std::shared_ptr<Tensor> getInput(const IOIndex_t /*inputIdx*/) const override final {
       assert(false && "Producer Operator has no input");
       return nullptr;
     }
-    inline std::shared_ptr<Tensor> getOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
+    inline std::shared_ptr<Tensor> getOutput(const IOIndex_t /*outputIdx*/) const override final {
       assert((outputIdx == 0) && "Producer Operator has only 1 output");
       return mOutput;
     }
 
 
-    std::shared_ptr<Data> getRawInput(__attribute__((unused)) const IOIndex_t inputIdx) const override final {
+    std::shared_ptr<Data> getRawInput(const IOIndex_t /*inputIdx*/) const override final {
         assert(false && "Producer operator takes no input");
         return nullptr;
     }
 
-    std::shared_ptr<Data> getRawOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
+    std::shared_ptr<Data> getRawOutput(const IOIndex_t /*outputIdx*/) const override final {
         assert(outputIdx == 0 && "operator supports only 1 output");
         return std::static_pointer_cast<Data>(mOutput);
     }
diff --git a/include/aidge/operator/ReLU.hpp b/include/aidge/operator/ReLU.hpp
index b969a76bc24a6fa41288b009934a3c060289b597..972a73388fba9421be67ae1bcc42ddfd1f9407eb 100644
--- a/include/aidge/operator/ReLU.hpp
+++ b/include/aidge/operator/ReLU.hpp
@@ -42,7 +42,7 @@ public:
         setDatatype(DataType::Float32);
     }
 
-    void associateInput(__attribute__((unused)) const IOIndex_t inputIdx, std::shared_ptr<Data> data) override final {
+    void associateInput(const IOIndex_t /*inputIdx*/, std::shared_ptr<Data> data) override final {
         assert(inputIdx == 0 && "operator supports only 1 input");
         assert(strcmp(data->type(), Tensor::Type)==0 && "input data must be of Tensor type");
         mInput = std::dynamic_pointer_cast<Tensor>(data);
@@ -58,25 +58,25 @@ public:
     }
 
 
-    inline Tensor& input(__attribute__((unused)) const IOIndex_t inputIdx) const override final { return *(mInput.get()); }
-    inline Tensor& output(__attribute__((unused)) const IOIndex_t outputIdx) const override final { return *(mOutput.get()); }
+    inline Tensor& input(const IOIndex_t /*inputIdx*/) const override final { return *(mInput.get()); }
+    inline Tensor& output(const IOIndex_t /*outputIdx*/) const override final { return *(mOutput.get()); }
 
 
-    inline std::shared_ptr<Tensor> getInput(__attribute__((unused)) const IOIndex_t inputIdx) const override final {
+    inline std::shared_ptr<Tensor> getInput(const IOIndex_t /*inputIdx*/) const override final {
         assert((inputIdx == 0) && "ReLU Operator has only 1 input");
         return mInput;
     }
-    inline std::shared_ptr<Tensor> getOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
+    inline std::shared_ptr<Tensor> getOutput(const IOIndex_t /*outputIdx*/) const override final {
         assert((outputIdx == 0) && "ReLU Operator has only 1 output");
         return mOutput;
     }
 
 
-    std::shared_ptr<Data> getRawInput(__attribute__((unused)) const IOIndex_t inputIdx) const override final {
+    std::shared_ptr<Data> getRawInput(const IOIndex_t /*inputIdx*/) const override final {
         assert(inputIdx == 0 && "operator supports only 1 input");
         return std::static_pointer_cast<Data>(mInput);
     }
-    std::shared_ptr<Data> getRawOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
+    std::shared_ptr<Data> getRawOutput(const IOIndex_t /*outputIdx*/) const override final {
         assert(outputIdx == 0 && "operator supports only 1 output");
         return std::static_pointer_cast<Data>(mOutput);
     }
diff --git a/include/aidge/operator/Softmax.hpp b/include/aidge/operator/Softmax.hpp
index 3d3cb8204e4b133b944521cf84117b5d16ac83df..81eb7fa90fc6708ae79d000db346c2a6126eb1db 100644
--- a/include/aidge/operator/Softmax.hpp
+++ b/include/aidge/operator/Softmax.hpp
@@ -42,7 +42,7 @@ public:
         setDatatype(DataType::Float32);
     }
 
-    void associateInput(__attribute__((unused)) const IOIndex_t inputIdx, std::shared_ptr<Data> data) override final {
+    void associateInput(const IOIndex_t /*inputIdx*/, std::shared_ptr<Data> data) override final {
         assert(inputIdx == 0 && "operator supports only 1 input");
         assert(strcmp(data->type(), Tensor::Type)==0 && "input data must be of Tensor type");
         mInput = std::dynamic_pointer_cast<Tensor>(data);
@@ -58,25 +58,25 @@ public:
     }
 
 
-    inline Tensor& input(__attribute__((unused)) const IOIndex_t inputIdx) const override final { return *(mInput.get()); }
-    inline Tensor& output(__attribute__((unused)) const IOIndex_t outputIdx) const override final { return *(mOutput.get()); }
+    inline Tensor& input(const IOIndex_t /*inputIdx*/) const override final { return *(mInput.get()); }
+    inline Tensor& output(const IOIndex_t /*outputIdx*/) const override final { return *(mOutput.get()); }
 
 
-    inline std::shared_ptr<Tensor> getInput(__attribute__((unused)) const IOIndex_t inputIdx) const override final {
+    inline std::shared_ptr<Tensor> getInput(const IOIndex_t /*inputIdx*/) const override final {
         assert((inputIdx == 0) && "Softmax Operator has only 1 input");
         return mInput;
     }
-    inline std::shared_ptr<Tensor> getOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
+    inline std::shared_ptr<Tensor> getOutput(const IOIndex_t /*outputIdx*/) const override final {
         assert((outputIdx == 0) && "Softmax Operator has only 1 output");
         return mOutput;
     }
 
 
-    std::shared_ptr<Data> getRawInput(__attribute__((unused)) const IOIndex_t inputIdx) const override final {
+    std::shared_ptr<Data> getRawInput(const IOIndex_t /*inputIdx*/) const override final {
         assert(inputIdx == 0 && "operator supports only 1 input");
         return std::static_pointer_cast<Data>(mInput);
     }
-    std::shared_ptr<Data> getRawOutput(__attribute__((unused)) const IOIndex_t outputIdx) const override final {
+    std::shared_ptr<Data> getRawOutput(const IOIndex_t /*outputIdx*/) const override final {
         assert(outputIdx == 0 && "operator supports only 1 output");
         return std::static_pointer_cast<Data>(mOutput);
     }
diff --git a/src/graph/GraphView.cpp b/src/graph/GraphView.cpp
index 53d9f844a6a5bda4961659b8ff7f8b1fcf53b4e7..e8b29c67cf0b71c61a11f4ee07c57371af14a2a8 100644
--- a/src/graph/GraphView.cpp
+++ b/src/graph/GraphView.cpp
@@ -28,13 +28,15 @@ Aidge::Connector Aidge::GraphView::operator()(
   assert((inputNodes().size() == 1U) && "Too many input Nodes for the GraphView, undefined behaviour");
   std::shared_ptr<Node> inNode = *inputNodes().begin();
   assert((ctors.size() == static_cast<std::size_t>(inNode->nbDataInputs())) && "Wrong number of arguments.\n");
-  for (__attribute__((unused)) std::pair<std::shared_ptr<Node>, IOIndex_t> &input : inNode->inputs()) {
+  for (std::pair<std::shared_ptr<Node>, IOIndex_t> &input : inNode->inputs()) {
     assert((gk_IODefaultIndex == input.second) && "At least one input connection is not free.\n");
+    (void)input; // Suppress ununsed warning
   }
 
-  for (__attribute__((unused)) const Connector &ctor : ctors) {
+  for (const Connector &ctor : ctors) {
     assert((ctor.node() != nullptr) &&
            "Input Connector must be associated with a node");
+    (void)ctors; // Suppress ununsed warning
   }
   IOIndex_t inID = 0;
   for (const Connector &ctor : ctors) {
diff --git a/src/graph/Node.cpp b/src/graph/Node.cpp
index 286ed7136a369e63f567b35135f89afcc266e0e1..f4e2b58185d70223b9319c81b221e1ad5bb04459 100644
--- a/src/graph/Node.cpp
+++ b/src/graph/Node.cpp
@@ -35,8 +35,9 @@ Aidge::Node::Node(std::shared_ptr<Operator> op, const char *name)
 
 Aidge::Connector Aidge::Node::operator()(const std::vector<Connector> &ctors) {
     assert((ctors.size() == nbDataInputs()) && "Wrong number of arguments.\n");
-    for (__attribute__((unused)) std::pair<std::shared_ptr<Node>, IOIndex_t> &input : inputs()) {
+    for (std::pair<std::shared_ptr<Node>, IOIndex_t> &input : inputs()) {
         assert((gk_IODefaultIndex == input.second) && "At least one input connection is not free.\n");
+        (void) input;
     }
     IOIndex_t i = 0;
     for (const Connector &ctor : ctors) {