COMPMID-793 : Add graph intermediate representation

Change-Id: Ic1685de4e19e0ac79669ef2da64e1dc96c7ea0bf
Reviewed-on: https://eu-gerrit-1.euhpc.arm.com/115248
Tested-by: Jenkins <bsgcomp@arm.com>
Reviewed-by: Anthony Barbier <anthony.barbier@arm.com>

85 files changed, 6200 insertions, 22 deletions

diff --git a/arm_compute/core/Error.h b/arm_compute/core/Error.h
index 56c7ccdd93..f178936ede 100644
--- a/arm_compute/core/Error.h
+++ b/arm_compute/core/Error.h
@@ -29,6 +29,16 @@
 
 namespace arm_compute
 {
+/** Ignores unused arguments
+ *
+ * @tparam T Argument types
+ */
+template <typename... T>
+inline void ignore_unused(T &&...)
+{
+}
+
+/** Available error codes */
 enum class ErrorCode
 {
     OK,           /**< No error */
@@ -142,9 +152,9 @@ Status create_error(ErrorCode error_code, const char *function, const char *file
  * This is useful if for example a variable is only used
  * in debug builds and generates a warning in release builds.
  *
- * @param[in] var Variable which is unused.
+ * @param[in] ... Variables which are unused.
  */
-#define ARM_COMPUTE_UNUSED(var) (void)(var)
+#define ARM_COMPUTE_UNUSED(...) ignore_unused(__VA_ARGS__) // NOLINT
 
 /** Creates an error with a given message
  *
diff --git a/arm_compute/core/FixedPoint.inl b/arm_compute/core/FixedPoint.inl
index 9c7e35ab16..eb3516e8db 100644
--- a/arm_compute/core/FixedPoint.inl
+++ b/arm_compute/core/FixedPoint.inl
@@ -22,7 +22,7 @@
  * SOFTWARE.
  */
 #include "arm_compute/core/Error.h"
-#include "arm_compute/core/utils/misc/utility.h"
+#include "arm_compute/core/utils/misc/Utility.h"
 
 #include <cmath>
 #include <limits>
diff --git a/arm_compute/core/Helpers.h b/arm_compute/core/Helpers.h
index 24ba521d60..1554f63904 100644
--- a/arm_compute/core/Helpers.h
+++ b/arm_compute/core/Helpers.h
@@ -33,7 +33,6 @@
 #include "arm_compute/core/TensorShape.h"
 #include "arm_compute/core/Types.h"
 #include "arm_compute/core/Window.h"
-#include "arm_compute/core/utils/misc/utility.h"
 
 #include <array>
 #include <cstddef>
diff --git a/arm_compute/core/ITensorInfo.h b/arm_compute/core/ITensorInfo.h
index 167fb41bb3..ce0cf53fdf 100644
--- a/arm_compute/core/ITensorInfo.h
+++ b/arm_compute/core/ITensorInfo.h
@@ -30,7 +30,7 @@
 #include "arm_compute/core/Types.h"
 #include "arm_compute/core/Utils.h"
 #include "arm_compute/core/utils/misc/ICloneable.h"
-#include "arm_compute/core/utils/misc/utility.h"
+#include "arm_compute/core/utils/misc/Utility.h"
 
 #include <cstddef>
 
diff --git a/arm_compute/core/TensorShape.h b/arm_compute/core/TensorShape.h
index dc836c98da..d5532e8a6a 100644
--- a/arm_compute/core/TensorShape.h
+++ b/arm_compute/core/TensorShape.h
@@ -26,7 +26,7 @@
 
 #include "arm_compute/core/Dimensions.h"
 #include "arm_compute/core/Error.h"
-#include "arm_compute/core/utils/misc/utility.h"
+#include "arm_compute/core/utils/misc/Utility.h"
 
 #include <algorithm>
 #include <array>
diff --git a/arm_compute/core/Types.h b/arm_compute/core/Types.h
index 143ee025f5..ae88e607c3 100644
--- a/arm_compute/core/Types.h
+++ b/arm_compute/core/Types.h
@@ -1076,5 +1076,5 @@ enum class ConvolutionMethod
     DIRECT,  /**< Direct convolution */
     WINOGRAD /**< Convolution using Winograd */
 };
-}
+} // namespace arm_compute
 #endif /* __ARM_COMPUTE_TYPES_H__ */
diff --git a/arm_compute/core/utils/logging/Types.h b/arm_compute/core/utils/logging/Types.h
index 171270d4ef..0b40e3d7a1 100644
--- a/arm_compute/core/utils/logging/Types.h
+++ b/arm_compute/core/utils/logging/Types.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, 2017 ARM Limited.
+ * Copyright (c) 2016-2018 ARM Limited.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -36,6 +36,7 @@ enum class LogLevel : unsigned int
     VERBOSE, /**< All logging messages */
     INFO,    /**< Information log level */
     WARN,    /**< Warning log level */
+    ERROR,   /**< Error log level */
     OFF      /**< No logging */
 };
 
diff --git a/arm_compute/core/utils/misc/CRTP.h b/arm_compute/core/utils/misc/CRTP.h
new file mode 100644
index 0000000000..9947312f95
--- /dev/null
+++ b/arm_compute/core/utils/misc/CRTP.h
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_MISC_CRTP_H__
+#define __ARM_COMPUTE_MISC_CRTP_H__
+
+namespace arm_compute
+{
+namespace misc
+{
+/** Curiously recurring template pattern Interface */
+template <typename T, template <typename> class Type>
+struct CRTP
+{
+public:
+    using ExactType = T;
+
+protected:
+    const T &impl() const
+    {
+        return static_cast<const T &>(*this);
+    }
+    T &impl()
+    {
+        return static_cast<T &>(*this);
+    }
+
+private:
+    CRTP() = default;
+    friend Type<T>;
+};
+} // namespace misc
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_MISC_CRTP_H__ */
diff --git a/arm_compute/core/utils/misc/Cast.h b/arm_compute/core/utils/misc/Cast.h
new file mode 100644
index 0000000000..f6c91dd2de
--- /dev/null
+++ b/arm_compute/core/utils/misc/Cast.h
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_MISC_CAST_H__
+#define __ARM_COMPUTE_MISC_CAST_H__
+
+#include "arm_compute/core/Error.h"
+
+namespace arm_compute
+{
+namespace utils
+{
+namespace cast
+{
+/** Polymorphic cast between two types
+ *
+ * @warning Will throw an exception if cast cannot take place
+ *
+ * @tparam Target Target to cast type
+ * @tparam Source Source from cast type
+ *
+ * @param[in] v Value to cast
+ *
+ * @return The casted type
+ */
+template <typename Target, typename Source>
+inline Target polymorphic_cast(Source *v)
+{
+    if(dynamic_cast<Target>(v) == nullptr)
+    {
+        throw std::bad_cast();
+    }
+    return static_cast<Target>(v);
+}
+
+/** Polymorphic down cast between two types
+ *
+ * @warning Will assert if cannot take place
+ *
+ * @tparam Target Target to cast type
+ * @tparam Source Source from cast type
+ *
+ * @param[in] v Value to cast
+ *
+ * @return The casted type
+ */
+template <typename Target, typename Source>
+inline Target polymorphic_downcast(Source *v)
+{
+    ARM_COMPUTE_ERROR_ON(dynamic_cast<Target>(v) != static_cast<Target>(v));
+    return static_cast<Target>(v);
+}
+} // namespace cast
+} // namespace utils
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_MISC_CAST_H__ */
diff --git a/arm_compute/core/utils/misc/Iterable.h b/arm_compute/core/utils/misc/Iterable.h
new file mode 100644
index 0000000000..96a650af35
--- /dev/null
+++ b/arm_compute/core/utils/misc/Iterable.h
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_MISC_ITERABLE_H__
+#define __ARM_COMPUTE_MISC_ITERABLE_H__
+
+#include <iterator>
+
+namespace arm_compute
+{
+namespace utils
+{
+namespace iterable
+{
+/** Reverse range iterable class
+ *
+ * @tparam T Type to create a reverse range on
+ */
+template <typename T>
+class reverse_iterable
+{
+public:
+    /** Default constructor
+     *
+     * @param[in] it Value to reverse iterate on
+     */
+    explicit reverse_iterable(T &it)
+        : _it(it)
+    {
+    }
+
+    typename T::reverse_iterator begin()
+    {
+        return _it.rbegin();
+    }
+
+    typename T::reverse_iterator end()
+    {
+        return _it.rend();
+    }
+
+    typename T::const_reverse_iterator cbegin()
+    {
+        return _it.rbegin();
+    }
+
+    typename T::const_reverse_iterator cend()
+    {
+        return _it.rend();
+    }
+
+private:
+    T &_it;
+};
+
+/** Creates a reverse iterable for a given type
+ *
+ * @tparam T Type to create a reverse iterable on
+ *
+ * @param[in] val Iterable input
+ *
+ * @return Reverse iterable container
+ */
+template <typename T>
+reverse_iterable<T> reverse_iterate(T &val)
+{
+    return reverse_iterable<T>(val);
+}
+} // namespace iterable
+} // namespace utils
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_MISC_ITERABLE_H__ */
diff --git a/arm_compute/core/utils/misc/ShapeCalculator.h b/arm_compute/core/utils/misc/ShapeCalculator.h
index 2919625511..354f60d016 100644
--- a/arm_compute/core/utils/misc/ShapeCalculator.h
+++ b/arm_compute/core/utils/misc/ShapeCalculator.h
@@ -174,7 +174,6 @@ inline TensorShape compute_interleave_custom_shape(const TensorShape &input, con
 
     return output_shape;
 }
-
 inline TensorShape compute_fully_connected_reshaped_weights_shape(const ITensorInfo *input, bool transpose_weights, bool is_batched_fc_layer, const int interleave)
 {
     TensorShape output_shape{ input->tensor_shape() };
@@ -194,7 +193,6 @@ inline TensorShape compute_fully_connected_reshaped_weights_shape(const ITensorI
 
     return output_shape;
 }
-
 inline TensorShape compute_winograd_input_transform_shape(const ITensorInfo &input, const PadStrideInfo &conv_info, const Size2D &kernel_size)
 {
     // Compute height
@@ -212,6 +210,22 @@ inline TensorShape compute_winograd_input_transform_shape(const ITensorInfo &inp
 
     return output_shape;
 }
+inline TensorShape compute_deep_convolution_shape(const ITensorInfo &input, const ITensorInfo &weights, PadStrideInfo conv_info)
+{
+    const TensorShape input_shape{ input.tensor_shape() };
+    const TensorShape weights_shape{ weights.tensor_shape() };
+
+    unsigned int output_width  = 0;
+    unsigned int output_height = 0;
+    std::tie(output_width, output_height) = scaled_dimensions(input_shape.x(), input_shape.y(), weights_shape.x(), weights_shape.y(), conv_info);
+
+    TensorShape output_shape{ input_shape };
+    output_shape.set(0, output_width);
+    output_shape.set(1, output_height);
+    output_shape.set(2, weights_shape[3]);
+
+    return output_shape;
+}
 } // namespace shape_calculator
 } // namespace misc
 } // namespace arm_compute
diff --git a/arm_compute/core/utils/misc/utility.h b/arm_compute/core/utils/misc/Utility.h
index 8ba92310da..639f2e155d 100644
--- a/arm_compute/core/utils/misc/utility.h
+++ b/arm_compute/core/utils/misc/Utility.h
@@ -164,7 +164,6 @@ std::vector<size_t> sort_indices(const std::vector<T> &v)
 
     return idx;
 }
-
 } // namespace utility
 } // namespace arm_compute
 #endif /* __ARM_COMPUTE_MISC_UTILITY_H__ */
diff --git a/arm_compute/core/utils/strong_type/StrongType.h b/arm_compute/core/utils/strong_type/StrongType.h
new file mode 100644
index 0000000000..5a38edbbd6
--- /dev/null
+++ b/arm_compute/core/utils/strong_type/StrongType.h
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_STRONG_TYPE_STRONG_TYPE_H__
+#define __ARM_COMPUTE_STRONG_TYPE_STRONG_TYPE_H__
+
+#include <type_traits>
+
+namespace arm_compute
+{
+namespace strong_type
+{
+/** Strong type
+ *
+ * @tparam T           Exact type of the Strong Type
+ * @tparam Tag         Tag used to distinguish between types with same T
+ * @tparam Attributes  Attributes of the Strong Type
+ */
+template <typename T, typename Tag, template <typename> class... Attributes>
+class StrongType : public Attributes<StrongType<T, Tag, Attributes...>>...
+{
+public:
+    /** Exact underlying type **/
+    using ExactType = T;
+
+public:
+    /** Default Constructor
+     *
+     * @param[in] val Initialization value
+     */
+    StrongType(T val)
+        : _val(val)
+    {
+    }
+    /** Accessor of the value of the exact type
+     *
+     * @return Exact type value
+     */
+    T &get()
+    {
+        return _val;
+    }
+    /** Accessor of the value of the exact type
+     *
+     * @return Exact type value
+     */
+    const T &get() const
+    {
+        return _val;
+    }
+
+private:
+    T _val = {};
+};
+} // namespace strong_type
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_STRONG_TYPE_STRONG_TYPE_H__ */
diff --git a/arm_compute/core/utils/strong_type/StrongTypeAttributes.h b/arm_compute/core/utils/strong_type/StrongTypeAttributes.h
new file mode 100644
index 0000000000..b5ed48f5ce
--- /dev/null
+++ b/arm_compute/core/utils/strong_type/StrongTypeAttributes.h
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_STRONG_TYPE_STRONG_TYPE_ATTRIBUTES_H__
+#define __ARM_COMPUTE_STRONG_TYPE_STRONG_TYPE_ATTRIBUTES_H__
+
+#include "arm_compute/core/utils/misc/CRTP.h"
+
+namespace arm_compute
+{
+namespace strong_type
+{
+/** Comparable attribute */
+template <typename T>
+struct Comparable : misc::CRTP<T, Comparable>
+{
+    bool operator==(T const &other) const
+    {
+        return this->impl().get() == other.get();
+    }
+    bool operator!=(T const &other) const
+    {
+        return !(*this == other);
+    }
+    bool operator>(T const &other) const
+    {
+        return this->impl().get() > other.get();
+    }
+    bool operator<(T const &other) const
+    {
+        return this->impl().get() < other.get();
+    }
+    bool operator>=(T const &other) const
+    {
+        return !(*this < other);
+    }
+    bool operator<=(T const &other) const
+    {
+        return !(*this > other);
+    }
+};
+} // namespace strong_type
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_STRONG_TYPE_STRONG_TYPE_ATTRIBUTES_H__ */
diff --git a/arm_compute/graph/nodes/BranchLayer.h b/arm_compute/graph/nodes/BranchLayer.h
index 5e4a8d98b1..cbc016d043 100644
--- a/arm_compute/graph/nodes/BranchLayer.h
+++ b/arm_compute/graph/nodes/BranchLayer.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017 ARM Limited.
+ * Copyright (c) 2017-2018 ARM Limited.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -31,7 +31,7 @@
 #include "arm_compute/graph/SubTensor.h"
 #include "arm_compute/graph/Types.h"
 
-#include "arm_compute/core/utils/misc/utility.h"
+#include "arm_compute/core/utils/misc/Utility.h"
 
 #include <vector>
 
diff --git a/arm_compute/graph/nodes/ResidualLayer.h b/arm_compute/graph/nodes/ResidualLayer.h
index 1eecf6f996..27e0501739 100644
--- a/arm_compute/graph/nodes/ResidualLayer.h
+++ b/arm_compute/graph/nodes/ResidualLayer.h
@@ -30,7 +30,7 @@
 #include "arm_compute/graph/SubGraph.h"
 #include "arm_compute/graph/Types.h"
 
-#include "arm_compute/core/utils/misc/utility.h"
+#include "arm_compute/core/utils/misc/Utility.h"
 
 #include <vector>
 
diff --git a/arm_compute/graph2.h b/arm_compute/graph2.h
new file mode 100644
index 0000000000..5f54990ba8
--- /dev/null
+++ b/arm_compute/graph2.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_H__
+#define __ARM_COMPUTE_GRAPH2_H__
+
+// IR
+#include "arm_compute/graph2/Edge.h"
+#include "arm_compute/graph2/Graph.h"
+#include "arm_compute/graph2/GraphBuilder.h"
+#include "arm_compute/graph2/IDeviceBackend.h"
+#include "arm_compute/graph2/IGraphMutator.h"
+#include "arm_compute/graph2/IGraphPrinter.h"
+#include "arm_compute/graph2/INode.h"
+#include "arm_compute/graph2/INodeVisitor.h"
+#include "arm_compute/graph2/Logger.h"
+#include "arm_compute/graph2/Tensor.h"
+#include "arm_compute/graph2/TensorDescriptor.h"
+#include "arm_compute/graph2/TypePrinter.h"
+#include "arm_compute/graph2/Types.h"
+
+// Algorithms
+#include "arm_compute/graph2/algorithms/Algorithms.h"
+#include "arm_compute/graph2/mutators/GraphMutators.h"
+#include "arm_compute/graph2/nodes/Nodes.h"
+#include "arm_compute/graph2/printers/Printers.h"
+
+// Frontend
+#include "arm_compute/graph2/frontend/IStreamOperators.h"
+#include "arm_compute/graph2/frontend/Layers.h"
+#include "arm_compute/graph2/frontend/Stream.h"
+#include "arm_compute/graph2/frontend/SubStream.h"
+#include "arm_compute/graph2/frontend/Types.h"
+
+#endif /* __ARM_COMPUTE_GRAPH2_H__ */
diff --git a/arm_compute/graph2/Edge.h b/arm_compute/graph2/Edge.h
new file mode 100644
index 0000000000..e82bcb295a
--- /dev/null
+++ b/arm_compute/graph2/Edge.h
@@ -0,0 +1,152 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_EDGE_H__
+#define __ARM_COMPUTE_GRAPH2_EDGE_H__
+
+#include "arm_compute/graph2/INode.h"
+#include "arm_compute/graph2/Tensor.h"
+#include "arm_compute/graph2/Types.h"
+
+namespace arm_compute
+{
+namespace graph2
+{
+// Forward declarations
+class Graph;
+
+/** Graph Edge */
+class Edge final
+{
+public:
+    /** Default Constructor
+     *
+     * @param[in] id           Edge id
+     * @param[in] producer     Producer node id
+     * @param[in] producer_idx Producer node output index
+     * @param[in] consumer     Consumer node id
+     * @param[in] consumer_idx Consumer node input index
+     * @param[in] tensor       Tensor associated with the edge
+     */
+    Edge(EdgeID id, INode *producer, unsigned int producer_idx, INode *consumer, unsigned int consumer_idx, Tensor *tensor)
+        : _id(id), _producer(producer), _consumer(consumer), _producer_idx(producer_idx), _consumer_idx(consumer_idx), _tensor(tensor)
+
+    {
+    }
+    /** Returns edge id
+     *
+     * @return Edge id
+     */
+    EdgeID id() const
+    {
+        return _id;
+    }
+    /** Returns producer node id
+     *
+     * @return Producer node id
+     */
+    NodeID producer_id() const
+    {
+        return (_producer == nullptr) ? EmptyNodeID : _producer->id();
+    }
+    /** Returns sink node id
+     *
+     * @return Sink node id
+     */
+    NodeID consumer_id() const
+    {
+        return (_consumer == nullptr) ? EmptyNodeID : _consumer->id();
+    }
+    /** Returns producer node
+     *
+     * @return Producer node
+     */
+    INode *producer() const
+    {
+        return _producer;
+    }
+    /** Returns consumer node
+     *
+     * @return Consumer node
+     */
+    INode *consumer() const
+    {
+        return _consumer;
+    }
+    /** Returns the index of the output that produces the result in the producer node
+     *
+     * @return Producer node output index
+     */
+    unsigned int producer_idx() const
+    {
+        return _producer_idx;
+    }
+    /** Returns the index of the input that consumes the result in the consumer node
+     *
+     * @return Consumer node input index
+     */
+    unsigned int consumer_idx() const
+    {
+        return _consumer_idx;
+    }
+    /** Returns the tensor associated with this edge
+     *
+     * @return Tensor id
+     */
+    Tensor *tensor() const
+    {
+        return _tensor;
+    }
+    /** Returns the tensor id associated with this edge
+     *
+     * @return Tensor id
+     */
+    TensorID tensor_id() const
+    {
+        return (_tensor == nullptr) ? NullTensorID : _tensor->id();
+    }
+    /** Bind the edge to another tensor
+     *
+     * @note If tensor is nullptr then nothing happens
+     *
+     * @param[in] tensor Tensor to bind the edge to
+     */
+    void update_bound_tensor(Tensor *tensor)
+    {
+        _tensor = (tensor != nullptr) ? tensor : _tensor;
+    }
+
+private:
+    friend class Graph;
+
+private:
+    EdgeID       _id;
+    INode       *_producer;
+    INode       *_consumer;
+    unsigned int _producer_idx;
+    unsigned int _consumer_idx;
+    Tensor      *_tensor;
+};
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_EDGE_H__ */
diff --git a/arm_compute/graph2/Graph.h b/arm_compute/graph2/Graph.h
new file mode 100644
index 0000000000..a601598e97
--- /dev/null
+++ b/arm_compute/graph2/Graph.h
@@ -0,0 +1,262 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_GRAPH_H__
+#define __ARM_COMPUTE_GRAPH2_GRAPH_H__
+
+#include "arm_compute/graph2/Edge.h"
+#include "arm_compute/graph2/INode.h"
+#include "arm_compute/graph2/Tensor.h"
+#include "arm_compute/graph2/Types.h"
+
+#include "support/Mutex.h"
+#include "support/ToolchainSupport.h"
+
+#include <map>
+#include <memory>
+#include <string>
+#include <thread>
+#include <utility>
+#include <vector>
+
+namespace arm_compute
+{
+namespace graph2
+{
+/** Graph class
+ *
+ * Represents a multiple source - multiple sink directed graph
+ */
+class Graph final
+{
+public:
+    Graph() = default;
+    /** Constructor
+     *
+     * @param[in] id   Graph identification number. Can be used to differentiate between graphs. Default value 0
+     * @param[in] name Graph name. Default value empty string
+     */
+    Graph(GraphID id, std::string name);
+    /** Prevent instances of this class from being copied (As this class contains pointers) */
+    Graph(const Graph &) = delete;
+    /** Prevent instances of this class from being copy assigned (As this class contains pointers) */
+    Graph &operator=(const Graph &) = delete;
+    /** Allow instances of this class to be moved */
+    Graph(Graph &&) = default;
+    /** Allow instances of this class to be move assigned */
+    Graph &operator=(Graph &&) = default;
+    /** Adds a node to the graph
+     *
+     * @note Models a single output node
+     *
+     * @tparam NT Node operation
+     * @tparam Ts Arguments to operation
+     *
+     * @param args Node arguments
+     *
+     * @return ID of the node
+     */
+    template <typename NT, typename... Ts>
+    NodeID add_node(Ts &&... args);
+    /** Remove the node with the given ID
+     *
+     * @param[in] nid ID of the node to remove
+     *
+     * @return True if the removal took place else false
+     */
+    bool remove_node(NodeID nid);
+    /** Adds a connection between two nodes
+     *
+     * @param[in] source     ID of the source node
+     * @param[in] source_idx Output index of the source node
+     * @param[in] sink       ID of the sink node
+     * @param[in] sink_idx   Input index of the sink node
+     *
+     * @return ID of this connection
+     */
+    EdgeID add_connection(NodeID source, size_t source_idx, NodeID sink, size_t sink_idx);
+    /** Removes an edge (connection)
+     *
+     * @param[in] eid Connection to remove
+     *
+     * @return True if the removal took place else false
+     */
+    bool remove_connection(EdgeID eid);
+    /** Returns graph name
+     *
+     * @return Graph name
+     */
+    std::string name() const;
+    /** Returns graph id
+     *
+     * @return Graph id
+     */
+    GraphID id() const;
+    /** Returns graph input nodes
+     *
+     * @return vector containing the graph inputs
+     */
+    const std::vector<NodeID> &inputs();
+    /** Returns nodes of graph
+     *
+     * @warning Nodes can be nullptr if they have been removed during the mutation steps of the graph
+     *
+     * @return Nodes of graph
+     */
+    std::vector<std::unique_ptr<INode>> &nodes();
+    /** Returns nodes of graph
+     *
+     * @warning Nodes can be nullptr if they have been removed during the mutation steps of the graph
+     *
+     * @return Nodes of graph
+     */
+    const std::vector<std::unique_ptr<INode>> &nodes() const;
+    /** Returns edges of graph
+     *
+     * @warning Edges can be nullptr if they have been removed during the mutation steps of the graph
+     *
+     * @return Edges of graph
+     */
+    const std::vector<std::unique_ptr<Edge>> &edges() const;
+    /** Returns tensors of graph
+     *
+     * @warning Tensor can be nullptr if they have been removed during the mutation steps of the graph
+     *
+     * @return Tensors of graph
+     */
+    std::vector<std::unique_ptr<Tensor>> &tensors();
+    /** Returns tensors of graph
+     *
+     * @warning Tensor can be nullptr if they have been removed during the mutation steps of the graph
+     *
+     * @return Tensors of graph
+     */
+    const std::vector<std::unique_ptr<Tensor>> &tensors() const;
+    /** Get node object given its id
+     *
+     * @warning Can be nullptr if node was removed during the mutation steps of the graph
+     *
+     * @param[in] id Node ID
+     *
+     * @return The actual node object
+     */
+    const INode *node(NodeID id) const;
+    /** Get node object given its id
+     *
+     * @warning Can be nullptr if node was removed during the mutation steps of the graph
+     *
+     * @param[in] id Node ID
+     *
+     * @return The actual node object
+     */
+    INode *node(NodeID id);
+    /** Get edge object given its id
+     *
+     * @warning Can be nullptr if node was removed during the mutation steps of the graph
+     *
+     * @param[in] id Edge ID
+     *
+     * @return The actual edge object
+     */
+    const Edge *edge(EdgeID id) const;
+    /** Get edge object given its id
+     *
+     * @warning Can be nullptr if node was removed during the mutation steps of the graph
+     *
+     * @param[in] id Edge ID
+     *
+     * @return The actual edge object
+     */
+    Edge *edge(EdgeID id);
+    /** Get tensor object given its id
+     *
+     * @warning Can be nullptr if tensor was removed during the mutation steps of the graph
+     *
+     * @param[in] id Tensor ID
+     *
+     * @return The actual tensor object
+     */
+    const Tensor *tensor(TensorID id) const;
+    /** Get tensor object given its id
+     *
+     * @warning Can be nullptr if tensor was removed during the mutation steps of the graph
+     *
+     * @param[in] id Tensor ID
+     *
+     * @return The actual tensor object
+     */
+    Tensor *tensor(TensorID id);
+
+private:
+    /** Creates a tensor object
+     *
+     * @param[in] desc Tensor descriptor
+     *
+     * @return Tensor ID
+     */
+    TensorID create_tensor(TensorDescriptor desc = TensorDescriptor());
+
+private:
+    GraphID                              _id      = GraphID(0); /**< Graph id */
+    std::string                          _name    = {};         /**< Graph name */
+    std::vector<std::unique_ptr<INode>>  _nodes   = {};         /**< Graph nodes */
+    std::vector<std::unique_ptr<Edge>>   _edges   = {};         /**< Graph edges */
+    std::vector<std::unique_ptr<Tensor>> _tensors = {};         /**< Graph tensors */
+    std::map<NodeType, std::vector<NodeID>> _tagged_nodes = {}; /**< Graph nodes map with the node type as key */
+    arm_compute::Mutex _mtx = {};                               /**< Mutex used for graph construction */
+};
+
+template <typename NT, typename... Ts>
+inline NodeID Graph::add_node(Ts &&... args)
+{
+    std::lock_guard<arm_compute::Mutex> lock(_mtx);
+
+    // Create node
+    NodeID nid  = _nodes.size();
+    auto   node = support::cpp14::make_unique<NT>(std::forward<Ts>(args)...);
+    node->set_graph(this);
+    node->set_id(nid);
+
+    // Keep track of input nodes
+    if(node->type() == NodeType::Input)
+    {
+        _tagged_nodes[NodeType::Input].push_back(nid);
+    }
+
+    // Associate a new tensor with each output
+    for(auto &output : node->_outputs)
+    {
+        output = create_tensor();
+    }
+
+    // Propagate node shape if possible
+    node->forward_descriptors();
+
+    // Add node to the graph nodes
+    _nodes.push_back(std::move(node));
+
+    return nid;
+}
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_GRAPH_H__ */
diff --git a/arm_compute/graph2/GraphBuilder.h b/arm_compute/graph2/GraphBuilder.h
new file mode 100644
index 0000000000..f92746a603
--- /dev/null
+++ b/arm_compute/graph2/GraphBuilder.h
@@ -0,0 +1,220 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_GRAPH_BUILDER_H__
+#define __ARM_COMPUTE_GRAPH2_GRAPH_BUILDER_H__
+
+#include "arm_compute/graph2/ITensorAccessor.h"
+#include "arm_compute/graph2/Types.h"
+
+namespace arm_compute
+{
+namespace graph2
+{
+// Forward declaration
+class Graph;
+
+/** Graph builder class
+ *
+ * Builds and compiles a graph
+ */
+class GraphBuilder final
+{
+public:
+    /** Adds a Const node to the graph
+     *
+     * @param[in] g        Graph to add the node to
+     * @param[in] params   Common node parameters
+     * @param[in] desc     Tensor descriptor of the node
+     * @param[in] accessor (Optional) Accessor of the const node data
+     *
+     * @return Node ID of the created node, EmptyNodeID in case of error
+     */
+    static NodeID add_const_node(Graph &g, NodeParams params, TensorDescriptor desc, ITensorAccessorUPtr accessor = nullptr);
+    /** Adds an input layer node to the graph
+     *
+     * @param[in] g        Graph to add the node to
+     * @param[in] params   Common node parameters
+     * @param[in] desc     Tensor descriptor of the Tensor
+     * @param[in] accessor (Optional) Accessor of the input node data
+     *
+     * @return Node ID of the created node, EmptyNodeID in case of error
+     */
+    static NodeID add_input_node(Graph &g, NodeParams params, TensorDescriptor desc, ITensorAccessorUPtr accessor = nullptr);
+    /** Adds an output layer node to the graph
+     *
+     * @param[in] g        Graph to add the node to
+     * @param[in] params   Common node parameters
+     * @param[in] input    Input to the output node as a NodeID-Index pair
+     * @param[in] accessor (Optional) Accessor of the output node data
+     *
+     * @return Node ID of the created node, EmptyNodeID in case of error
+     */
+    static NodeID add_output_node(Graph &g, NodeParams params, NodeIdxPair input, ITensorAccessorUPtr accessor = nullptr);
+    /** Adds an activation layer node to the graph
+     *
+     * @param[in] g        Graph to add the node to
+     * @param[in] params   Common node parameters
+     * @param[in] input    Input to the activation layer node as a NodeID-Index pair
+     * @param[in] act_info Activation layer information
+     *
+     * @return Node ID of the created node, EmptyNodeID in case of error
+     */
+    static NodeID add_activation_node(Graph &g, NodeParams params, NodeIdxPair input, ActivationLayerInfo act_info);
+    /** Adds a batch normalization layer node to the graph
+     *
+     * @param[in] g              Graph to add the node to
+     * @param[in] params         Common node parameters
+     * @param[in] input          Input to the batch normalization layer node as a NodeID-Index pair
+     * @param[in] epsilon        Epsilon parameter
+     * @param[in] mean_accessor  Const Node ID that contains the mean values
+     * @param[in] var_accessor   Const Node ID that contains the variance values
+     * @param[in] beta_accessor  Const Node ID that contains the beta values. Can be EmptyNodeID
+     * @param[in] gamma_accessor Const Node ID that contains the gamma values. Can be EmptyNodeID
+     *
+     * @return Node ID of the created node, EmptyNodeID in case of error
+     */
+    static NodeID add_batch_normalization_node(Graph &g, NodeParams params, NodeIdxPair input, float epsilon,
+                                               ITensorAccessorUPtr mean_accessor = nullptr, ITensorAccessorUPtr var_accessor = nullptr,
+                                               ITensorAccessorUPtr beta_accessor = nullptr, ITensorAccessorUPtr gamma_accessor = nullptr);
+    /** Adds a convolution layer node to the graph
+     *
+     * @param[in] g                     Graph to add the node to
+     * @param[in] params                Common node parameters
+     * @param[in] input                 Input to the batch normalization layer node as a NodeID-Index pair
+     * @param[in] kernel_spatial_extend Spatial extend of convolution kernels
+     * @param[in] depth                 Number of convolution kernels
+     * @param[in] conv_info             Convolution layer information
+     * @param[in] method                (Optional) Convolution method to use
+     * @param[in] weights_accessor      (Optional) Accessor of the weights node data
+     * @param[in] bias_accessor         (Optional) Accessor of the bias node data
+     *
+     * @return Node ID of the created node, EmptyNodeID in case of error
+     */
+    static NodeID add_convolution_node(Graph &g, NodeParams params, NodeIdxPair input,
+                                       Size2D kernel_spatial_extend, unsigned int depth, PadStrideInfo conv_info,
+                                       ConvolutionMethod   method           = ConvolutionMethod::DEFAULT,
+                                       ITensorAccessorUPtr weights_accessor = nullptr, ITensorAccessorUPtr bias_accessor = nullptr);
+    /** Adds a depth concatenate node to the graph
+     *
+     * @param[in] g      Graph to add the node to
+     * @param[in] params Common node parameters
+     * @param[in] inputs Input to the batch normalization layer node as a NodeID-Index pair
+     *
+     * @return Node ID of the created node, EmptyNodeID in case of error
+     */
+    static NodeID add_depth_concatenate_node(Graph &g, NodeParams params, std::vector<NodeIdxPair> inputs);
+    /** Adds a depth-wise convolution layer node to the graph
+     *
+     * @param[in] g                     Graph to add the node to
+     * @param[in] params                Common node parameters
+     * @param[in] input                 Input to the batch normalization layer node as a NodeID-Index pair
+     * @param[in] kernel_spatial_extend Spatial extend of convolution kernels
+     * @param[in] conv_info             Convolution layer information
+     * @param[in] method                (Optional) Convolution method to use
+     * @param[in] weights_accessor      (Optional) Accessor of the weights node data
+     * @param[in] bias_accessor         (Optional) Accessor of the bias node data
+     *
+     * @return Node ID of the created node, EmptyNodeID in case of error
+     */
+    static NodeID add_depthwise_convolution_node(Graph &g, NodeParams params, NodeIdxPair input,
+                                                 Size2D kernel_spatial_extend, PadStrideInfo conv_info,
+                                                 DepthwiseConvolutionMethod method    = DepthwiseConvolutionMethod::DEFAULT,
+                                                 ITensorAccessorUPtr weights_accessor = nullptr, ITensorAccessorUPtr bias_accessor = nullptr);
+    /** Adds an element-wise layer node to the graph
+     *
+     * @param[in] g         Graph to add the node to
+     * @param[in] params    Common node parameters
+     * @param[in] input0    First input to the element-wise operation layer node as a NodeID-Index pair
+     * @param[in] input1    Second input to the element-wise operation layer node as a NodeID-Index pair
+     * @param[in] operation Element-wise operation to perform
+     *
+     * @return Node ID of the created node, EmptyNodeID in case of error
+     */
+    static NodeID add_elementwise_node(Graph &g, NodeParams params, NodeIdxPair input0, NodeIdxPair input1, EltwiseOperation operation);
+    /** Adds a flatten layer node to the graph
+     *
+     * @param[in] g      Graph to add the node to
+     * @param[in] params Common node parameters
+     * @param[in] input  Input to the batch normalization layer node as a NodeID-Index pair
+     *
+     * @return Node ID of the created node, EmptyNodeID in case of error
+     */
+    static NodeID add_flatten_node(Graph &g, NodeParams params, NodeIdxPair input);
+    /** Adds a fully connected layer node to the graph
+     *
+     * @param[in] g                Graph to add the layer to
+     * @param[in] params           Common node parameters
+     * @param[in] input            Input to the batch normalization layer node as a NodeID-Index pair
+     * @param[in] num_outputs      Number of output neurons
+     * @param[in] weights_accessor (Optional) Accessor of the weights node data
+     * @param[in] bias_accessor    (Optional) Accessor of the bias node data
+     *
+     * @return Node ID of the created node, EmptyNodeID in case of error
+     */
+    static NodeID add_fully_connected_layer(Graph &g, NodeParams params, NodeIdxPair input, unsigned int num_outputs,
+                                            ITensorAccessorUPtr weights_accessor = nullptr, ITensorAccessorUPtr bias_accessor = nullptr);
+    /** Adds a normalization layer node to the graph
+     *
+     * @param[in] g         Graph to add the node to
+     * @param[in] params    Common node parameters
+     * @param[in] input     Input to the batch normalization layer node as a NodeID-Index pair
+     * @param[in] norm_info Normalization layer information
+     *
+     * @return Node ID of the created node, EmptyNodeID in case of error
+     */
+    static NodeID add_normalization_node(Graph &g, NodeParams params, NodeIdxPair input, NormalizationLayerInfo norm_info);
+    /** Adds a pooling layer node to the graph
+     *
+     * @param[in] g         Graph to add the node to
+     * @param[in] params    Common node parameters
+     * @param[in] input     Input to the batch normalization layer node as a NodeID-Index pair
+     * @param[in] pool_info Pooling layer information
+     *
+     * @return Node ID of the created node, EmptyNodeID in case of error
+     */
+    static NodeID add_pooling_node(Graph &g, NodeParams params, NodeIdxPair input, PoolingLayerInfo pool_info);
+    /** Adds a reshape layer node to the graph
+     *
+     * @param[in] g      Graph to add the node to
+     * @param[in] params Common node parameters
+     * @param[in] input  Input to the batch normalization layer node as a NodeID-Index pair
+     * @param[in] shape  Output reshaped shape
+     *
+     * @return Node ID of the created node, EmptyNodeID in case of error
+     */
+    static NodeID add_reshape_node(Graph &g, NodeParams params, NodeIdxPair input, TensorShape shape);
+    /** Adds a softmax node to the graph
+     *
+     * @param[in] g      Graph to add the node to
+     * @param[in] params Common node parameters
+     * @param[in] input  Input to the batch normalization layer node as a NodeID-Index pair
+     * @param[in] beta   Beta parameter
+     *
+     * @return Node ID of the created node, EmptyNodeID in case of error
+     */
+    static NodeID add_softmax_node(Graph &g, NodeParams params, NodeIdxPair input, float beta = 1.f);
+};
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_GRAPH_BUILDER_H__ */
diff --git a/arm_compute/graph2/GraphContext.h b/arm_compute/graph2/GraphContext.h
new file mode 100644
index 0000000000..bd579eaca2
--- /dev/null
+++ b/arm_compute/graph2/GraphContext.h
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_GRAPH_CONTEXT_H__
+#define __ARM_COMPUTE_GRAPH2_GRAPH_CONTEXT_H__
+
+#include "arm_compute/graph2/Types.h"
+
+#include "arm_compute/runtime/IMemoryManager.h"
+
+#include <map>
+#include <memory>
+
+namespace arm_compute
+{
+namespace graph2
+{
+/** Contains structs required for memory management */
+struct MemoryManagerContext
+{
+    Target                                       target = { Target::UNSPECIFIED };
+    std::shared_ptr<arm_compute::IMemoryManager> mm     = { nullptr };
+};
+
+/** Graph context **/
+class GraphContext final
+{
+public:
+    /** Constructor */
+    GraphContext();
+    /** Prevent instances of this class from being copied (As this class contains pointers) */
+    GraphContext(const GraphContext &) = delete;
+    /** Default move constructor */
+    GraphContext(GraphContext &&) = default;
+    /** Prevent instances of this class from being copied (As this class contains pointers) */
+    GraphContext &operator=(const GraphContext &) = delete;
+    /** Default move assignment operator */
+    GraphContext &operator=(GraphContext &&) = default;
+    /** Enables tuning
+     *
+     * @param[in] enable_tuning Enables tuning if true
+     */
+    void enable_tuning(bool enable_tuning);
+    /** Checks if tuning is enabled
+     *
+     * @return True if tuning is enabled else false
+     */
+    bool is_tuning_enabled() const;
+    /** Enables memory management
+     *
+     * @param[in] enable_mm Enables mm if true
+     */
+    void enable_memory_managenent(bool enable_mm);
+    /** Checks if memory management is enabled
+     *
+     * @return True if memory management is enabled else false
+     */
+    bool is_memory_management_enabled();
+    /** Inserts a memory manager context
+     *
+     * @param[in] memory_ctx Memory manage context
+     *
+     * @return If the insertion succeeded else false
+     */
+    bool insert_memory_management_ctx(MemoryManagerContext &&memory_ctx);
+    /** Gets a memory manager context for a given target
+     *
+     * @param[in] target To retrieve the management context
+     *
+     * @return Management context for the target if exists else nullptr
+     */
+    MemoryManagerContext *memory_management_ctx(Target target);
+    /** Finalizes memory managers in graph context */
+    void finalize();
+
+private:
+    bool _tunable;                                           /**< Specifies if the Graph should use a tunable object */
+    bool _memory_managed;                                    /**< Specifies if the Graph should use a memory managed */
+    std::map<Target, MemoryManagerContext> _memory_managers; /**< Memory managers for each target */
+};
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_GRAPH_CONTEXT_H__ */
diff --git a/arm_compute/graph2/GraphManager.h b/arm_compute/graph2/GraphManager.h
new file mode 100644
index 0000000000..0d5835f6a4
--- /dev/null
+++ b/arm_compute/graph2/GraphManager.h
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_GRAPH_MANAGER_H__
+#define __ARM_COMPUTE_GRAPH2_GRAPH_MANAGER_H__
+
+#include "arm_compute/graph2/Types.h"
+#include "arm_compute/graph2/Workload.h"
+
+#include <map>
+
+namespace arm_compute
+{
+namespace graph2
+{
+// Forward declaration
+class Graph;
+class GraphContext;
+class PassManager;
+
+/** Graph manager class
+ *
+ * Manages a list of graphs along with their resources
+ */
+class GraphManager final
+{
+public:
+    /** Default Constructor **/
+    GraphManager();
+    /** Prevent instances of this class from being copied (As this class contains pointers) */
+    GraphManager(const GraphManager &) = delete;
+    /** Default move constructor */
+    GraphManager(GraphManager &&) = default;
+    /** Prevent instances of this class from being copied (As this class contains pointers) */
+    GraphManager &operator=(const GraphManager &) = delete;
+    /** Default move assignment operator */
+    GraphManager &operator=(GraphManager &&) = default;
+    /** Finalizes a given graph
+     *
+     * @warning At this given time finalize_graph will alter the passed graph,
+     *          plan is to avoid by copying the graph structure,
+     *          or provide another entry-point for this functionality as it will increase the memory requirements
+     *
+     * @param[in] graph  Graph to finalize
+     * @param[in] ctx    Graph context
+     * @param[in] pm     Pass manager to use for any optimization passes
+     * @param[in] target Execution target (Single target execution is currently supported)
+     */
+    void finalize_graph(Graph &graph, GraphContext &ctx, PassManager &pm, Target target);
+    /** Executes a graph
+     *
+     * @param[in] graph Graph to execute
+     */
+    void execute_graph(Graph &graph);
+    /** Invalidates the graph execution workload
+     *
+     * @param[in] graph Graph to invalidate
+     */
+    void invalidate_graph(Graph &graph);
+
+private:
+    std::map<GraphID, ExecutionWorkload> _workloads = {}; /**< Graph workloads */
+};
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_GRAPH_MANAGER_H__ */
diff --git a/arm_compute/graph2/IDeviceBackend.h b/arm_compute/graph2/IDeviceBackend.h
new file mode 100644
index 0000000000..771ff85011
--- /dev/null
+++ b/arm_compute/graph2/IDeviceBackend.h
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_IDEVICEBACKEND_H__
+#define __ARM_COMPUTE_GRAPH2_IDEVICEBACKEND_H__
+
+#include "arm_compute/graph2/ITensorHandle.h"
+#include "arm_compute/graph2/Types.h"
+#include "arm_compute/runtime/IFunction.h"
+#include "arm_compute/runtime/IMemoryManager.h"
+
+#include <memory>
+
+namespace arm_compute
+{
+namespace graph2
+{
+// Forward declarations
+class Graph;
+class GraphContext;
+class Tensor;
+class INode;
+
+namespace backends
+{
+/** Device backend interface */
+class IDeviceBackend
+{
+public:
+    /** Virtual Destructor */
+    virtual ~IDeviceBackend() = default;
+    /** Initializes the backend */
+    virtual void initialize_backend() = 0;
+    /** Setups the given graph context
+     *
+     * @param[in] ctx Graph context
+     */
+    virtual void setup_backend_context(GraphContext &ctx) = 0;
+    /** Create a backend Tensor
+     *
+     * @param[in] tensor The tensor we want to create a backend tensor for
+     *
+     * @return Backend tensor handle
+     */
+    virtual std::unique_ptr<ITensorHandle> create_tensor(const Tensor &tensor) = 0;
+    /** Create a backend Sub-Tensor
+     *
+     * @param[in] parent Parent sub-tensor handle
+     * @param[in] shape  Shape of the sub-tensor
+     * @param[in] coords Starting coordinates of the sub-tensor
+     *
+     * @return Backend sub-tensor handle
+     */
+    virtual std::unique_ptr<ITensorHandle> create_subtensor(ITensorHandle *parent, TensorShape shape, Coordinates coords) = 0;
+    /** Configure a backend Node
+     *
+     * @note This creates an appropriate configured backend function for the given node
+     *
+     * @param[in] node The node we want to configure
+     * @param[in] ctx  Context to use
+     *
+     * @return Backend execution function
+     */
+    virtual std::unique_ptr<arm_compute::IFunction> configure_node(INode &node, GraphContext &ctx) = 0;
+    /** Validate a node
+     *
+     * @param[in] node The node we want to validate
+     *
+     * @return An error status
+     */
+    virtual Status validate_node(const INode &node) = 0;
+    /** Create a backend memory manager given its affinity
+     *
+     * @param[in] affinity Memory Manager affinity
+     *
+     * @return Memory manager
+     */
+    virtual std::shared_ptr<arm_compute::IMemoryManager> create_memory_manager(MemoryManagerAffinity affinity) = 0;
+};
+} // namespace backends
+} // namespace graph2
+} // namespace arm_compute
+#endif //__ARM_COMPUTE_GRAPH2_IDEVICEBACKEND_H__
diff --git a/arm_compute/graph2/IGraphMutator.h b/arm_compute/graph2/IGraphMutator.h
new file mode 100644
index 0000000000..50151c87ce
--- /dev/null
+++ b/arm_compute/graph2/IGraphMutator.h
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_IGRAPHMUTATOR_H__
+#define __ARM_COMPUTE_GRAPH2_IGRAPHMUTATOR_H__
+
+namespace arm_compute
+{
+namespace graph2
+{
+// Forward declarations
+class Graph;
+
+/** Graph mutator interface */
+class IGraphMutator
+{
+public:
+    /** Virtual Destructor */
+    virtual ~IGraphMutator() = default;
+    /** Walk the graph and perform a specific mutation
+     *
+     * @param[in, out] g Graph to walk and mutate
+     */
+    virtual void mutate(Graph &g) = 0;
+    /** Returns mutator name
+     *
+     * @return Mutator name
+     */
+    virtual const char *name() = 0;
+};
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_IGRAPHMUTATOR_H__ */
diff --git a/arm_compute/graph2/IGraphPrinter.h b/arm_compute/graph2/IGraphPrinter.h
new file mode 100644
index 0000000000..eb85f97a5b
--- /dev/null
+++ b/arm_compute/graph2/IGraphPrinter.h
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_IGRAPHPRINTER_H__
+#define __ARM_COMPUTE_GRAPH2_IGRAPHPRINTER_H__
+
+#include <ostream>
+
+namespace arm_compute
+{
+namespace graph2
+{
+// Forward declarations
+class Graph;
+
+/** Graph printer interface */
+class IGraphPrinter
+{
+public:
+    /** Virtual Destructor */
+    virtual ~IGraphPrinter() = default;
+    /** Print graph
+     *
+     * @param[in]  g  Graph to print
+     * @param[out] os Output stream
+     */
+    virtual void print(const Graph &g, std::ostream &os) = 0;
+};
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_IGRAPHPRINTER_H__ */
diff --git a/arm_compute/graph2/INode.h b/arm_compute/graph2/INode.h
new file mode 100644
index 0000000000..ba5620ba0e
--- /dev/null
+++ b/arm_compute/graph2/INode.h
@@ -0,0 +1,252 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_INODE_H__
+#define __ARM_COMPUTE_GRAPH2_INODE_H__
+
+#include "arm_compute/core/Error.h"
+#include "arm_compute/graph2/TensorDescriptor.h"
+#include "arm_compute/graph2/Types.h"
+
+#include <set>
+
+namespace arm_compute
+{
+namespace graph2
+{
+// Forward declarations
+class Graph;
+class Edge;
+class INodeVisitor;
+class Tensor;
+
+/** Node interface */
+class INode
+{
+public:
+    /** Constructor */
+    INode();
+    /** Destructor **/
+    virtual ~INode() = default;
+    /** Prevent instances of this class from being copied (As this class contains pointers) */
+    INode(const INode &) = delete;
+    /** Prevent instances of this class from being copy assigned (As this class contains pointers) */
+    INode &operator=(const INode &) = delete;
+    /** Allow instances of this class to be moved */
+    INode(INode &&) = default;
+    /** Allow instances of this class to be move assigned */
+    INode &operator=(INode &&) = default;
+    /** Validate node
+     *
+     * @return Status containing any errors
+     */
+    virtual Status validate() = 0;
+    /** Returns node's type
+     *
+     * @return Node's type
+     */
+    virtual NodeType type() const = 0;
+    /** Accepts a node visitor
+     *
+     * @param[in] v Visitor to accept
+     */
+    virtual void accept(INodeVisitor &v) = 0;
+    /** Forwards descriptor information to outputs if possible
+     *
+     * @return True if descriptor information could be forwarded otherwise false
+     */
+    virtual bool forward_descriptors() = 0;
+    /** Calculates output configuration
+     *
+     * @param[in] idx Output index to configure
+     *
+     * @return Output descriptor configuration
+     */
+    virtual TensorDescriptor configure_output(size_t idx) const = 0;
+    /** Returns node's name
+     *
+     * @return Node name
+     */
+    std::string name() const;
+    /** Returns node's ID
+     *
+     * @return Node's ID
+     */
+    NodeID id() const;
+    /** Returns node's Graph
+     *
+     * @return Node's graph
+     */
+    const Graph *graph() const;
+    /** Returns node's Graph
+     *
+     * @return Node's graph
+     */
+    Graph *graph();
+    /** Sets the graph that this node is registered to
+     *
+     * @param[in] g Back reference to graph
+     */
+    void set_graph(Graph *g);
+    /** Sets the node id
+     *
+     * @param[in] id Node id
+     */
+    void set_id(NodeID id);
+    /** Sets common node parameters
+     *
+     * @param[in] common_params Common node parameters to set
+     */
+    void set_common_node_parameters(NodeParams common_params);
+    /** Sets target preference
+     *
+     * @note This is not the target that the graph executor might choose, its just an indication
+     *
+     * @param[in] target Target preference
+     */
+    void set_requested_target(Target target);
+    /** Sets the final execution target
+     *
+     * @note GraphManager might change this target
+     *
+     * @param[in] target Final execution target
+     */
+    void set_assigned_target(Target target);
+    /** Sets the output tensor of at a given index
+     *
+     * @note All edges will get updated
+     *
+     * @param[in] tid Tensor ID
+     * @param[in] idx Output index
+     */
+    void set_output_tensor(TensorID tid, size_t idx);
+    /** Returns inputs of the node
+     *
+     * @return Inputs of the node
+     */
+    const std::vector<TensorID> &inputs() const;
+    /** Returns outputs of the node
+     *
+     * @return Outputs of the node
+     */
+    const std::vector<TensorID> &outputs() const;
+    /** Returns input edge set
+     *
+     * @return Set of input edges
+     */
+    const std::vector<EdgeID> &input_edges() const;
+    /** Returns output edge set
+     *
+     * @return Set of output edges
+     */
+    const std::set<EdgeID> &output_edges() const;
+    /** Returns the tensor ID of a given input of the node
+     *
+     * @note Precondition : idx should be a valid input index
+     *
+     * @param[in] idx Index of the node input
+     *
+     * @return TensorID of the requested input
+     */
+    TensorID input_id(size_t idx) const;
+    /** Returns the tensor ID of a given output of the node
+     *
+     * @note Precondition : idx should be a valid output index
+     *
+     * @param[in] idx Index of the node output
+     *
+     * @return TensorID of the requested output
+     */
+    TensorID output_id(size_t idx) const;
+    /** Returns the tensor of a given input of the node
+     *
+     * @note Precondition : idx should be a valid input index
+     *
+     * @param[in] idx Index of the node input
+     *
+     * @return Tensor of the requested input
+     */
+    Tensor *input(size_t idx) const;
+    /** Returns the tensor of a given output of the node
+     *
+     * @note Precondition : idx should be a valid output index
+     *
+     * @param[in] idx Index of the node output
+     *
+     * @return Tensor of the requested output
+     */
+    Tensor *output(size_t idx) const;
+    /** Returns the edge ID of a given input of the node
+     *
+     * @note Precondition : idx should be a valid input index
+     *
+     * @param[in] idx Index of the node input
+     *
+     * @return EdgeID of the requested input
+     */
+    EdgeID input_edge_id(size_t idx) const;
+    /** Returns the edge of a given input of the node
+     *
+     * @note Precondition : idx should be a valid input index
+     *
+     * @param[in] idx Index of the node input
+     *
+     * @return Edge of the requested input
+     */
+    Edge *input_edge(size_t idx) const;
+    /** Returns number of inputs of the node
+     *
+     * @return Number of inputs
+     */
+    size_t num_inputs() const;
+    /** Returns number of outputs of the node
+     *
+     * @return Number of outputs
+     */
+    size_t num_outputs() const;
+    /** Returns requested target for this node
+     *
+     * @return Requested execution target
+     */
+    Target requested_target() const;
+    /** Returns assigned target for this node
+     *
+     * @return Assigned target of this node
+     */
+    Target assigned_target() const;
+
+protected:
+    friend class Graph;
+
+protected:
+    Graph                *_graph;           /**< Backward reference to graph owning the node */
+    NodeID                _id;              /**< Node ID */
+    NodeParams            _common_params;   /**< Node common params */
+    std::vector<TensorID> _outputs;         /**< Output of the node */
+    std::vector<EdgeID>   _input_edges;     /**< Inputs edge set */
+    std::set<EdgeID>      _output_edges;    /**< Output edge set */
+    Target                _assigned_target; /**< Assigned target by the Graph executor */
+};
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH_INODE_H__ */
diff --git a/arm_compute/graph2/INodeVisitor.h b/arm_compute/graph2/INodeVisitor.h
new file mode 100644
index 0000000000..429a2584bb
--- /dev/null
+++ b/arm_compute/graph2/INodeVisitor.h
@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_INODEVISITOR_H__
+#define __ARM_COMPUTE_GRAPH2_INODEVISITOR_H__
+
+#include "arm_compute/graph2/nodes/NodesFwd.h"
+
+namespace arm_compute
+{
+namespace graph2
+{
+/**  Node visitor interface */
+class INodeVisitor
+{
+public:
+    virtual ~INodeVisitor()                              = default;
+    virtual void visit(INode &n)                         = 0;
+    virtual void visit(ActivationLayerNode &n)           = 0;
+    virtual void visit(BatchNormalizationLayerNode &n)   = 0;
+    virtual void visit(ConstNode &n)                     = 0;
+    virtual void visit(ConvolutionLayerNode &n)          = 0;
+    virtual void visit(DepthConcatenateLayerNode &n)     = 0;
+    virtual void visit(DepthwiseConvolutionLayerNode &n) = 0;
+    virtual void visit(EltwiseLayerNode &n)              = 0;
+    virtual void visit(FlattenLayerNode &n)              = 0;
+    virtual void visit(FullyConnectedLayerNode &n)       = 0;
+    virtual void visit(InputNode &n)                     = 0;
+    virtual void visit(NormalizationLayerNode &n)        = 0;
+    virtual void visit(OutputNode &n)                    = 0;
+    virtual void visit(PoolingLayerNode &n)              = 0;
+    virtual void visit(ReshapeLayerNode &n)              = 0;
+    virtual void visit(SoftmaxLayerNode &n)              = 0;
+};
+
+/** Default visitor implementation
+ *
+ * Implements visit methods by calling a default function.
+ * Inherit from DefaultNodeVisitor if you don't want to provide specific implementation for all nodes.
+ */
+class DefaultNodeVisitor : public INodeVisitor
+{
+public:
+    virtual ~DefaultNodeVisitor() = default;
+
+    // Inherited methods overridden
+    virtual void visit(INode &n) override
+    {
+        default_visit();
+    }
+    virtual void visit(ActivationLayerNode &n) override
+    {
+        default_visit();
+    }
+    virtual void visit(BatchNormalizationLayerNode &n) override
+    {
+        default_visit();
+    }
+    virtual void visit(ConstNode &n) override
+    {
+        default_visit();
+    }
+    virtual void visit(ConvolutionLayerNode &n) override
+    {
+        default_visit();
+    }
+    virtual void visit(DepthConcatenateLayerNode &n) override
+    {
+        default_visit();
+    }
+    virtual void visit(DepthwiseConvolutionLayerNode &n) override
+    {
+        default_visit();
+    }
+    virtual void visit(EltwiseLayerNode &n) override
+    {
+        default_visit();
+    }
+    virtual void visit(FlattenLayerNode &n) override
+    {
+        default_visit();
+    }
+    virtual void visit(FullyConnectedLayerNode &n) override
+    {
+        default_visit();
+    }
+    virtual void visit(InputNode &n) override
+    {
+        default_visit();
+    }
+    virtual void visit(NormalizationLayerNode &n) override
+    {
+        default_visit();
+    }
+    virtual void visit(OutputNode &n) override
+    {
+        default_visit();
+    }
+    virtual void visit(PoolingLayerNode &n) override
+    {
+        default_visit();
+    }
+    virtual void visit(ReshapeLayerNode &n) override
+    {
+        default_visit();
+    }
+    virtual void visit(SoftmaxLayerNode &n) override
+    {
+        default_visit();
+    }
+
+    /** Function to be overloaded by the client and implement default behavior for the
+     *  non-overloaded visitors
+     */
+    virtual void default_visit() = 0;
+};
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_INODEVISITOR_H__ */
diff --git a/arm_compute/graph2/ITensorAccessor.h b/arm_compute/graph2/ITensorAccessor.h
new file mode 100644
index 0000000000..1a7277344d
--- /dev/null
+++ b/arm_compute/graph2/ITensorAccessor.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_ITENSOR_ACCESSOR_H__
+#define __ARM_COMPUTE_GRAPH2_ITENSOR_ACCESSOR_H__
+
+#include "arm_compute/graph/ITensorAccessor.h"
+
+#include <memory>
+
+namespace arm_compute
+{
+namespace graph2
+{
+// Forward Declarations
+class ITensorHandle;
+using ITensorAccessor     = graph::ITensorAccessor;
+using ITensorAccessorUPtr = std::unique_ptr<ITensorAccessor>;
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_SUB_STREAM_H__ */
\ No newline at end of file
diff --git a/arm_compute/graph2/ITensorHandle.h b/arm_compute/graph2/ITensorHandle.h
new file mode 100644
index 0000000000..68f79d8b01
--- /dev/null
+++ b/arm_compute/graph2/ITensorHandle.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_ITENSORHANDLE_H__
+#define __ARM_COMPUTE_GRAPH2_ITENSORHANDLE_H__
+
+#include "arm_compute/core/ITensor.h"
+
+namespace arm_compute
+{
+namespace graph2
+{
+/** Tensor handle interface object **/
+class ITensorHandle
+{
+public:
+    /** Default virtual destructor **/
+    virtual ~ITensorHandle() = default;
+    /** Allocates backend memory for the handle **/
+    virtual void allocate() = 0;
+    /** Backend tensor object accessor **/
+    virtual arm_compute::ITensor &tensor() = 0;
+    /** Backend tensor object const accessor **/
+    virtual const arm_compute::ITensor &tensor() const = 0;
+    /** Maps backend tensor object
+     *
+     * @param[in] blocking Flags if the mapping operations should be blocking
+     */
+    virtual void map(bool blocking) = 0;
+    /** Un-maps a backend tensor object **/
+    virtual void unmap() = 0;
+    /** Checks if a backing tensor is a sub-tensor object or not
+     *
+     * @return True if the backend tensor is a sub-tensor else false
+     */
+    virtual bool is_subtensor() const = 0;
+};
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_ITENSORHANDLE_H__ */
diff --git a/arm_compute/graph2/Logger.h b/arm_compute/graph2/Logger.h
new file mode 100644
index 0000000000..f3c263cd3f
--- /dev/null
+++ b/arm_compute/graph2/Logger.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_LOGGER_H__
+#define __ARM_COMPUTE_GRAPH2_LOGGER_H__
+
+#include "arm_compute/core/utils/logging/Macros.h"
+
+/** Create a default core logger
+ *
+ * @note It will eventually create all default loggers in don't exist
+ */
+#define ARM_COMPUTE_CREATE_DEFAULT_GRAPH_LOGGER()                                  \
+    do                                                                             \
+    {                                                                              \
+        if(arm_compute::logging::LoggerRegistry::get().logger("GRAPH") == nullptr) \
+        {                                                                          \
+            arm_compute::logging::LoggerRegistry::get().create_reserved_loggers(); \
+        }                                                                          \
+    } while(false)
+
+#define ARM_COMPUTE_LOG_GRAPH(log_level, x)    \
+    ARM_COMPUTE_CREATE_DEFAULT_GRAPH_LOGGER(); \
+    ARM_COMPUTE_LOG_STREAM("GRAPH", log_level, x)
+
+#define ARM_COMPUTE_LOG_GRAPH_VERBOSE(x)       \
+    ARM_COMPUTE_CREATE_DEFAULT_GRAPH_LOGGER(); \
+    ARM_COMPUTE_LOG_STREAM("GRAPH", arm_compute::logging::LogLevel::VERBOSE, x)
+
+#define ARM_COMPUTE_LOG_GRAPH_INFO(x)          \
+    ARM_COMPUTE_CREATE_DEFAULT_GRAPH_LOGGER(); \
+    ARM_COMPUTE_LOG_STREAM("GRAPH", arm_compute::logging::LogLevel::INFO, x)
+
+#define ARM_COMPUTE_LOG_GRAPH_WARNING(x)       \
+    ARM_COMPUTE_CREATE_DEFAULT_GRAPH_LOGGER(); \
+    ARM_COMPUTE_LOG_STREAM("GRAPH", arm_compute::logging::LogLevel::WARN, x)
+
+#define ARM_COMPUTE_LOG_GRAPH_ERROR(x)         \
+    ARM_COMPUTE_CREATE_DEFAULT_GRAPH_LOGGER(); \
+    ARM_COMPUTE_LOG_STREAM("GRAPH", arm_compute::logging::LogLevel::ERROR, x)
+
+#endif /* __ARM_COMPUTE_GRAPH2_LOGGER_H__ */
diff --git a/arm_compute/graph2/PassManager.h b/arm_compute/graph2/PassManager.h
new file mode 100644
index 0000000000..b1db18b4ad
--- /dev/null
+++ b/arm_compute/graph2/PassManager.h
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_PASSMANAGER_H__
+#define __ARM_COMPUTE_GRAPH2_PASSMANAGER_H__
+
+#include "arm_compute/graph2/IGraphMutator.h"
+
+#include <memory>
+#include <vector>
+
+namespace arm_compute
+{
+namespace graph2
+{
+// Forward declarations
+class Graph;
+
+/** Pass manager
+ *
+ * Responsible for performing the mutating graph passes with a given order
+ **/
+class PassManager final
+{
+public:
+    /** Constructor */
+    PassManager();
+    /** Prevent instances of this class from being copied (As this class contains pointers) */
+    PassManager(const PassManager &) = delete;
+    /** Default move constructor */
+    PassManager(PassManager &&) = default;
+    /** Prevent instances of this class from being copied (As this class contains pointers) */
+    PassManager &operator=(const PassManager &) = delete;
+    /** Default move assignment operator */
+    PassManager &operator=(PassManager &&) = default;
+    /** Mutation passes accessors
+     *
+     * @return Returns the vector with the mutation passes that are to be executed on a graph
+     */
+    const std::vector<std::unique_ptr<IGraphMutator>> &passes() const;
+    /** Accessor of a pass at a given index
+     *
+     * @param[in] index Index of the requested pass
+     *
+     * @return A pointer to the given pass if exists else nullptr
+     */
+    IGraphMutator *pass(size_t index);
+    /** Appends a mutation pass
+     *
+     * @param[in] pass Pass to append
+     */
+    void append(std::unique_ptr<IGraphMutator> pass);
+    /** Clears all the passes */
+    void clear();
+    /** Runs all the mutation passes on a given graph
+     *
+     * @param[in] g Graph to run the mutations on
+     */
+    void run_all(Graph &g);
+    /** Runs a specific mutation pass on a given graph
+     *
+     * @param[in] g     Graph to run the mutation on
+     * @param[in] index Index of the mutation to execute
+     */
+    void run(Graph &g, size_t index);
+
+private:
+    std::vector<std::unique_ptr<IGraphMutator>> _passes; /**< Vector of graph passes */
+};
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_PASSMANAGER_H__ */
diff --git a/arm_compute/graph2/Tensor.h b/arm_compute/graph2/Tensor.h
new file mode 100644
index 0000000000..fcba854a3e
--- /dev/null
+++ b/arm_compute/graph2/Tensor.h
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_TENSOR_H__
+#define __ARM_COMPUTE_GRAPH2_TENSOR_H__
+
+#include "arm_compute/graph2/Types.h"
+
+#include "arm_compute/graph2/ITensorAccessor.h"
+#include "arm_compute/graph2/ITensorHandle.h"
+#include "arm_compute/graph2/TensorDescriptor.h"
+
+#include <memory>
+
+namespace arm_compute
+{
+namespace graph2
+{
+/** Tensor object **/
+class Tensor final
+{
+public:
+    /** Default constructor
+     *
+     * @param[in] id   Tensor ID
+     * @param[in] desc Tensor information
+     */
+    Tensor(TensorID id, TensorDescriptor desc);
+    /** Tensor ID accessor
+     *
+     * @return Tensor ID
+     */
+    TensorID id() const;
+    /** TensorInfo metadata accessor
+     *
+     * @return Tensor descriptor metadata
+     */
+    TensorDescriptor &desc();
+    /** TensorInfo metadata accessor
+     *
+     * @return Tensor descriptor metadata
+     */
+    const TensorDescriptor &desc() const;
+    /** Sets the backend tensor
+     *
+     * @param[in] backend_tensor Backend tensor to set
+     */
+    void set_handle(std::unique_ptr<ITensorHandle> backend_tensor);
+    /** Backend tensor handle accessor
+     *
+     * @return Backend tensor handle
+     */
+    ITensorHandle *handle();
+    /** Sets the backend tensor accessor
+     *
+     * @param[in] accessor Accessor to set
+     */
+    void set_accessor(std::unique_ptr<ITensorAccessor> accessor);
+    /** Backend tensor accessor
+     *
+     * @return Backend tensor accessor
+     */
+    ITensorAccessor *accessor();
+    /** Calls accessor on tensor
+     *
+     * @return True if the accessor was called else false
+     */
+    bool call_accessor();
+    /** Binds the tensor with an edge
+     *
+     * @param[in] eid Edge ID that is bound to the tensor
+     */
+    void bind_edge(EdgeID eid);
+    /** Unbinds an edge from a tensor
+     *
+     * @param[in] eid Edge to unbind
+     */
+    void unbind_edge(EdgeID eid);
+    /** Accessor the edges that are bound with the tensor
+     *
+     * @return Bound edges
+     */
+    const std::set<EdgeID> bound_edges() const;
+
+private:
+    TensorID                         _id;          /**< Tensor id */
+    TensorDescriptor                 _desc;        /**< Tensor metadata */
+    std::unique_ptr<ITensorHandle>   _handle;      /**< Tensor Handle */
+    std::unique_ptr<ITensorAccessor> _accessor;    /**< Tensor Accessor */
+    std::set<EdgeID>                 _bound_edges; /**< Edges bound to this tensor */
+};
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_TENSOR_H__ */
diff --git a/arm_compute/graph2/TensorDescriptor.h b/arm_compute/graph2/TensorDescriptor.h
new file mode 100644
index 0000000000..ff23f71471
--- /dev/null
+++ b/arm_compute/graph2/TensorDescriptor.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_TENSOR_DESCRIPTOR_H__
+#define __ARM_COMPUTE_GRAPH2_TENSOR_DESCRIPTOR_H__
+
+#include "arm_compute/graph2/Types.h"
+
+namespace arm_compute
+{
+namespace graph2
+{
+/** Tensor metadata class */
+struct TensorDescriptor final
+{
+    /** Default Constructor **/
+    TensorDescriptor() = default;
+    /** Constructor
+     *
+     * @param[in] tensor_shape     Tensor shape
+     * @param[in] tensor_data_type Tensor data type
+     * @param[in] tensor_target    Target to allocate the tensor for
+     */
+    TensorDescriptor(TensorShape tensor_shape, DataType tensor_data_type, Target tensor_target = Target::UNSPECIFIED)
+        : shape(tensor_shape), data_type(tensor_data_type), target(tensor_target)
+    {
+    }
+
+    TensorShape shape{};
+    DataType    data_type{ DataType::UNKNOWN };
+    Target      target{ Target::UNSPECIFIED };
+};
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_TENSOR_DESCRIPTOR_H__ */
diff --git a/arm_compute/graph2/TypePrinter.h b/arm_compute/graph2/TypePrinter.h
new file mode 100644
index 0000000000..de675c4633
--- /dev/null
+++ b/arm_compute/graph2/TypePrinter.h
@@ -0,0 +1,313 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_TYPE_PRINTER_H__
+#define __ARM_COMPUTE_GRAPH2_TYPE_PRINTER_H__
+
+#include "arm_compute/core/Error.h"
+#include "arm_compute/core/Types.h"
+#include "arm_compute/graph2/Types.h"
+
+namespace arm_compute
+{
+namespace graph2
+{
+/** Formatted output of the Dimensions type. */
+template <typename T>
+inline ::std::ostream &operator<<(::std::ostream &os, const arm_compute::Dimensions<T> &dimensions)
+{
+    if(dimensions.num_dimensions() > 0)
+    {
+        os << dimensions[0];
+
+        for(unsigned int d = 1; d < dimensions.num_dimensions(); ++d)
+        {
+            os << "x" << dimensions[d];
+        }
+    }
+
+    return os;
+}
+
+/** Formatted output of the Size2D type. */
+inline ::std::ostream &operator<<(::std::ostream &os, const Size2D &size)
+{
+    os << size.width << "x" << size.height;
+
+    return os;
+}
+
+/** Formatted output of the DataType type. */
+inline ::std::ostream &operator<<(::std::ostream &os, const DataType &data_type)
+{
+    switch(data_type)
+    {
+        case DataType::UNKNOWN:
+            os << "UNKNOWN";
+            break;
+        case DataType::U8:
+            os << "U8";
+            break;
+        case DataType::QS8:
+            os << "QS8";
+            break;
+        case DataType::QASYMM8:
+            os << "QASYMM8";
+            break;
+        case DataType::S8:
+            os << "S8";
+            break;
+        case DataType::U16:
+            os << "U16";
+            break;
+        case DataType::S16:
+            os << "S16";
+            break;
+        case DataType::QS16:
+            os << "QS16";
+            break;
+        case DataType::U32:
+            os << "U32";
+            break;
+        case DataType::S32:
+            os << "S32";
+            break;
+        case DataType::U64:
+            os << "U64";
+            break;
+        case DataType::S64:
+            os << "S64";
+            break;
+        case DataType::F16:
+            os << "F16";
+            break;
+        case DataType::F32:
+            os << "F32";
+            break;
+        case DataType::F64:
+            os << "F64";
+            break;
+        case DataType::SIZET:
+            os << "SIZET";
+            break;
+        default:
+            ARM_COMPUTE_ERROR("NOT_SUPPORTED!");
+    }
+
+    return os;
+}
+
+/** Formatted output of the Target. */
+inline ::std::ostream &operator<<(::std::ostream &os, const Target &target)
+{
+    switch(target)
+    {
+        case Target::UNSPECIFIED:
+            os << "UNSPECIFIED";
+            break;
+        case Target::NEON:
+            os << "NEON";
+            break;
+        case Target::CL:
+            os << "CL";
+            break;
+        default:
+            ARM_COMPUTE_ERROR("NOT_SUPPORTED!");
+    }
+
+    return os;
+}
+
+/** Formatted output of the activation function type. */
+inline ::std::ostream &operator<<(::std::ostream &os, const ActivationLayerInfo::ActivationFunction &act_function)
+{
+    switch(act_function)
+    {
+        case ActivationLayerInfo::ActivationFunction::ABS:
+            os << "ABS";
+            break;
+        case ActivationLayerInfo::ActivationFunction::LINEAR:
+            os << "LINEAR";
+            break;
+        case ActivationLayerInfo::ActivationFunction::LOGISTIC:
+            os << "LOGISTIC";
+            break;
+        case ActivationLayerInfo::ActivationFunction::RELU:
+            os << "RELU";
+            break;
+        case ActivationLayerInfo::ActivationFunction::BOUNDED_RELU:
+            os << "BOUNDED_RELU";
+            break;
+        case ActivationLayerInfo::ActivationFunction::LEAKY_RELU:
+            os << "LEAKY_RELU";
+            break;
+        case ActivationLayerInfo::ActivationFunction::SOFT_RELU:
+            os << "SOFT_RELU";
+            break;
+        case ActivationLayerInfo::ActivationFunction::SQRT:
+            os << "SQRT";
+            break;
+        case ActivationLayerInfo::ActivationFunction::LU_BOUNDED_RELU:
+            os << "LU_BOUNDED_RELU";
+            break;
+        case ActivationLayerInfo::ActivationFunction::SQUARE:
+            os << "SQUARE";
+            break;
+        case ActivationLayerInfo::ActivationFunction::TANH:
+            os << "TANH";
+            break;
+        default:
+            ARM_COMPUTE_ERROR("NOT_SUPPORTED!");
+    }
+
+    return os;
+}
+
+inline std::string to_string(const ActivationLayerInfo::ActivationFunction &act_function)
+{
+    std::stringstream str;
+    str << act_function;
+    return str.str();
+}
+
+/** Formatted output of the PoolingType type. */
+inline ::std::ostream &operator<<(::std::ostream &os, const PoolingType &pool_type)
+{
+    switch(pool_type)
+    {
+        case PoolingType::AVG:
+            os << "AVG";
+            break;
+        case PoolingType::MAX:
+            os << "MAX";
+            break;
+        case PoolingType::L2:
+            os << "L2";
+            break;
+        default:
+            ARM_COMPUTE_ERROR("NOT_SUPPORTED!");
+    }
+
+    return os;
+}
+
+/** Formatted output of the NormType type. */
+inline ::std::ostream &operator<<(::std::ostream &os, const NormType &norm_type)
+{
+    switch(norm_type)
+    {
+        case NormType::CROSS_MAP:
+            os << "CROSS_MAP";
+            break;
+        case NormType::IN_MAP_1D:
+            os << "IN_MAP_1D";
+            break;
+        case NormType::IN_MAP_2D:
+            os << "IN_MAP_2D";
+            break;
+        default:
+            ARM_COMPUTE_ERROR("NOT_SUPPORTED!");
+    }
+
+    return os;
+}
+
+/** Formatted output of the EltwiseOperation type. */
+inline ::std::ostream &operator<<(::std::ostream &os, const EltwiseOperation &eltwise_op)
+{
+    switch(eltwise_op)
+    {
+        case EltwiseOperation::ADD:
+            os << "ADD";
+            break;
+        case EltwiseOperation::MUL:
+            os << "MUL";
+            break;
+        case EltwiseOperation::SUB:
+            os << "SUB";
+            break;
+        default:
+            ARM_COMPUTE_ERROR("NOT_SUPPORTED!");
+    }
+
+    return os;
+}
+
+/** Formatted output of the ConvolutionMethod type. */
+inline ::std::ostream &operator<<(::std::ostream &os, const ConvolutionMethod &method)
+{
+    switch(method)
+    {
+        case ConvolutionMethod::DEFAULT:
+            os << "DEFAULT";
+            break;
+        case ConvolutionMethod::DIRECT:
+            os << "DIRECT";
+            break;
+        case ConvolutionMethod::GEMM:
+            os << "GEMM";
+            break;
+        case ConvolutionMethod::WINOGRAD:
+            os << "WINOGRAD";
+            break;
+        default:
+            ARM_COMPUTE_ERROR("NOT_SUPPORTED!");
+    }
+
+    return os;
+}
+
+/** Formatted output of the DepthwiseConvolutionMethod type. */
+inline ::std::ostream &operator<<(::std::ostream &os, const DepthwiseConvolutionMethod &method)
+{
+    switch(method)
+    {
+        case DepthwiseConvolutionMethod::DEFAULT:
+            os << "DEFAULT";
+            break;
+        case DepthwiseConvolutionMethod::GEMV:
+            os << "GEMV";
+            break;
+        case DepthwiseConvolutionMethod::OPTIMIZED_3x3:
+            os << "OPTIMIZED_3x3";
+            break;
+        default:
+            ARM_COMPUTE_ERROR("NOT_SUPPORTED!");
+    }
+
+    return os;
+}
+
+/** Formatted output of the PadStrideInfo type. */
+inline ::std::ostream &operator<<(::std::ostream &os, const PadStrideInfo &pad_stride_info)
+{
+    os << pad_stride_info.stride().first << "," << pad_stride_info.stride().second;
+    os << ";";
+    os << pad_stride_info.pad_left() << "," << pad_stride_info.pad_right() << ","
+       << pad_stride_info.pad_top() << "," << pad_stride_info.pad_bottom();
+
+    return os;
+}
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_TYPE_PRINTER_H__ */
diff --git a/arm_compute/graph2/Types.h b/arm_compute/graph2/Types.h
new file mode 100644
index 0000000000..05c15f4daf
--- /dev/null
+++ b/arm_compute/graph2/Types.h
@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_TYPES_H__
+#define __ARM_COMPUTE_GRAPH2_TYPES_H__
+
+#include "arm_compute/core/Error.h"
+#include "arm_compute/core/Types.h"
+#include "arm_compute/core/utils/strong_type/StrongType.h"
+#include "arm_compute/core/utils/strong_type/StrongTypeAttributes.h"
+
+#include <limits>
+#include <string>
+
+namespace arm_compute
+{
+namespace graph2
+{
+using arm_compute::Status;
+
+using arm_compute::DataType;
+using arm_compute::TensorShape;
+using arm_compute::Size2D;
+
+using arm_compute::ActivationLayerInfo;
+using arm_compute::NormType;
+using arm_compute::NormalizationLayerInfo;
+using arm_compute::PadStrideInfo;
+using arm_compute::PoolingLayerInfo;
+using arm_compute::PoolingType;
+using arm_compute::DimensionRoundingType;
+
+/** TODO (geopin01): Make ids strongly typed */
+using TensorID   = unsigned int;
+using NodeID     = unsigned int;
+using EdgeID     = unsigned int;
+using Activation = arm_compute::ActivationLayerInfo::ActivationFunction;
+
+/**< GraphID strong type */
+using GraphID = strong_type::StrongType<unsigned int, struct graph_id_t, strong_type::Comparable>;
+/* TODO (geopin01): Strong types for NodeID */
+
+/**< Constant TensorID specifying an equivalent of null tensor */
+constexpr TensorID NullTensorID = std::numeric_limits<TensorID>::max();
+/**< Constant NodeID specifying an equivalent of null node */
+constexpr NodeID EmptyNodeID = std::numeric_limits<NodeID>::max();
+/**< Constant EdgeID specifying an equivalent of null edge */
+constexpr EdgeID EmptyEdgeID = std::numeric_limits<EdgeID>::max();
+
+// Forward declarations
+class TensorDescriptor;
+
+/**< Data layout format */
+enum class DataLayout
+{
+    NCHW, /** N(Batches), C(Channels), H(Height), W(Width) from slow to fast moving dimension */
+    NHWC  /** N(Batches), H(Height), W(Width), C(Channels) from slow to fast moving dimension */
+};
+
+/**< Device target types */
+enum class Target
+{
+    UNSPECIFIED, /**< Unspecified Target */
+    NEON,        /**< NEON capable target device */
+    CL,          /**< OpenCL capable target device */
+};
+
+/** Supported Element-wise operations */
+enum class EltwiseOperation
+{
+    ADD, /**< Arithmetic addition */
+    SUB, /**< Arithmetic subtraction */
+    MUL  /**< Arithmetic multiplication */
+};
+
+/** Supported Convolution layer methods */
+enum class ConvolutionMethod
+{
+    DEFAULT, /**< Default approach using internal heuristics */
+    GEMM,    /**< GEMM based convolution */
+    DIRECT,  /**< Deep direct convolution */
+    WINOGRAD /**< Winograd based convolution */
+};
+
+/** Supported Depthwise Convolution layer methods */
+enum class DepthwiseConvolutionMethod
+{
+    DEFAULT,       /**< Default approach using internal heuristics */
+    GEMV,          /**< Generic GEMV based depthwise convolution */
+    OPTIMIZED_3x3, /**< Optimized 3x3 direct depthwise convolution */
+};
+
+/** Supported nodes */
+enum class NodeType
+{
+    ActivationLayer,
+    BatchNormalizationLayer,
+    ConvolutionLayer,
+    DepthConcatenateLayer,
+    DepthwiseConvolutionLayer,
+    EltwiseLayer,
+    FlattenLayer,
+    FullyConnectedLayer,
+    NormalizationLayer,
+    PoolingLayer,
+    ReshapeLayer,
+    SoftmaxLayer,
+
+    Input,
+    Output,
+    Const,
+};
+
+/** Backend Memory Manager affinity **/
+enum class MemoryManagerAffinity
+{
+    Buffer, /**< Affinity at buffer level */
+    Offset  /**< Affinity at offset level */
+};
+
+/** NodeID-index struct
+ *
+ * Used to describe connections
+ */
+struct NodeIdxPair
+{
+    NodeID node_id;
+    size_t index;
+};
+
+/** Common node parameters */
+struct NodeParams
+{
+    std::string name;
+    Target      target;
+};
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_TYPES_H__ */
diff --git a/arm_compute/graph2/Utils.h b/arm_compute/graph2/Utils.h
new file mode 100644
index 0000000000..750665a491
--- /dev/null
+++ b/arm_compute/graph2/Utils.h
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_UTILS_H__
+#define __ARM_COMPUTE_GRAPH2_UTILS_H__
+
+#include "arm_compute/graph2/Graph.h"
+#include "arm_compute/graph2/PassManager.h"
+
+namespace arm_compute
+{
+namespace graph2
+{
+// Forward Declaration
+class GraphContext;
+
+/** Returns the tensor descriptor of a given tensor
+ *
+ * @param[in] g   Graph that the tensor belongs to
+ * @param[in] tid Tensor ID
+ *
+ * @return Tensor descriptor if tensor was found else empty descriptor
+ */
+inline TensorDescriptor get_tensor_descriptor(const Graph &g, TensorID tid)
+{
+    const Tensor *tensor = g.tensor(tid);
+    return (tensor != nullptr) ? tensor->desc() : TensorDescriptor();
+}
+/** Sets an accessor on a given tensor
+ *
+ * @param[in] tensor   Tensor to set the accessor to
+ * @param[in] accessor Accessor to set
+ *
+ * @return True if accessor was set else false
+ */
+inline Status set_tensor_accessor(Tensor *tensor, std::unique_ptr<ITensorAccessor> accessor)
+{
+    ARM_COMPUTE_RETURN_ERROR_ON(tensor == nullptr);
+    tensor->set_accessor(std::move(accessor));
+
+    return Status{};
+}
+/** Checks if a specific target is supported
+ *
+ * @param[in] target Target to check
+ *
+ * @return True if target is support else false
+ */
+bool is_target_supported(Target target);
+/** Returns default target for execution
+ *
+ * @note If an OpenCL backend exists then OpenCL is returned,
+ *       else if the NEON backend exists returns NEON as target.
+ *       If no backends are registered an error is raised.
+ *
+ * @return Default target
+ */
+Target get_default_target();
+/** Forces a single target to all graph constructs
+ *
+ * @param[in] g      Graph to force target on
+ * @param[in] target Target to force
+ */
+void force_target_to_graph(Graph &g, Target target);
+/** Creates a default @ref PassManager
+ *
+ * @return A PassManager with default mutating passes
+ */
+PassManager create_default_pass_manager();
+/** Default setups the graph context if not done manually
+ *
+ * @param[in] ctx Graph Context
+ */
+void setup_default_graph_context(GraphContext &ctx);
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_UTILS_H__ */
diff --git a/arm_compute/graph2/Workload.h b/arm_compute/graph2/Workload.h
new file mode 100644
index 0000000000..85506e350e
--- /dev/null
+++ b/arm_compute/graph2/Workload.h
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_WORKLOAD_H__
+#define __ARM_COMPUTE_GRAPH2_WORKLOAD_H__
+
+#include "arm_compute/runtime/IFunction.h"
+
+#include <memory>
+#include <vector>
+
+namespace arm_compute
+{
+namespace graph2
+{
+// Forward declarations
+class ITensorHandle;
+class INode;
+class Tensor;
+
+/** Execution task
+ *
+ * Contains all the information required to execute a given task
+ */
+struct ExecutionTask
+{
+    // TODO (geopin01) : Support vector of functions?
+    std::unique_ptr<arm_compute::IFunction> task            = {}; /**< Task to execute */
+    INode                                  *node            = {}; /**< Node bound to this workload */
+    std::vector<ITensorHandle *>            commit_handles  = {}; /**< Handles needs to sync for this task to execute */
+    std::vector<ITensorHandle *>            release_handles = {}; /**< Handles that can be released after this node execution */
+
+    /** Function operator */
+    void operator()();
+};
+
+/** Execution workload */
+struct ExecutionWorkload
+{
+    std::vector<Tensor *>      inputs  = {}; /**< Input handles */
+    std::vector<Tensor *>      outputs = {}; /**< Output handles */
+    std::vector<ExecutionTask> tasks   = {}; /**< Execution workload */
+};
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_WORKLOAD_H__ */
diff --git a/arm_compute/graph2/algorithms/Algorithms.h b/arm_compute/graph2/algorithms/Algorithms.h
new file mode 100644
index 0000000000..dfc36febe2
--- /dev/null
+++ b/arm_compute/graph2/algorithms/Algorithms.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_ALGORITHMS_H__
+#define __ARM_COMPUTE_GRAPH2_ALGORITHMS_H__
+
+#include "arm_compute/graph2/algorithms/BFS.h"
+
+#endif /* __ARM_COMPUTE_GRAPH2_ALGORITHMS_H__ */
diff --git a/arm_compute/graph2/algorithms/BFS.h b/arm_compute/graph2/algorithms/BFS.h
new file mode 100644
index 0000000000..d590658074
--- /dev/null
+++ b/arm_compute/graph2/algorithms/BFS.h
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_ALGORITHM_BFS_H__
+#define __ARM_COMPUTE_GRAPH2_ALGORITHM_BFS_H__
+
+#include "arm_compute/graph2/Graph.h"
+
+#include <list>
+#include <vector>
+
+namespace arm_compute
+{
+namespace graph2
+{
+namespace detail
+{
+/** Checks if all the input dependencies of a node have been visited
+ *
+ * @param[in] node    Node to check
+ * @param[in] visited Vector that contains the visited information
+ *
+ * @return True if all inputs dependencies have been visited else false
+ */
+inline bool all_inputs_are_visited(const INode *node, const std::vector<bool> &visited)
+{
+    ARM_COMPUTE_ERROR_ON(node == nullptr);
+    const Graph *graph = node->graph();
+    ARM_COMPUTE_ERROR_ON(graph == nullptr);
+
+    bool are_all_visited = true;
+    for(const auto &input_edge_id : node->input_edges())
+    {
+        if(input_edge_id != EmptyNodeID)
+        {
+            const Edge *input_edge = graph->edge(input_edge_id);
+            ARM_COMPUTE_ERROR_ON(input_edge == nullptr);
+            ARM_COMPUTE_ERROR_ON(input_edge->producer() == nullptr);
+            if(!visited[input_edge->producer_id()])
+            {
+                are_all_visited = false;
+                break;
+            }
+        }
+    }
+
+    return are_all_visited;
+}
+} // namespace detail
+
+/** Breadth first search traversal
+ *
+ * @param g Graph to traverse
+ *
+ * @return A vector with the node id traversal order
+ */
+inline std::vector<NodeID> bfs(Graph &g)
+{
+    std::vector<NodeID> bfs_order_vector;
+
+    // Created visited vector
+    std::vector<bool> visited(g.nodes().size(), false);
+
+    // Create BFS queue
+    std::list<NodeID> queue;
+
+    // Push inputs and mark as visited
+    for(auto &input : g.inputs())
+    {
+        if(input != EmptyNodeID)
+        {
+            visited[input] = true;
+            queue.push_back(input);
+        }
+    }
+
+    // Iterate over vector and edges
+    while(!queue.empty())
+    {
+        // Dequeue a node from queue and process
+        NodeID n = queue.front();
+        bfs_order_vector.push_back(n);
+        queue.pop_front();
+
+        const INode *node = g.node(n);
+        ARM_COMPUTE_ERROR_ON(node == nullptr);
+        for(const auto &eid : node->output_edges())
+        {
+            const Edge *e = g.edge(eid);
+            ARM_COMPUTE_ERROR_ON(e == nullptr);
+            if(!visited[e->consumer_id()] && detail::all_inputs_are_visited(e->consumer(), visited))
+            {
+                visited[e->consumer_id()] = true;
+                queue.push_back(e->consumer_id());
+            }
+        }
+    }
+
+    return bfs_order_vector;
+}
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_ALGORITHM_BFS_H__ */
diff --git a/arm_compute/graph2/backends/BackendRegistrar.h b/arm_compute/graph2/backends/BackendRegistrar.h
new file mode 100644
index 0000000000..f9905a7f8f
--- /dev/null
+++ b/arm_compute/graph2/backends/BackendRegistrar.h
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef ARM_COMPUTE_GRAPH2_BACKEND_REGISTRAR_H__
+#define ARM_COMPUTE_GRAPH2_BACKEND_REGISTRAR_H__
+
+#include "arm_compute/graph2/Types.h"
+#include "arm_compute/graph2/backends/BackendRegistry.h"
+
+#include <utility>
+
+namespace arm_compute
+{
+namespace graph2
+{
+namespace backends
+{
+namespace detail
+{
+/** Helper class to statically register a backend */
+template <typename T>
+class BackendRegistrar final
+{
+public:
+    /** Add a new backend to the backend registry
+     *
+     * @param[in] target Execution target
+     */
+    BackendRegistrar(Target target);
+};
+
+template <typename T>
+inline BackendRegistrar<T>::BackendRegistrar(Target target)
+{
+    BackendRegistry::get().add_backend<T>(target);
+}
+} // namespace detail
+} // namespace backends
+} // namespace graph2
+} // namespace arm_compute
+#endif /* ARM_COMPUTE_GRAPH2_BACKEND_REGISTRAR_H__ */
\ No newline at end of file
diff --git a/arm_compute/graph2/backends/BackendRegistry.h b/arm_compute/graph2/backends/BackendRegistry.h
new file mode 100644
index 0000000000..9481115009
--- /dev/null
+++ b/arm_compute/graph2/backends/BackendRegistry.h
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_BACKEND_REGISTRY_H__
+#define __ARM_COMPUTE_GRAPH2_BACKEND_REGISTRY_H__
+
+#include "arm_compute/graph2/IDeviceBackend.h"
+#include "arm_compute/graph2/Types.h"
+#include "support/ToolchainSupport.h"
+
+#include <map>
+#include <memory>
+
+namespace arm_compute
+{
+namespace graph2
+{
+namespace backends
+{
+/** Registry holding all the supported backends */
+class BackendRegistry final
+{
+public:
+    /** Gets backend registry instance
+     *
+     * @return Backend registry instance
+     */
+    static BackendRegistry &get();
+    /** Finds a backend in the registry
+     *
+     * @param[in] target Backend target
+     *
+     * @return Pointer to the backend interface if found, else nullptr
+     */
+    IDeviceBackend *find_backend(Target target);
+    /** Checks if a backend for a given target exists
+     *
+     * @param[in] target Execution target
+     *
+     * @return True if exists else false
+     */
+    bool contains(Target target) const;
+    /** Backends accessor
+     *
+     * @return Map containing the registered backends
+     */
+    const std::map<Target, std::unique_ptr<IDeviceBackend>> &backends() const;
+    /** Registers a backend to the registry
+     *
+     * @param[in] target Execution target to register for
+     */
+    template <typename T>
+    void add_backend(Target target);
+
+private:
+    /** Default Constructor */
+    BackendRegistry();
+
+private:
+    std::map<Target, std::unique_ptr<IDeviceBackend>> _registered_backends;
+};
+
+template <typename T>
+inline void BackendRegistry::add_backend(Target target)
+{
+    _registered_backends[target] = support::cpp14::make_unique<T>();
+}
+} // namespace backends
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_BACKEND_REGISTRY_H__ */
diff --git a/arm_compute/graph2/backends/CL/CLDeviceBackend.h b/arm_compute/graph2/backends/CL/CLDeviceBackend.h
new file mode 100644
index 0000000000..c48a85f99a
--- /dev/null
+++ b/arm_compute/graph2/backends/CL/CLDeviceBackend.h
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_CLDEVICEBACKEND_H__
+#define __ARM_COMPUTE_GRAPH2_CLDEVICEBACKEND_H__
+
+#include "arm_compute/graph2/IDeviceBackend.h"
+
+#include "arm_compute/runtime/CL/CLBufferAllocator.h"
+#include "arm_compute/runtime/CL/CLTuner.h"
+
+namespace arm_compute
+{
+namespace graph2
+{
+namespace backends
+{
+/** OpenCL device backend */
+class CLDeviceBackend final : public IDeviceBackend
+{
+public:
+    /** Default Constructor */
+    CLDeviceBackend();
+    /** Destructor */
+    ~CLDeviceBackend();
+    /** Switchs on or off the kernel tuning
+     *
+     * @note When true the tuner set is used, if no tuner is set a new default one is created
+     *
+     * @param[in] enable_tuning Enables tuning if false else true
+     */
+    void set_kernel_tuning(bool enable_tuning);
+
+    // Inherited overridden methods
+    void initialize_backend() override;
+    void setup_backend_context(GraphContext &ctx) override;
+    std::unique_ptr<ITensorHandle> create_tensor(const Tensor &tensor) override;
+    std::unique_ptr<ITensorHandle> create_subtensor(ITensorHandle *parent, TensorShape shape, Coordinates coords) override;
+    std::unique_ptr<arm_compute::IFunction> configure_node(INode &node, GraphContext &ctx) override;
+    Status validate_node(const INode &node) override;
+    std::shared_ptr<arm_compute::IMemoryManager> create_memory_manager(MemoryManagerAffinity affinity) override;
+
+private:
+    CLTuner           _tuner;     /**< CL kernel tuner */
+    CLBufferAllocator _allocator; /**< CL buffer affinity allocator */
+};
+} // namespace backends
+} // namespace graph2
+} // namespace arm_compute
+#endif //__ARM_COMPUTE_GRAPH2_CLDEVICEBACKEND_H__
diff --git a/arm_compute/graph2/backends/CL/CLFunctionFactory.h b/arm_compute/graph2/backends/CL/CLFunctionFactory.h
new file mode 100644
index 0000000000..94fd2b8be1
--- /dev/null
+++ b/arm_compute/graph2/backends/CL/CLFunctionFactory.h
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_CLFUNCTIONFACTORY_H__
+#define __ARM_COMPUTE_GRAPH2_CLFUNCTIONFACTORY_H__
+
+#include "arm_compute/runtime/IFunction.h"
+
+#include <memory>
+
+namespace arm_compute
+{
+namespace graph2
+{
+// Forward declarations
+class INode;
+class GraphContext;
+
+namespace backends
+{
+/** Factory for generating OpenCL backend functions **/
+class CLFunctionFactory final
+{
+public:
+    /** Create a backend execution function depending on the node type
+     *
+     * @param[in] node Node to create the backend function for
+     * @param[in] ctx  Context to use
+     *
+     * @return Backend function
+     */
+    static std::unique_ptr<arm_compute::IFunction> create(INode *node, GraphContext &ctx);
+};
+} // namespace backends
+} // namespace graph2
+} // namespace arm_compute
+#endif //__ARM_COMPUTE_GRAPH2_CLFUNCTIONFACTORY_H__
diff --git a/arm_compute/graph2/backends/CL/CLSubTensorHandle.h b/arm_compute/graph2/backends/CL/CLSubTensorHandle.h
new file mode 100644
index 0000000000..5584a8ba4f
--- /dev/null
+++ b/arm_compute/graph2/backends/CL/CLSubTensorHandle.h
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_CLSUBTENSORHANDLE_H__
+#define __ARM_COMPUTE_GRAPH2_CLSUBTENSORHANDLE_H__
+
+#include "arm_compute/graph2/ITensorHandle.h"
+
+#include "arm_compute/runtime/CL/CLSubTensor.h"
+
+namespace arm_compute
+{
+namespace graph2
+{
+namespace backends
+{
+/** OpenCL Sub-Tensor handle interface object **/
+class CLSubTensorHandle final : public ITensorHandle
+{
+public:
+    /** Default constructor
+     *
+     * @param[in] parent_handle Parent tensor handle
+     * @param[in] shape         Sub-Tensor shape
+     * @param[in] coords        Starting coordinates
+     */
+    CLSubTensorHandle(ITensorHandle *parent_handle, const TensorShape &shape, const Coordinates &coords);
+    /** Destructor: free the tensor's memory */
+    ~CLSubTensorHandle() = default;
+    /** Allow instances of this class to be move constructed */
+    CLSubTensorHandle(CLSubTensorHandle &&) = default;
+    /** Allow instances of this class to be moved */
+    CLSubTensorHandle &operator=(CLSubTensorHandle &&) = default;
+
+    // Inherited overridden methods
+    void                        allocate() override;
+    arm_compute::ITensor       &tensor() override;
+    const arm_compute::ITensor &tensor() const override;
+    void map(bool blocking) override;
+    void unmap() override;
+    bool is_subtensor() const override;
+
+private:
+    arm_compute::CLSubTensor _sub_tensor; /**< Backend Sub-Tensor */
+};
+} // namespace backends
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_CLSUBTENSORHANDLE_H__ */
diff --git a/arm_compute/graph2/backends/CL/CLTensorHandle.h b/arm_compute/graph2/backends/CL/CLTensorHandle.h
new file mode 100644
index 0000000000..37d7147b6b
--- /dev/null
+++ b/arm_compute/graph2/backends/CL/CLTensorHandle.h
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_CLTENSORHANDLE_H__
+#define __ARM_COMPUTE_GRAPH2_CLTENSORHANDLE_H__
+
+#include "arm_compute/graph2/ITensorHandle.h"
+
+#include "arm_compute/runtime/CL/CLTensor.h"
+
+namespace arm_compute
+{
+namespace graph2
+{
+namespace backends
+{
+/** OpenCL Tensor handle interface object **/
+class CLTensorHandle final : public ITensorHandle
+{
+public:
+    /** Default Constructor
+     *
+     * @param[in] info Tensor metadata
+     */
+    CLTensorHandle(const ITensorInfo &info);
+    /** Destructor: free the tensor's memory */
+    ~CLTensorHandle() = default;
+    /** Allow instances of this class to be move constructed */
+    CLTensorHandle(CLTensorHandle &&) = default;
+    /** Allow instances of this class to be moved */
+    CLTensorHandle &operator=(CLTensorHandle &&) = default;
+
+    // Inherited overridden methods
+    void                        allocate() override;
+    arm_compute::ITensor       &tensor() override;
+    const arm_compute::ITensor &tensor() const override;
+    void map(bool blocking) override;
+    void unmap() override;
+    bool is_subtensor() const override;
+
+private:
+    arm_compute::CLTensor _tensor; /**< Backend Tensor */
+};
+} // namespace backends
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_CLTENSORHANDLE_H__ */
diff --git a/arm_compute/graph2/backends/NEON/NEDeviceBackend.h b/arm_compute/graph2/backends/NEON/NEDeviceBackend.h
new file mode 100644
index 0000000000..533a2c0863
--- /dev/null
+++ b/arm_compute/graph2/backends/NEON/NEDeviceBackend.h
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_NEDEVICEBACKEND_H__
+#define __ARM_COMPUTE_GRAPH2_NEDEVICEBACKEND_H__
+
+#include "arm_compute/graph2/IDeviceBackend.h"
+
+#include "arm_compute/runtime/Allocator.h"
+
+namespace arm_compute
+{
+namespace graph2
+{
+namespace backends
+{
+/** NEON device backend */
+class NEDeviceBackend final : public IDeviceBackend
+{
+public:
+    NEDeviceBackend();
+
+    // Inherited overridden methods
+    void initialize_backend() override;
+    void setup_backend_context(GraphContext &ctx) override;
+    std::unique_ptr<ITensorHandle> create_tensor(const Tensor &tensor) override;
+    std::unique_ptr<ITensorHandle> create_subtensor(ITensorHandle *parent, TensorShape shape, Coordinates coords) override;
+    std::unique_ptr<arm_compute::IFunction> configure_node(INode &node, GraphContext &ctx) override;
+    Status validate_node(const INode &node) override;
+    std::shared_ptr<arm_compute::IMemoryManager> create_memory_manager(MemoryManagerAffinity affinity) override;
+
+private:
+    Allocator _allocator; /**< NEON backend allocator */
+};
+} // namespace backends
+} // namespace graph2
+} // namespace arm_compute
+#endif //__ARM_COMPUTE_GRAPH2_NEDEVICEBACKEND_H__
diff --git a/arm_compute/graph2/backends/NEON/NEFunctionFactory.h b/arm_compute/graph2/backends/NEON/NEFunctionFactory.h
new file mode 100644
index 0000000000..a065340ad6
--- /dev/null
+++ b/arm_compute/graph2/backends/NEON/NEFunctionFactory.h
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_NEFUNCTIONFACTORY_H__
+#define __ARM_COMPUTE_GRAPH2_NEFUNCTIONFACTORY_H__
+
+#include "arm_compute/runtime/IFunction.h"
+
+#include <memory>
+
+namespace arm_compute
+{
+namespace graph2
+{
+// Forward declarations
+class INode;
+class GraphContext;
+
+namespace backends
+{
+class NEFunctionFactory final
+{
+public:
+    /** Create a backend execution function depending on the node type
+     *
+     * @param[in] node Node to create the backend function for
+     * @param[in] ctx  Context to use
+     *
+     * @return Backend function
+     */
+    static std::unique_ptr<arm_compute::IFunction> create(INode *node, GraphContext &ctx);
+};
+} // namespace backends
+} // namespace graph2
+} // namespace arm_compute
+#endif //__ARM_COMPUTE_GRAPH2_NEFUNCTIONFACTORY_H__
diff --git a/arm_compute/graph2/backends/NEON/NENodeValidator.h b/arm_compute/graph2/backends/NEON/NENodeValidator.h
new file mode 100644
index 0000000000..8e8448526a
--- /dev/null
+++ b/arm_compute/graph2/backends/NEON/NENodeValidator.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_NENODEVALIDATOR_H__
+#define __ARM_COMPUTE_GRAPH2_NENODEVALIDATOR_H__
+
+#include "arm_compute/graph2/INodeVisitor.h"
+
+namespace arm_compute
+{
+namespace graph2
+{
+namespace backends
+{
+// TODO (geopin01) : Add node validator
+} // namespace backends
+} // namespace graph2
+} // namespace arm_compute
+#endif //__ARM_COMPUTE_GRAPH2_NENODEVALIDATOR_H__
diff --git a/arm_compute/graph2/backends/NEON/NESubTensorHandle.h b/arm_compute/graph2/backends/NEON/NESubTensorHandle.h
new file mode 100644
index 0000000000..e027b0cc56
--- /dev/null
+++ b/arm_compute/graph2/backends/NEON/NESubTensorHandle.h
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_NESUBTENSORHANDLE_H__
+#define __ARM_COMPUTE_GRAPH2_NESUBTENSORHANDLE_H__
+
+#include "arm_compute/graph2/ITensorHandle.h"
+
+#include "arm_compute/runtime/SubTensor.h"
+
+namespace arm_compute
+{
+namespace graph2
+{
+namespace backends
+{
+/** NEON Sub-Tensor handle interface object **/
+class NESubTensorHandle final : public ITensorHandle
+{
+public:
+    /** Default constructor
+     *
+     * @param[in] parent_handle Parent tensor handle
+     * @param[in] shape         Sub-Tensor shape
+     * @param[in] coords        Starting coordinates
+     */
+    NESubTensorHandle(ITensorHandle *parent_handle, const TensorShape &shape, const Coordinates &coords);
+    /** Destructor: free the tensor's memory */
+    ~NESubTensorHandle() = default;
+    /** Allow instances of this class to be move constructed */
+    NESubTensorHandle(NESubTensorHandle &&) = default;
+    /** Allow instances of this class to be moved */
+    NESubTensorHandle &operator=(NESubTensorHandle &&) = default;
+
+    // Inherited overridden methods
+    void                        allocate() override;
+    arm_compute::ITensor       &tensor() override;
+    const arm_compute::ITensor &tensor() const override;
+    void map(bool blocking) override;
+    void unmap() override;
+    bool is_subtensor() const override;
+
+private:
+    arm_compute::SubTensor _sub_tensor; /**< Backend Sub-Tensor */
+};
+} // namespace backends
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_NESUBTENSORHANDLE_H__ */
diff --git a/arm_compute/graph2/backends/NEON/NETensorHandle.h b/arm_compute/graph2/backends/NEON/NETensorHandle.h
new file mode 100644
index 0000000000..c22fcdf216
--- /dev/null
+++ b/arm_compute/graph2/backends/NEON/NETensorHandle.h
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_NETENSORHANDLE_H__
+#define __ARM_COMPUTE_GRAPH2_NETENSORHANDLE_H__
+
+#include "arm_compute/graph2/ITensorHandle.h"
+
+#include "arm_compute/runtime/Tensor.h"
+
+namespace arm_compute
+{
+namespace graph2
+{
+namespace backends
+{
+/** NEON Tensor handle interface object **/
+class NETensorHandle final : public ITensorHandle
+{
+public:
+    /** Default Constructor
+     *
+     * @param[in] info Tensor metadata
+     */
+    NETensorHandle(const ITensorInfo &info);
+    /** Destructor: free the tensor's memory */
+    ~NETensorHandle() = default;
+    /** Allow instances of this class to be move constructed */
+    NETensorHandle(NETensorHandle &&) = default;
+    /** Allow instances of this class to be moved */
+    NETensorHandle &operator=(NETensorHandle &&) = default;
+
+    // Inherited overridden methods
+    void                        allocate() override;
+    arm_compute::ITensor       &tensor() override;
+    const arm_compute::ITensor &tensor() const override;
+    void map(bool blocking) override;
+    void unmap() override;
+    bool is_subtensor() const override;
+
+private:
+    arm_compute::Tensor _tensor; /**< Backend Tensor */
+};
+} // namespace backends
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_NETENSORHANDLE_H__ */
diff --git a/arm_compute/graph2/backends/Utils.h b/arm_compute/graph2/backends/Utils.h
new file mode 100644
index 0000000000..cc6f5163f2
--- /dev/null
+++ b/arm_compute/graph2/backends/Utils.h
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_BACKENDS_UTILS_H__
+#define __ARM_COMPUTE_GRAPH2_BACKENDS_UTILS_H__
+
+#include "arm_compute/graph2/GraphContext.h"
+#include "arm_compute/runtime/IMemoryManager.h"
+
+namespace arm_compute
+{
+namespace graph2
+{
+namespace backends
+{
+/** Creates and configures a named function
+ *
+ * @param[in] name Name of the function
+ * @param[in] args Function arguments
+ *
+ * @return  A configured backend function
+ */
+template <typename FunctionType, typename FunctionNameType, typename... ParameterType>
+std::pair<std::unique_ptr<arm_compute::IFunction>, FunctionNameType> create_named_function(FunctionNameType name, ParameterType... args)
+{
+    auto f = arm_compute::support::cpp14::make_unique<FunctionType>();
+    f->configure(std::forward<ParameterType>(args)...);
+    return std::make_pair(std::move(f), name);
+}
+
+/** Creates and configures a named function
+ *
+ * @param[in] name Name of the function
+ * @param[in] mm   Memory manager to use
+ * @param[in] args Function arguments
+ *
+ * @return  A configured backend function
+ */
+template <typename FunctionType, typename FunctionNameType, typename MemoryManagerType, typename... ParameterType>
+std::pair<std::unique_ptr<arm_compute::IFunction>, FunctionNameType> create_named_memory_managed_function(FunctionNameType name,
+                                                                                                          MemoryManagerType mm,
+                                                                                                          ParameterType... args)
+{
+    auto f = arm_compute::support::cpp14::make_unique<FunctionType>(mm);
+    f->configure(std::forward<ParameterType>(args)...);
+    return std::make_pair(std::move(f), name);
+}
+
+/** Checks if an operation is in place
+ *
+ * @param[in] input  Pointer to input
+ * @param[in] output Pointer to output
+ *
+ * @return True if output is nullptr or input is equal to the output, else false
+ */
+inline bool is_in_place_operation(void *input, void *output)
+{
+    return (output == nullptr) || (input == output);
+}
+
+/** Returns the memory manager for a given target
+ *
+ * @param[in] ctx    Graph context containing memory management metadata
+ * @param[in] target Target to retrieve the memory manager from
+ *
+ * @return The memory manager for the given target else false
+ */
+inline std::shared_ptr<IMemoryManager> get_memory_manager(GraphContext &ctx, Target target)
+{
+    bool enabled = ctx.is_memory_management_enabled() && (ctx.memory_management_ctx(target) != nullptr);
+    return enabled ? ctx.memory_management_ctx(target)->mm : nullptr;
+}
+} // namespace backends
+} // namespace graph2
+} // namespace arm_compute
+
+#endif /* __ARM_COMPUTE_GRAPH2_BACKENDS_UTILS_H__ */
diff --git a/arm_compute/graph2/detail/ExecutionHelpers.h b/arm_compute/graph2/detail/ExecutionHelpers.h
new file mode 100644
index 0000000000..acd1654a06
--- /dev/null
+++ b/arm_compute/graph2/detail/ExecutionHelpers.h
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_DETAIL_EXECUTION_HELPERS_H__
+#define __ARM_COMPUTE_GRAPH2_DETAIL_EXECUTION_HELPERS_H__
+
+#include "arm_compute/graph2/Types.h"
+
+namespace arm_compute
+{
+namespace graph2
+{
+// Forward declarations
+class Graph;
+class GraphContext;
+class ExecutionWorkload;
+class Tensor;
+
+namespace detail
+{
+/** Initializes the available backends **/
+void default_initialize_backends();
+/** Configures all nodes of a graph
+ *
+ * @param[in] g Graph to configure
+ */
+void configure_all_tensors(Graph &g);
+/** Allocates all tensors of a graph
+ *
+ * @param[in] g Graph to allocate the tensors
+ */
+void allocate_all_tensors(Graph &g);
+/** Configures all nodes of graph
+ *
+ * @param[in] g   Graph to configure the nodes
+ * @param[in] ctx Graph context to use
+ *
+ * @return The execution workload
+ */
+ExecutionWorkload configure_all_nodes(Graph &g, GraphContext &ctx);
+/** Calls accessor of a given tensor
+ *
+ * @param[in] tensor The tensor of which the accessor should be called
+ */
+void call_tensor_accessor(Tensor *tensor);
+/** Call all const node accessors
+ *
+ * @param[in] g Graph containing the const nodes
+ */
+void call_all_const_node_accessors(Graph &g);
+/** Call all input node accessors
+ *
+ * @param[in] workload Workload to execute
+ */
+void call_all_input_node_accessors(ExecutionWorkload &workload);
+/** Call all output node accessors
+ *
+ * @param[in] workload Workload to execute
+ */
+void call_all_output_node_accessors(ExecutionWorkload &workload);
+/** Executes all tasks of a workload
+ *
+ * @param[in] workload Workload to execute
+ */
+void call_all_tasks(ExecutionWorkload &workload);
+} // namespace detail
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_DETAIL_EXECUTION_HELPERS_H__ */
diff --git a/arm_compute/graph2/frontend/ILayer.h b/arm_compute/graph2/frontend/ILayer.h
new file mode 100644
index 0000000000..fee0b37e64
--- /dev/null
+++ b/arm_compute/graph2/frontend/ILayer.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_ILAYER_H__
+#define __ARM_COMPUTE_GRAPH2_ILAYER_H__
+
+namespace arm_compute
+{
+namespace graph2
+{
+namespace frontend
+{
+// Forward declarations
+class IStream;
+
+/** ILayer interface **/
+class ILayer
+{
+public:
+    virtual ~ILayer()                       = default;
+    virtual NodeID create_layer(IStream &s) = 0;
+};
+} // namespace frontend
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_ILAYER_H__ */
diff --git a/arm_compute/graph2/frontend/IStream.h b/arm_compute/graph2/frontend/IStream.h
new file mode 100644
index 0000000000..110be5230d
--- /dev/null
+++ b/arm_compute/graph2/frontend/IStream.h
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_ISTREAM_H__
+#define __ARM_COMPUTE_GRAPH2_ISTREAM_H__
+
+#include "arm_compute/graph2/frontend/Types.h"
+
+namespace arm_compute
+{
+namespace graph2
+{
+// Forward declarations
+class Graph;
+
+namespace frontend
+{
+// Forward declarations
+class ILayer;
+
+/** Stream interface **/
+class IStream
+{
+public:
+    virtual ~IStream() = default;
+    /** Adds a layer to the stream
+     *
+     * @param[in] layer Layer to add
+     */
+    virtual void add_layer(ILayer &layer) = 0;
+    /** Returns the underlying graph
+     *
+     * @return Underlying graph
+     */
+    virtual Graph &graph() = 0;
+    /** Returns the underlying graph
+     *
+     * @return Underlying graph
+     */
+    virtual const Graph &graph() const = 0;
+    /** Returns the tail node of the Stream
+     *
+     * @return Tail Node ID
+     */
+    NodeID tail_node()
+    {
+        return _tail_node;
+    }
+    /** Returns the stream hints that are currently used
+     *
+     * @return Stream hints
+     */
+    StreamHints &hints()
+    {
+        return _hints;
+    }
+    /** Forwards tail of stream to a given nid
+     *
+     * @param[in] nid NodeID of the updated tail node
+     */
+    void forward_tail(NodeID nid)
+    {
+        _tail_node = (nid != NullTensorID) ? nid : _tail_node;
+    }
+
+protected:
+    StreamHints _hints     = {};              /**< Execution and algorithmic hints */
+    NodeID      _tail_node = { EmptyNodeID }; /**< NodeID pointing to the last(tail) node of the graph */
+};
+} // namespace frontend
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_ISTREAM_H__ */
diff --git a/arm_compute/graph2/frontend/IStreamOperators.h b/arm_compute/graph2/frontend/IStreamOperators.h
new file mode 100644
index 0000000000..1798e4a4ab
--- /dev/null
+++ b/arm_compute/graph2/frontend/IStreamOperators.h
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_ISTREAM_OPERATORS_H__
+#define __ARM_COMPUTE_GRAPH2_ISTREAM_OPERATORS_H__
+
+#include "arm_compute/graph2/frontend/IStream.h"
+#include "arm_compute/graph2/frontend/Types.h"
+
+namespace arm_compute
+{
+namespace graph2
+{
+namespace frontend
+{
+// Forward declarations
+class ILayer;
+
+/** Overloaded stream operator to add a node to the graph
+ *
+ * @param[in, out] s     Stream to add the tensor
+ * @param[in]      layer Layer to be added
+ *
+ * @return Updated stream
+ */
+inline IStream &operator<<(IStream &s, ILayer &&layer)
+{
+    s.add_layer(layer);
+    return s;
+}
+/** Overloaded stream operator to provide a target hint to the graph
+ *
+ * @param[in, out] s           Stream to provide the hint to
+ * @param[in]      target_hint Target hint to be considered
+ *
+ * @return Updated stream
+ */
+inline IStream &operator<<(IStream &s, Target target_hint)
+{
+    s.hints().target_hint = target_hint;
+    return s;
+}
+/** Overloaded stream operator to provide a convolution method hint to the graph
+ *
+ * @param[in, out] s                       Stream to provide the hint to
+ * @param[in]      convolution_method_hint Convolution method hint to be considered
+ *
+ * @return Updated stream
+ */
+inline IStream &operator<<(IStream &s, ConvolutionMethod convolution_method_hint)
+{
+    s.hints().convolution_method_hint = convolution_method_hint;
+    return s;
+}
+/** Overloaded stream operator to provide a depthwise convolution method hint to the graph
+ *
+ * @param[in, out] s                                 Stream to provide the hint to
+ * @param[in]      depthwise_convolution_method_hint Depthwise Convolution method hint to be considered
+ *
+ * @return Updated stream
+ */
+inline IStream &operator<<(IStream &s, DepthwiseConvolutionMethod depthwise_convolution_method_hint)
+{
+    s.hints().depthwise_convolution_method_hint = depthwise_convolution_method_hint;
+    return s;
+}
+} // namespace frontend
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_ISTREAM_OPERATORS_H__ */
diff --git a/arm_compute/graph2/frontend/Layers.h b/arm_compute/graph2/frontend/Layers.h
new file mode 100644
index 0000000000..40274a4769
--- /dev/null
+++ b/arm_compute/graph2/frontend/Layers.h
@@ -0,0 +1,410 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_LAYERS_H__
+#define __ARM_COMPUTE_GRAPH2_LAYERS_H__
+
+#include "arm_compute/graph2/GraphBuilder.h"
+#include "arm_compute/graph2/Types.h"
+#include "arm_compute/graph2/frontend/ILayer.h"
+#include "arm_compute/graph2/frontend/IStream.h"
+#include "arm_compute/graph2/frontend/SubStream.h"
+
+#include "arm_compute/core/utils/misc/Utility.h"
+
+#include <memory>
+#include <string>
+
+namespace arm_compute
+{
+namespace graph2
+{
+namespace frontend
+{
+/** Input Layer */
+class InputLayer final : public ILayer
+{
+public:
+    InputLayer(TensorDescriptor desc, ITensorAccessorUPtr accessor)
+        : _desc(desc), _accessor(std::move(accessor))
+    {
+    }
+
+    NodeID create_layer(IStream &s) override
+    {
+        NodeParams common_params = { "", s.hints().target_hint };
+        return GraphBuilder::add_input_node(s.graph(), common_params, _desc, std::move(_accessor));
+    }
+
+private:
+    TensorDescriptor    _desc;
+    ITensorAccessorUPtr _accessor;
+};
+
+/** Output Layer */
+class OutputLayer final : public ILayer
+{
+public:
+    OutputLayer(ITensorAccessorUPtr accessor)
+        : _accessor(std::move(accessor))
+    {
+    }
+
+    NodeID create_layer(IStream &s) override
+    {
+        NodeParams  common_params = { "", s.hints().target_hint };
+        NodeIdxPair input         = { s.tail_node(), 0 };
+        return GraphBuilder::add_output_node(s.graph(), common_params, input, std::move(_accessor));
+    }
+
+private:
+    ITensorAccessorUPtr _accessor;
+};
+
+/** Activation Layer */
+class ActivationLayer final : public ILayer
+{
+public:
+    ActivationLayer(ActivationLayerInfo act_info)
+        : _act_info(act_info)
+    {
+    }
+
+    NodeID create_layer(IStream &s) override
+    {
+        NodeParams  common_params = { "", s.hints().target_hint };
+        NodeIdxPair input         = { s.tail_node(), 0 };
+        return GraphBuilder::add_activation_node(s.graph(), common_params, input, _act_info);
+    }
+
+private:
+    ActivationLayerInfo _act_info;
+};
+
+/** Batchnormalization Layer */
+class BatchNormalizationLayer final : public ILayer
+{
+public:
+    BatchNormalizationLayer(ITensorAccessorUPtr mean,
+                            ITensorAccessorUPtr var,
+                            ITensorAccessorUPtr gamma   = nullptr,
+                            ITensorAccessorUPtr beta    = nullptr,
+                            float               epsilon = 0.001f)
+        : _mean(std::move(mean)), _var(std::move(var)), _gamma(std::move(gamma)), _beta(std::move(beta)), _epsilon(epsilon)
+    {
+    }
+
+    NodeID create_layer(IStream &s) override
+    {
+        ARM_COMPUTE_ERROR_ON(_mean == nullptr);
+        ARM_COMPUTE_ERROR_ON(_var == nullptr);
+
+        NodeParams  common_params = { "", s.hints().target_hint };
+        NodeIdxPair input         = { s.tail_node(), 0 };
+        return GraphBuilder::add_batch_normalization_node(s.graph(), common_params, input, _epsilon,
+                                                          std::move(_mean), std::move(_var), std::move(_beta), std::move(_gamma));
+    }
+
+private:
+    ITensorAccessorUPtr _mean;
+    ITensorAccessorUPtr _var;
+    ITensorAccessorUPtr _gamma;
+    ITensorAccessorUPtr _beta;
+    float               _epsilon;
+};
+
+/** Convolution Layer */
+class ConvolutionLayer final : public ILayer
+{
+public:
+    ConvolutionLayer(unsigned int        conv_width,
+                     unsigned int        conv_height,
+                     unsigned int        ofm,
+                     ITensorAccessorUPtr weights,
+                     ITensorAccessorUPtr bias,
+                     PadStrideInfo       conv_info,
+                     unsigned int        num_groups = 1)
+        : _conv_width(conv_width),
+          _conv_height(conv_height),
+          _ofm(ofm),
+          _conv_info(std::move(conv_info)),
+          _num_groups(num_groups),
+          _weights(std::move(weights)),
+          _bias(std::move(bias))
+    {
+    }
+
+    NodeID create_layer(IStream &s) override
+    {
+        ARM_COMPUTE_UNUSED(_num_groups);
+        NodeIdxPair input         = { s.tail_node(), 0 };
+        NodeParams  common_params = { "", s.hints().target_hint };
+        return GraphBuilder::add_convolution_node(s.graph(), common_params, input,
+                                                  Size2D(_conv_width, _conv_height), _ofm, _conv_info,
+                                                  s.hints().convolution_method_hint,
+                                                  std::move(_weights), std::move(_bias));
+    }
+
+private:
+    unsigned int        _conv_width;
+    unsigned int        _conv_height;
+    unsigned int        _ofm;
+    const PadStrideInfo _conv_info;
+    unsigned int        _num_groups;
+    ITensorAccessorUPtr _weights;
+    ITensorAccessorUPtr _bias;
+};
+
+/** Depthwise Convolution Layer */
+class DepthwiseConvolutionLayer final : public ILayer
+{
+public:
+    DepthwiseConvolutionLayer(unsigned int        conv_width,
+                              unsigned int        conv_height,
+                              ITensorAccessorUPtr weights,
+                              ITensorAccessorUPtr bias,
+                              PadStrideInfo       conv_info)
+        : _conv_width(conv_width),
+          _conv_height(conv_height),
+          _conv_info(std::move(conv_info)),
+          _weights(std::move(weights)),
+          _bias(std::move(bias))
+    {
+    }
+
+    NodeID create_layer(IStream &s) override
+    {
+        NodeIdxPair input         = { s.tail_node(), 0 };
+        NodeParams  common_params = { "", s.hints().target_hint };
+        return GraphBuilder::add_depthwise_convolution_node(s.graph(), common_params,
+                                                            input, Size2D(_conv_width, _conv_height), _conv_info,
+                                                            s.hints().depthwise_convolution_method_hint,
+                                                            std::move(_weights), std::move(_bias));
+    }
+
+private:
+    unsigned int        _conv_width;
+    unsigned int        _conv_height;
+    const PadStrideInfo _conv_info;
+    ITensorAccessorUPtr _weights;
+    ITensorAccessorUPtr _bias;
+};
+
+/** Flatten Layer */
+class FlattenLayer final : public ILayer
+{
+public:
+    FlattenLayer()
+    {
+    }
+
+    NodeID create_layer(IStream &s) override
+    {
+        NodeParams  common_params = { "", s.hints().target_hint };
+        NodeIdxPair input         = { s.tail_node(), 0 };
+        return GraphBuilder::add_flatten_node(s.graph(), common_params, input);
+    }
+};
+
+/** Fully Connected Layer */
+class FullyConnectedLayer final : public ILayer
+{
+public:
+    FullyConnectedLayer(unsigned int        num_outputs,
+                        ITensorAccessorUPtr weights,
+                        ITensorAccessorUPtr bias)
+        : _num_outputs(num_outputs), _weights(std::move(weights)), _bias(std::move(bias))
+    {
+    }
+
+    NodeID create_layer(IStream &s) override
+    {
+        NodeParams  common_params = { "", s.hints().target_hint };
+        NodeIdxPair input         = { s.tail_node(), 0 };
+        return GraphBuilder::add_fully_connected_layer(s.graph(), common_params, input, _num_outputs,
+                                                       std::move(_weights), std::move(_bias));
+    }
+
+private:
+    unsigned int        _num_outputs;
+    ITensorAccessorUPtr _weights;
+    ITensorAccessorUPtr _bias;
+};
+
+/** Normalization Layer */
+class NormalizationLayer final : public ILayer
+{
+public:
+    NormalizationLayer(NormalizationLayerInfo norm_info)
+        : _norm_info(norm_info)
+    {
+    }
+
+    NodeID create_layer(IStream &s) override
+    {
+        NodeParams  common_params = { "", s.hints().target_hint };
+        NodeIdxPair input         = { s.tail_node(), 0 };
+        return GraphBuilder::add_normalization_node(s.graph(), common_params, input, _norm_info);
+    }
+
+private:
+    NormalizationLayerInfo _norm_info;
+};
+
+/** Pooling Layer */
+class PoolingLayer final : public ILayer
+{
+public:
+    PoolingLayer(PoolingLayerInfo pool_info)
+        : _pool_info(pool_info)
+    {
+    }
+
+    NodeID create_layer(IStream &s) override
+    {
+        NodeParams  common_params = { "", s.hints().target_hint };
+        NodeIdxPair input         = { s.tail_node(), 0 };
+        return GraphBuilder::add_pooling_node(s.graph(), common_params, input, _pool_info);
+    }
+
+private:
+    PoolingLayerInfo _pool_info;
+};
+
+/** Reshape Layer */
+class ReshapeLayer final : public ILayer
+{
+public:
+    ReshapeLayer(TensorShape shape)
+        : _shape(shape)
+    {
+    }
+
+    NodeID create_layer(IStream &s) override
+    {
+        NodeParams  common_params = { "", s.hints().target_hint };
+        NodeIdxPair input         = { s.tail_node(), 0 };
+        return GraphBuilder::add_reshape_node(s.graph(), common_params, input, _shape);
+    }
+
+private:
+    TensorShape _shape;
+};
+
+/** Softmax Layer */
+class SoftmaxLayer final : public ILayer
+{
+public:
+    SoftmaxLayer(float beta = 1.0f)
+        : _beta(beta)
+    {
+    }
+
+    NodeID create_layer(IStream &s) override
+    {
+        NodeParams  common_params = { "", s.hints().target_hint };
+        NodeIdxPair input         = { s.tail_node(), 0 };
+        return GraphBuilder::add_softmax_node(s.graph(), common_params, input, _beta);
+    }
+
+private:
+    float _beta;
+};
+
+/** Branch Layer */
+class BranchLayer final : public ILayer
+{
+public:
+    /** Default Constructor
+     *
+     * @param[in] merge_method     Branch merging method
+     * @param[in] sub_stream1      First graph branch
+     * @param[in] sub_stream2      Second graph branch
+     * @param[in] rest_sub_streams Rest sub-graph branches
+     */
+    template <typename... Ts>
+    BranchLayer(BranchMergeMethod merge_method, SubStream &&sub_stream1, SubStream &&sub_stream2, Ts &&... rest_sub_streams)
+        : _branch_merge_method(merge_method), _sub_streams()
+    {
+        _sub_streams.push_back(arm_compute::support::cpp14::make_unique<SubStream>(std::move(sub_stream1)));
+        _sub_streams.push_back(arm_compute::support::cpp14::make_unique<SubStream>(std::move(sub_stream2)));
+
+        utility::for_each([&](SubStream && sub_stream)
+        {
+            _sub_streams.push_back(arm_compute::support::cpp14::make_unique<SubStream>(std::move(sub_stream)));
+        },
+        std::move(rest_sub_streams)...);
+    }
+    /** Default Constructor
+     *
+     * @param[in] sub_stream Sub-stream
+     */
+    template <typename... Ts>
+    BranchLayer(SubStream &&sub_stream)
+        : _branch_merge_method(BranchMergeMethod::DEPTH_CONCATENATE), _sub_streams()
+    {
+        _sub_streams.push_back(arm_compute::support::cpp14::make_unique<SubStream>(std::move(sub_stream)));
+    }
+    NodeID create_layer(IStream &s) override
+    {
+        NodeID     nid           = EmptyNodeID;
+        NodeParams common_params = { "", s.hints().target_hint };
+        if(_sub_streams.size() == 1 && _sub_streams.at(0) != nullptr)
+        {
+            nid = _sub_streams[0]->tail_node();
+        }
+        else if(_branch_merge_method == BranchMergeMethod::DEPTH_CONCATENATE)
+        {
+            // Collect tail nodes and perform DepthConcatenate
+            std::vector<NodeIdxPair> nodes;
+            for(auto &ss : _sub_streams)
+            {
+                if(ss && (ss->tail_node() != EmptyNodeID))
+                {
+                    const auto tail_node = s.graph().node(ss->tail_node());
+                    if(tail_node != nullptr && tail_node->type() != NodeType::Output)
+                    {
+                        nodes.push_back({ ss->tail_node(), 0 });
+                    }
+                }
+            }
+            nid = GraphBuilder::add_depth_concatenate_node(s.graph(), common_params, nodes);
+        }
+        else
+        {
+            ARM_COMPUTE_ERROR_ON(_sub_streams.size() != 2);
+            NodeIdxPair input0 = { _sub_streams[0]->tail_node(), 0 };
+            NodeIdxPair input1 = { _sub_streams[1]->tail_node(), 0 };
+            nid                = GraphBuilder::add_elementwise_node(s.graph(), common_params, input0, input1, EltwiseOperation::ADD);
+        }
+        return nid;
+    }
+
+private:
+    BranchMergeMethod                       _branch_merge_method;
+    std::vector<std::unique_ptr<SubStream>> _sub_streams;
+};
+} // namespace frontend
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_LAYERS_H__ */
diff --git a/arm_compute/graph2/frontend/Stream.h b/arm_compute/graph2/frontend/Stream.h
new file mode 100644
index 0000000000..6100975958
--- /dev/null
+++ b/arm_compute/graph2/frontend/Stream.h
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_STREAM_H__
+#define __ARM_COMPUTE_GRAPH2_STREAM_H__
+
+#include "arm_compute/graph2/frontend/IStream.h"
+#include "arm_compute/graph2/frontend/IStreamOperators.h"
+#include "arm_compute/graph2/frontend/Types.h"
+
+#include "arm_compute/graph2/Graph.h"
+#include "arm_compute/graph2/GraphContext.h"
+#include "arm_compute/graph2/GraphManager.h"
+
+namespace arm_compute
+{
+namespace graph2
+{
+namespace frontend
+{
+// Forward Declarations
+class ILayer;
+
+/** Stream frontend class to construct simple graphs in a stream fashion */
+class Stream final : public IStream
+{
+public:
+    /** Constructor
+     *
+     * @param[in] id   Stream id
+     * @param[in] name Stream name
+     */
+    Stream(size_t id, std::string name);
+    /** Prevent instances of this class from being copied (As this class contains pointers) */
+    Stream(const Stream &) = delete;
+    /** Default move constructor */
+    Stream(Stream &&) = default;
+    /** Prevent instances of this class from being copied (As this class contains pointers) */
+    Stream &operator=(const Stream &) = delete;
+    /** Default move assignment operator */
+    Stream &operator=(Stream &&) = default;
+    /** Finalizes the stream for an execution target
+     *
+     * @note enable_tuning only works if the target is OpenCL.
+     * @note tuning increases the execution time of first run of the graph
+     *
+     * @param[in] target                   Execution target
+     * @param[in] enable_tuning            (Optional) Enables the tuning interface. Defaults to false
+     * @param[in] enable_memory_management (Optional) Enables the memory management interface. Defaults to false
+     */
+    void finalize(Target target, bool enable_tuning = false, bool enable_memory_management = false);
+    /** Executes the stream **/
+    void run();
+
+    // Inherited overridden methods
+    void add_layer(ILayer &layer) override;
+    Graph       &graph() override;
+    const Graph &graph() const override;
+
+private:
+    GraphManager _manager; /**< Graph manager */
+    GraphContext _ctx;     /**< Graph context to use */
+    Graph        _g;       /**< Internal graph representation of the stream */
+};
+} // namespace frontend
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_STREAM_H__ */
\ No newline at end of file
diff --git a/arm_compute/graph2/frontend/SubStream.h b/arm_compute/graph2/frontend/SubStream.h
new file mode 100644
index 0000000000..dee09b76ea
--- /dev/null
+++ b/arm_compute/graph2/frontend/SubStream.h
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_SUB_STREAM_H__
+#define __ARM_COMPUTE_GRAPH2_SUB_STREAM_H__
+
+#include "arm_compute/graph2/frontend/IStream.h"
+#include "arm_compute/graph2/frontend/IStreamOperators.h"
+#include "arm_compute/graph2/frontend/Types.h"
+
+#include <memory>
+#include <vector>
+
+namespace arm_compute
+{
+namespace graph2
+{
+// Forward declarations
+class Graph;
+
+namespace frontend
+{
+// Forward declarations
+class ILayer;
+
+/** Sub stream class*/
+class SubStream final : public IStream
+{
+public:
+    /** Default Constructor
+     *
+     * @param[in] s Parent stream
+     */
+    SubStream(IStream &s);
+    /** Prevent instances of this class from being copied (As this class contains pointers) */
+    SubStream(const SubStream &) = delete;
+    /** Default move constructor */
+    SubStream(SubStream &&) = default;
+    /** Prevent instances of this class from being copied (As this class contains pointers) */
+    SubStream &operator=(const SubStream &) = delete;
+    /** Default move assignment operator */
+    SubStream &operator=(SubStream &&) = default;
+
+    // Inherited overridden methods
+    void add_layer(ILayer &layer) override;
+    Graph       &graph() override;
+    const Graph &graph() const override;
+
+private:
+    IStream &_s; /**< Parent stream (assume that the lifetime of the parent is longer) */
+};
+} // namespace frontend
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_SUB_STREAM_H__ */
diff --git a/arm_compute/graph2/frontend/Types.h b/arm_compute/graph2/frontend/Types.h
new file mode 100644
index 0000000000..234b998126
--- /dev/null
+++ b/arm_compute/graph2/frontend/Types.h
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_STREAM_TYPES_H__
+#define __ARM_COMPUTE_GRAPH2_STREAM_TYPES_H__
+
+#include "arm_compute/graph2/Types.h"
+
+namespace arm_compute
+{
+namespace graph2
+{
+namespace frontend
+{
+// Import types for graph
+using graph2::DataType;
+using graph2::TensorShape;
+
+using graph2::ActivationLayerInfo;
+using graph2::NormalizationLayerInfo;
+using graph2::NormType;
+using graph2::PadStrideInfo;
+using graph2::PoolingLayerInfo;
+using graph2::PoolingType;
+using graph2::Target;
+using graph2::ConvolutionMethod;
+using graph2::DepthwiseConvolutionMethod;
+using graph2::TensorDescriptor;
+using graph2::DimensionRoundingType;
+
+/** Branch layer merging method */
+enum class BranchMergeMethod
+{
+    DEPTH_CONCATENATE, /**< Concatenate across depth */
+    ADD                /**< Adds the results of each stream */
+};
+
+/** Hints that can be passed to the stream to expose parameterization */
+struct StreamHints
+{
+    Target                     target_hint                       = { Target::UNSPECIFIED };                 /**< Target execution hint */
+    ConvolutionMethod          convolution_method_hint           = { ConvolutionMethod::DEFAULT };          /**< Convolution method hint */
+    DepthwiseConvolutionMethod depthwise_convolution_method_hint = { DepthwiseConvolutionMethod::DEFAULT }; /**< Depthwise Convolution method hint */
+};
+} // namespace frontend
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_STREAM_TYPES_H__ */
\ No newline at end of file
diff --git a/arm_compute/graph2/mutators/DepthConcatSubTensorMutator.h b/arm_compute/graph2/mutators/DepthConcatSubTensorMutator.h
new file mode 100644
index 0000000000..bdf2e01edb
--- /dev/null
+++ b/arm_compute/graph2/mutators/DepthConcatSubTensorMutator.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_DEPTH_CONCAT_SUBTENSOR_MUTATOR_H__
+#define __ARM_COMPUTE_GRAPH2_DEPTH_CONCAT_SUBTENSOR_MUTATOR_H__
+
+#include "arm_compute/graph2/IGraphMutator.h"
+
+namespace arm_compute
+{
+namespace graph2
+{
+/** Mutation pass to optimize depth concatenation operations by using sub-tensors
+ *
+ * @warning Always run as one of the last mutation pass as optimizations might change the parent of sub-tensors.
+ **/
+class DepthConcatSubTensorMutator final : public IGraphMutator
+{
+public:
+    // Inherited methods overridden
+    virtual void mutate(Graph &g) override;
+    const char *name() override;
+};
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_DEPTH_CONCAT_SUBTENSOR_MUTATOR_H__ */
diff --git a/arm_compute/graph2/mutators/GraphMutators.h b/arm_compute/graph2/mutators/GraphMutators.h
new file mode 100644
index 0000000000..b432e329e2
--- /dev/null
+++ b/arm_compute/graph2/mutators/GraphMutators.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_GRAPH_MUTATORS_H__
+#define __ARM_COMPUTE_GRAPH2_GRAPH_MUTATORS_H__
+
+#include "arm_compute/graph2/mutators/DepthConcatSubTensorMutator.h"
+#include "arm_compute/graph2/mutators/InPlaceOperationMutator.h"
+#include "arm_compute/graph2/mutators/NodeFusionMutator.h"
+
+#endif /* __ARM_COMPUTE_GRAPH2_GRAPH_MUTATORS_H__ */
diff --git a/arm_compute/graph2/mutators/InPlaceOperationMutator.h b/arm_compute/graph2/mutators/InPlaceOperationMutator.h
new file mode 100644
index 0000000000..7e4018a736
--- /dev/null
+++ b/arm_compute/graph2/mutators/InPlaceOperationMutator.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_INPLACE_OPERATION_MUTATOR_H__
+#define __ARM_COMPUTE_GRAPH2_INPLACE_OPERATION_MUTATOR_H__
+
+#include "arm_compute/graph2/IGraphMutator.h"
+
+namespace arm_compute
+{
+namespace graph2
+{
+/** Mutation pass to optimize operations that can be performed in-place */
+class InPlaceOperationMutator final : public IGraphMutator
+{
+public:
+    // Inherited methods overridden
+    virtual void mutate(Graph &g) override;
+    const char *name() override;
+};
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_INPLACE_OPERATION_MUTATOR_H__ */
diff --git a/arm_compute/graph2/mutators/NodeFusionMutator.h b/arm_compute/graph2/mutators/NodeFusionMutator.h
new file mode 100644
index 0000000000..4371bd3ebe
--- /dev/null
+++ b/arm_compute/graph2/mutators/NodeFusionMutator.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_NODE_FUSION_MUTATOR_H__
+#define __ARM_COMPUTE_GRAPH2_NODE_FUSION_MUTATOR_H__
+
+#include "arm_compute/graph2/IGraphMutator.h"
+
+namespace arm_compute
+{
+namespace graph2
+{
+namespace detail
+{
+/** Fused batch normalization with activation
+ *
+ * @param[in] g Graph to perform operation fusion on
+ */
+void fuse_batch_norm_with_activation(Graph &g);
+} // namespace detail
+
+/** Mutation pass to fuss nodes */
+class NodeFusionMutator final : public IGraphMutator
+{
+public:
+    // Inherited methods overridden
+    virtual void mutate(Graph &g) override;
+    const char *name() override;
+};
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_NODE_FUSION_MUTATOR_H__ */
diff --git a/arm_compute/graph2/nodes/ActivationLayerNode.h b/arm_compute/graph2/nodes/ActivationLayerNode.h
new file mode 100644
index 0000000000..c3775231a4
--- /dev/null
+++ b/arm_compute/graph2/nodes/ActivationLayerNode.h
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_ACTIVATION_LAYER_NODE_H__
+#define __ARM_COMPUTE_GRAPH2_ACTIVATION_LAYER_NODE_H__
+
+#include "arm_compute/graph2/INode.h"
+
+namespace arm_compute
+{
+namespace graph2
+{
+class ActivationLayerNode final : public INode
+{
+public:
+    /** Constructor
+     *
+     * @param[in] info Activation Layer information
+     */
+    ActivationLayerNode(ActivationLayerInfo info);
+    /** Activation metadata accessor
+     *
+     * @return The activation info of the layer
+     */
+    ActivationLayerInfo activation_info() const;
+
+    // Inherited overridden methods:
+    Status           validate() override;
+    NodeType         type() const override;
+    bool             forward_descriptors() override;
+    TensorDescriptor configure_output(size_t idx) const override;
+    void accept(INodeVisitor &v) override;
+
+private:
+    ActivationLayerInfo _info;
+};
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_ACTIVATION_LAYER_NODE_H__ */
diff --git a/arm_compute/graph2/nodes/BatchNormalizationLayerNode.h b/arm_compute/graph2/nodes/BatchNormalizationLayerNode.h
new file mode 100644
index 0000000000..a521938414
--- /dev/null
+++ b/arm_compute/graph2/nodes/BatchNormalizationLayerNode.h
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_BATCH_NORMALIZATION_LAYER_NODE_H__
+#define __ARM_COMPUTE_GRAPH2_BATCH_NORMALIZATION_LAYER_NODE_H__
+
+#include "arm_compute/graph2/INode.h"
+
+namespace arm_compute
+{
+namespace graph2
+{
+class BatchNormalizationLayerNode final : public INode
+{
+public:
+    /** Constructor
+     *
+     * @param[in] epsilon          (Optional) Epsilon parameter. Defaults to 1.f
+     * @param[in] fused_activation (Optional) Fused activation layer. Disabled if not specified
+     */
+    BatchNormalizationLayerNode(float epsilon = 1.f, ActivationLayerInfo fused_activation = ActivationLayerInfo());
+    /** Epsilon parameter accessor
+     *
+     * @return Epsilon parameter
+     */
+    float epsilon() const;
+    /** Returns fused activation
+     *
+     * @return Fused activation
+     */
+    ActivationLayerInfo fused_activation() const;
+    /** Sets fused activation
+     *
+     * @param[in] fused_activation Fused activation to set
+     */
+    void set_fused_activation(ActivationLayerInfo fused_activation);
+
+    // Inherited overridden methods:
+    Status           validate() override;
+    NodeType         type() const override;
+    bool             forward_descriptors() override;
+    TensorDescriptor configure_output(size_t idx) const override;
+    void accept(INodeVisitor &v) override;
+
+private:
+    float               _epsilon;
+    ActivationLayerInfo _fused_activation;
+};
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_BATCH_NORMALIZATION_LAYER_NODE_H__ */
diff --git a/arm_compute/graph2/nodes/ConstNode.h b/arm_compute/graph2/nodes/ConstNode.h
new file mode 100644
index 0000000000..73a2246498
--- /dev/null
+++ b/arm_compute/graph2/nodes/ConstNode.h
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_CONST_NODE_H__
+#define __ARM_COMPUTE_GRAPH2_CONST_NODE_H__
+
+#include "arm_compute/graph2/INode.h"
+
+namespace arm_compute
+{
+namespace graph2
+{
+class ConstNode final : public INode
+{
+public:
+    /** Constructor
+     *
+     * @param[in] desc Tensor descriptor
+     */
+    ConstNode(TensorDescriptor desc);
+
+    // Inherited overridden methods:
+    Status           validate() override;
+    NodeType         type() const override;
+    bool             forward_descriptors() override;
+    TensorDescriptor configure_output(size_t idx) const override;
+    void accept(INodeVisitor &v) override;
+
+private:
+    TensorDescriptor _desc;
+};
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_CONST_NODE_H__ */
diff --git a/arm_compute/graph2/nodes/ConvolutionLayerNode.h b/arm_compute/graph2/nodes/ConvolutionLayerNode.h
new file mode 100644
index 0000000000..1af344ea13
--- /dev/null
+++ b/arm_compute/graph2/nodes/ConvolutionLayerNode.h
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_CONVOLUTION_LAYER_NODE_H__
+#define __ARM_COMPUTE_GRAPH2_CONVOLUTION_LAYER_NODE_H__
+
+#include "arm_compute/graph2/INode.h"
+
+namespace arm_compute
+{
+namespace graph2
+{
+class ConvolutionLayerNode final : public INode
+{
+public:
+    /** Constructor
+     *
+     * @param[in] info   Convolution layer attributes
+     * @param[in] method (Optional) Convolution method to use
+     */
+    ConvolutionLayerNode(PadStrideInfo info, ConvolutionMethod method = ConvolutionMethod::DEFAULT);
+    /** Sets the convolution layer method to use
+     *
+     * @param[in] method Method to use for convolution
+     */
+    void set_convolution_method(ConvolutionMethod method);
+    /** Convolution layer method accessor
+     *
+     * @note This is an indication on which convolution layer implementation to use,
+     *       if it fails to be created the library's heuristic approach will be used
+     *
+     * @return Convolution layer method do be used by the node
+     */
+    ConvolutionMethod convolution_method() const;
+    /** Convolution metadata accessor
+     *
+     * @return Convolution information
+     */
+    PadStrideInfo convolution_info() const;
+    /** Computes convolution output shape
+     *
+     * @param[in] input_shape   Input shape
+     * @param[in] weights_shape Weights shape
+     * @param[in] info          Convolution operation attributes
+     *
+     * @return Output shape
+     */
+    static TensorShape compute_output_shape(TensorShape input_shape, TensorShape weights_shape, PadStrideInfo info);
+
+    // Inherited overridden methods:
+    Status           validate() override;
+    NodeType         type() const override;
+    bool             forward_descriptors() override;
+    TensorDescriptor configure_output(size_t idx) const override;
+    void accept(INodeVisitor &v) override;
+
+private:
+    PadStrideInfo     _info;
+    ConvolutionMethod _method;
+};
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_CONVOLUTION_LAYER_NODE_H__ */
diff --git a/arm_compute/graph2/nodes/DepthConcatenateLayerNode.h b/arm_compute/graph2/nodes/DepthConcatenateLayerNode.h
new file mode 100644
index 0000000000..617b9842fb
--- /dev/null
+++ b/arm_compute/graph2/nodes/DepthConcatenateLayerNode.h
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_DEPTH_CONCATENATE_LAYER_NODE_H__
+#define __ARM_COMPUTE_GRAPH2_DEPTH_CONCATENATE_LAYER_NODE_H__
+
+#include "arm_compute/graph2/INode.h"
+
+namespace arm_compute
+{
+namespace graph2
+{
+class DepthConcatenateLayerNode final : public INode
+{
+public:
+    /** Constructor
+     *
+     * @param[in] total_nodes Number of nodes that will get concatenated
+     */
+    DepthConcatenateLayerNode(unsigned int total_nodes);
+    /** Computes depth concatenations output shape
+     *
+     * @param input_shapes   Shapes of the inputs
+     *
+     * @return Expected output shape
+     */
+    static TensorShape compute_output_shape(const std::vector<TensorShape> &input_shapes);
+    /** Disables or not the depth concatenate node
+     *
+     * @warning This is used when depth concatenate is performed with sub-tensors,
+     *          where this node is used as a placeholder.
+     *
+     * @param[in] is_enabled If true a backend function is created to perform the depth concatenation (involves copying),
+     *                       while if false, no function is created and we assume that subtensors are properly set to simulate
+     *                       a no copy operation.
+     */
+    void set_enabled(bool is_enabled);
+    /** Enabled parameter accessor
+     *
+     * @return True if a backend function is to be created else false
+     */
+    bool is_enabled() const;
+
+    // Inherited overridden methods:
+    Status           validate() override;
+    NodeType         type() const override;
+    bool             forward_descriptors() override;
+    TensorDescriptor configure_output(size_t idx) const override;
+    void accept(INodeVisitor &v) override;
+
+private:
+    unsigned int _total_nodes;
+    bool         _is_enabled;
+};
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_DEPTH_CONCATENATE_LAYER_NODE_H__ */
diff --git a/arm_compute/graph2/nodes/DepthwiseConvolutionLayerNode.h b/arm_compute/graph2/nodes/DepthwiseConvolutionLayerNode.h
new file mode 100644
index 0000000000..1b05edf4dc
--- /dev/null
+++ b/arm_compute/graph2/nodes/DepthwiseConvolutionLayerNode.h
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_DEPTHWISE_CONVOLUTION_LAYER_NODE_H__
+#define __ARM_COMPUTE_GRAPH2_DEPTHWISE_CONVOLUTION_LAYER_NODE_H__
+
+#include "arm_compute/graph2/INode.h"
+
+namespace arm_compute
+{
+namespace graph2
+{
+class DepthwiseConvolutionLayerNode final : public INode
+{
+public:
+    /** Constructor
+     *
+     * @param[in] info   Convolution layer attributes
+     * @param[in] method Depthwise convolution method to use
+     */
+    DepthwiseConvolutionLayerNode(PadStrideInfo info, DepthwiseConvolutionMethod method = DepthwiseConvolutionMethod::DEFAULT);
+    /** Sets the depthwise convolution method to use
+     *
+     * @param[in] method Depthwise convolution method to use
+     */
+    void set_depthwise_convolution_method(DepthwiseConvolutionMethod method);
+    /** Depthwise convolution layer method accessor
+     *
+     * @note This is an indication on which depthwise implementation to use,
+     *       if it fails to be created the generic approach will be used
+     *
+     * @return Depthwise convolution layer method do be used by the node
+     */
+    DepthwiseConvolutionMethod depthwise_convolution_method() const;
+    /** Convolution metadata accessor
+     *
+     * @return Convolution information
+     */
+    PadStrideInfo convolution_info() const;
+    /** Computes depthwise convolution output shape
+     *
+     * @param[in] input_shape   Input shape
+     * @param[in] weights_shape Weights shape
+     * @param[in] info          Convolution operation attributes
+     *
+     * @return Output shape
+     */
+    static TensorShape compute_output_shape(TensorShape input_shape, TensorShape weights_shape, PadStrideInfo info);
+
+    // Inherited overridden methods:
+    Status           validate() override;
+    NodeType         type() const override;
+    bool             forward_descriptors() override;
+    TensorDescriptor configure_output(size_t idx) const override;
+    void accept(INodeVisitor &v) override;
+
+private:
+    PadStrideInfo              _info;
+    DepthwiseConvolutionMethod _method;
+};
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_DEPTHWISE_CONVOLUTION_LAYER_NODE_H__ */
diff --git a/arm_compute/graph2/nodes/EltwiseLayerNode.h b/arm_compute/graph2/nodes/EltwiseLayerNode.h
new file mode 100644
index 0000000000..2b217decff
--- /dev/null
+++ b/arm_compute/graph2/nodes/EltwiseLayerNode.h
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_ELTWISE_LAYER_NODE_H__
+#define __ARM_COMPUTE_GRAPH2_ELTWISE_LAYER_NODE_H__
+
+#include "arm_compute/graph2/INode.h"
+
+namespace arm_compute
+{
+namespace graph2
+{
+class EltwiseLayerNode final : public INode
+{
+public:
+    /** Constructor
+     *
+     * @param[in] op Element-wise operation to perform
+     */
+    EltwiseLayerNode(EltwiseOperation op);
+    /** Eltwise operation accessor
+     *
+     * @return Eltwise operation that is to be performed by the node
+     */
+    EltwiseOperation eltwise_operation() const;
+
+    // Inherited overridden methods:
+    Status           validate() override;
+    NodeType         type() const override;
+    bool             forward_descriptors() override;
+    TensorDescriptor configure_output(size_t idx) const override;
+    void accept(INodeVisitor &v) override;
+
+private:
+    EltwiseOperation _op;
+};
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_ELTWISE_LAYER_NODE_H__ */
diff --git a/arm_compute/graph2/nodes/FlattenLayerNode.h b/arm_compute/graph2/nodes/FlattenLayerNode.h
new file mode 100644
index 0000000000..de601f5f4e
--- /dev/null
+++ b/arm_compute/graph2/nodes/FlattenLayerNode.h
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_FLATTEN_LAYER_NODE_H__
+#define __ARM_COMPUTE_GRAPH2_FLATTEN_LAYER_NODE_H__
+
+#include "arm_compute/graph2/INode.h"
+
+namespace arm_compute
+{
+namespace graph2
+{
+class FlattenLayerNode final : public INode
+{
+public:
+    /** Default Constructor */
+    FlattenLayerNode();
+
+    // Inherited overridden methods:
+    Status           validate() override;
+    NodeType         type() const override;
+    bool             forward_descriptors() override;
+    TensorDescriptor configure_output(size_t idx) const override;
+    void accept(INodeVisitor &v) override;
+};
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_FLATTEN_LAYER_NODE_H__ */
diff --git a/arm_compute/graph2/nodes/FullyConnectedLayerNode.h b/arm_compute/graph2/nodes/FullyConnectedLayerNode.h
new file mode 100644
index 0000000000..836f20fdb3
--- /dev/null
+++ b/arm_compute/graph2/nodes/FullyConnectedLayerNode.h
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_FULLY_CONNECTED_LAYER_NODE_H__
+#define __ARM_COMPUTE_GRAPH2_FULLY_CONNECTED_LAYER_NODE_H__
+
+#include "arm_compute/graph2/INode.h"
+
+namespace arm_compute
+{
+namespace graph2
+{
+class FullyConnectedLayerNode final : public INode
+{
+public:
+    /** Constructor
+     *
+     * @param[in] num_outputs Number of neurons in the layer
+     */
+    FullyConnectedLayerNode(unsigned int num_outputs);
+    /** Computes weights shape
+     *
+     * @warning Works for inputs with 1D batch space
+     *
+     * @param[in] input_shape Input shape
+     * @param[in] num_outputs Number of output neurons
+     *
+     * @return Weights shape
+     */
+    static TensorShape compute_weights_shape(TensorShape input_shape, unsigned int num_outputs);
+    /** Computes fully connected layer output shape
+     *
+     * @warning Works for inputs with 1D batch space
+     *
+     * @param[in] input_shape Input shape
+     * @param[in] num_outputs Number of output neurons
+     *
+     * @return Output shape
+     */
+    static TensorShape compute_output_shape(TensorShape input_shape, unsigned int num_outputs);
+
+    // Inherited overridden methods:
+    Status           validate() override;
+    NodeType         type() const override;
+    bool             forward_descriptors() override;
+    TensorDescriptor configure_output(size_t idx) const override;
+    void accept(INodeVisitor &v) override;
+
+private:
+    unsigned int _num_outputs;
+};
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_FULLY_CONNECTED_LAYER_NODE_H__ */
diff --git a/arm_compute/graph2/nodes/InputNode.h b/arm_compute/graph2/nodes/InputNode.h
new file mode 100644
index 0000000000..2cad6f8fc6
--- /dev/null
+++ b/arm_compute/graph2/nodes/InputNode.h
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_INPUT_NODE_H__
+#define __ARM_COMPUTE_GRAPH2_INPUT_NODE_H__
+
+#include "arm_compute/graph2/INode.h"
+
+namespace arm_compute
+{
+namespace graph2
+{
+class InputNode final : public INode
+{
+public:
+    /** Constructor
+     *
+     * @param[in] desc Tensor descriptor
+     */
+    InputNode(TensorDescriptor desc);
+
+    // Inherited overridden methods:
+    Status           validate() override;
+    NodeType         type() const override;
+    bool             forward_descriptors() override;
+    TensorDescriptor configure_output(size_t idx) const override;
+    void accept(INodeVisitor &v) override;
+
+private:
+    TensorDescriptor _desc;
+};
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_INPUT_NODE_H__ */
diff --git a/arm_compute/graph2/nodes/Nodes.h b/arm_compute/graph2/nodes/Nodes.h
new file mode 100644
index 0000000000..8201361304
--- /dev/null
+++ b/arm_compute/graph2/nodes/Nodes.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_NODES_H__
+#define __ARM_COMPUTE_GRAPH2_NODES_H__
+
+#include "arm_compute/graph2/nodes/ActivationLayerNode.h"
+#include "arm_compute/graph2/nodes/BatchNormalizationLayerNode.h"
+#include "arm_compute/graph2/nodes/ConstNode.h"
+#include "arm_compute/graph2/nodes/ConvolutionLayerNode.h"
+#include "arm_compute/graph2/nodes/DepthConcatenateLayerNode.h"
+#include "arm_compute/graph2/nodes/DepthwiseConvolutionLayerNode.h"
+#include "arm_compute/graph2/nodes/EltwiseLayerNode.h"
+#include "arm_compute/graph2/nodes/FlattenLayerNode.h"
+#include "arm_compute/graph2/nodes/FullyConnectedLayerNode.h"
+#include "arm_compute/graph2/nodes/InputNode.h"
+#include "arm_compute/graph2/nodes/NormalizationLayerNode.h"
+#include "arm_compute/graph2/nodes/OutputNode.h"
+#include "arm_compute/graph2/nodes/PoolingLayerNode.h"
+#include "arm_compute/graph2/nodes/ReshapeLayerNode.h"
+#include "arm_compute/graph2/nodes/SoftmaxLayerNode.h"
+
+#endif /* __ARM_COMPUTE_GRAPH2_NODES_H__ */
diff --git a/arm_compute/graph2/nodes/NodesFwd.h b/arm_compute/graph2/nodes/NodesFwd.h
new file mode 100644
index 0000000000..03ca65e056
--- /dev/null
+++ b/arm_compute/graph2/nodes/NodesFwd.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_NODES_FWD_H__
+#define __ARM_COMPUTE_GRAPH2_NODES_FWD_H__
+
+namespace arm_compute
+{
+namespace graph2
+{
+// Forward declarations
+class INode;
+class ActivationLayerNode;
+class BatchNormalizationLayerNode;
+class ConstNode;
+class ConvolutionLayerNode;
+class DepthConcatenateLayerNode;
+class DepthwiseConvolutionLayerNode;
+class EltwiseLayerNode;
+class FlattenLayerNode;
+class FullyConnectedLayerNode;
+class InputNode;
+class NormalizationLayerNode;
+class OutputNode;
+class PoolingLayerNode;
+class ReshapeLayerNode;
+class SoftmaxLayerNode;
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_NODES_FWD_H__ */
diff --git a/arm_compute/graph2/nodes/NormalizationLayerNode.h b/arm_compute/graph2/nodes/NormalizationLayerNode.h
new file mode 100644
index 0000000000..e2816e9352
--- /dev/null
+++ b/arm_compute/graph2/nodes/NormalizationLayerNode.h
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_NORMALIZATION_LAYER_NODE_H__
+#define __ARM_COMPUTE_GRAPH2_NORMALIZATION_LAYER_NODE_H__
+
+#include "arm_compute/graph2/INode.h"
+
+namespace arm_compute
+{
+namespace graph2
+{
+class NormalizationLayerNode final : public INode
+{
+public:
+    /** Constructor
+     *
+     * @param[in] norm_info Normalization Layer information
+     */
+    NormalizationLayerNode(NormalizationLayerInfo norm_info);
+    /** Normalization info accessor
+     *
+     * @return Normalization layer info
+     */
+    NormalizationLayerInfo normalization_info() const;
+
+    // Inherited overridden methods:
+    Status           validate() override;
+    NodeType         type() const override;
+    bool             forward_descriptors() override;
+    TensorDescriptor configure_output(size_t idx) const override;
+    void accept(INodeVisitor &v) override;
+
+private:
+    NormalizationLayerInfo _info;
+};
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_NORMALIZATION_LAYER_NODE_H__ */
diff --git a/arm_compute/graph2/nodes/OutputNode.h b/arm_compute/graph2/nodes/OutputNode.h
new file mode 100644
index 0000000000..94df382d22
--- /dev/null
+++ b/arm_compute/graph2/nodes/OutputNode.h
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_OUTPUT_NODE_H__
+#define __ARM_COMPUTE_GRAPH2_OUTPUT_NODE_H__
+
+#include "arm_compute/graph2/INode.h"
+
+namespace arm_compute
+{
+namespace graph2
+{
+class OutputNode final : public INode
+{
+public:
+    /** Default Constructor */
+    OutputNode();
+
+    // Inherited overridden methods:
+    Status           validate() override;
+    NodeType         type() const override;
+    bool             forward_descriptors() override;
+    TensorDescriptor configure_output(size_t idx) const override;
+    void accept(INodeVisitor &v) override;
+};
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_OUTPUT_NODE_H__ */
diff --git a/arm_compute/graph2/nodes/PoolingLayerNode.h b/arm_compute/graph2/nodes/PoolingLayerNode.h
new file mode 100644
index 0000000000..b0c6270999
--- /dev/null
+++ b/arm_compute/graph2/nodes/PoolingLayerNode.h
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_POOLING_LAYER_NODE_H__
+#define __ARM_COMPUTE_GRAPH2_POOLING_LAYER_NODE_H__
+
+#include "arm_compute/graph2/INode.h"
+
+namespace arm_compute
+{
+namespace graph2
+{
+class PoolingLayerNode final : public INode
+{
+public:
+    /** Constructor
+     *
+     * @param[in] pool_info Pooling Layer information
+     */
+    PoolingLayerNode(PoolingLayerInfo pool_info);
+    /** Pooling metadata accessor
+     *
+     * @return Pooling Layer info
+     */
+    PoolingLayerInfo pooling_info() const;
+    /** Computes pooling output shape
+     *
+     * @param[in] input_shape Input shape
+     * @param[in] info        Pooling operation attributes
+     *
+     * @return Output shape
+     */
+    static TensorShape compute_output_shape(TensorShape input_shape, PoolingLayerInfo info);
+
+    // Inherited overridden methods:
+    Status           validate() override;
+    NodeType         type() const override;
+    bool             forward_descriptors() override;
+    TensorDescriptor configure_output(size_t idx) const override;
+    void accept(INodeVisitor &v) override;
+
+private:
+    PoolingLayerInfo _info;
+};
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_POOLING_LAYER_NODE_H__ */
diff --git a/arm_compute/graph2/nodes/ReshapeLayerNode.h b/arm_compute/graph2/nodes/ReshapeLayerNode.h
new file mode 100644
index 0000000000..89ee46c8e1
--- /dev/null
+++ b/arm_compute/graph2/nodes/ReshapeLayerNode.h
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_RESHAPE_LAYER_NODE_H__
+#define __ARM_COMPUTE_GRAPH2_RESHAPE_LAYER_NODE_H__
+
+#include "arm_compute/graph2/INode.h"
+
+namespace arm_compute
+{
+namespace graph2
+{
+class ReshapeLayerNode final : public INode
+{
+public:
+    /** Constructor
+     *
+     * @param[in] shape Reshaped tensor shape
+     */
+    ReshapeLayerNode(TensorShape shape);
+
+    // Inherited overridden methods:
+    Status           validate() override;
+    NodeType         type() const override;
+    bool             forward_descriptors() override;
+    TensorDescriptor configure_output(size_t idx) const override;
+    void accept(INodeVisitor &v) override;
+
+private:
+    TensorShape _shape;
+};
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_RESHAPE_LAYER_NODE_H__ */
diff --git a/arm_compute/graph2/nodes/SoftmaxLayerNode.h b/arm_compute/graph2/nodes/SoftmaxLayerNode.h
new file mode 100644
index 0000000000..86decb80d9
--- /dev/null
+++ b/arm_compute/graph2/nodes/SoftmaxLayerNode.h
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_SOFTMAX_LAYER_NODE_H__
+#define __ARM_COMPUTE_GRAPH2_SOFTMAX_LAYER_NODE_H__
+
+#include "arm_compute/graph2/INode.h"
+
+namespace arm_compute
+{
+namespace graph2
+{
+class SoftmaxLayerNode final : public INode
+{
+public:
+    /** Constructor
+     *
+     * @param[in] beta (Optional) Beta parameter. Defaults to 1
+     */
+    SoftmaxLayerNode(float beta = 1.f);
+    /** Beta parameter accessor
+     *
+     * @return Beta parameter
+     */
+    float beta() const;
+
+    // Inherited overridden methods:
+    Status           validate() override;
+    NodeType         type() const override;
+    bool             forward_descriptors() override;
+    TensorDescriptor configure_output(size_t idx) const override;
+    void accept(INodeVisitor &v) override;
+
+private:
+    float _beta;
+};
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_SOFTMAX_LAYER_NODE_H__ */
diff --git a/arm_compute/graph2/printers/DotGraphPrinter.h b/arm_compute/graph2/printers/DotGraphPrinter.h
new file mode 100644
index 0000000000..3b1879c505
--- /dev/null
+++ b/arm_compute/graph2/printers/DotGraphPrinter.h
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_DOTGRAPHPRINTER_H__
+#define __ARM_COMPUTE_GRAPH2_DOTGRAPHPRINTER_H__
+
+#include "arm_compute/graph2/IGraphPrinter.h"
+
+#include "arm_compute/graph2/INodeVisitor.h"
+
+#include <string>
+
+namespace arm_compute
+{
+namespace graph2
+{
+class DotGraphVisitor final : public DefaultNodeVisitor
+{
+public:
+    /** Default Constructor **/
+    DotGraphVisitor() = default;
+    /** Returns the output information of the last visited node
+     *
+     * @return Information of the last visited node
+     */
+    const std::string &info() const;
+
+    // Reveal parent method
+    using DefaultNodeVisitor::visit;
+
+    // Inherited methods overridden
+    void visit(ActivationLayerNode &n) override;
+    void visit(BatchNormalizationLayerNode &n) override;
+    void visit(ConvolutionLayerNode &n) override;
+    void visit(DepthConcatenateLayerNode &n) override;
+    void visit(DepthwiseConvolutionLayerNode &n) override;
+    void visit(EltwiseLayerNode &n) override;
+    void visit(NormalizationLayerNode &n) override;
+    void visit(PoolingLayerNode &n) override;
+    void default_visit() override;
+
+private:
+    std::string _info{};
+};
+
+/** Graph printer interface */
+class DotGraphPrinter final : public IGraphPrinter
+{
+public:
+    // Inherited methods overridden
+    void print(const Graph &g, std::ostream &os) override;
+
+private:
+    /** Print dot graph header
+     *
+     * @param[in]  g  Graph
+     * @param[out] os Output stream to use
+     */
+    void print_header(const Graph &g, std::ostream &os);
+    /** Print dot graph footer
+     *
+     * @param[in]  g  Graph
+     * @param[out] os Output stream to use
+     */
+    void print_footer(const Graph &g, std::ostream &os);
+    /** Prints nodes in dot format
+     *
+     * @param[in]  g  Graph
+     * @param[out] os Output stream to use
+     */
+    void print_nodes(const Graph &g, std::ostream &os);
+    /** Prints edges in dot format
+     *
+     * @param[in]  g  Graph
+     * @param[out] os Output stream to use
+     */
+    void print_edges(const Graph &g, std::ostream &os);
+
+private:
+    DotGraphVisitor _dot_node_visitor = {};
+};
+} // namespace graph2
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_GRAPH2_DOTGRAPHPRINTER_H__ */
diff --git a/arm_compute/graph2/printers/Printers.h b/arm_compute/graph2/printers/Printers.h
new file mode 100644
index 0000000000..0b70139683
--- /dev/null
+++ b/arm_compute/graph2/printers/Printers.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_GRAPH2_PRINTERS_H__
+#define __ARM_COMPUTE_GRAPH2_PRINTERS_H__
+
+#include "arm_compute/graph2/printers/DotGraphPrinter.h"
+
+#endif /* __ARM_COMPUTE_GRAPH2_PRINTERS_H__ */
diff --git a/arm_compute/runtime/CL/CLSubTensor.h b/arm_compute/runtime/CL/CLSubTensor.h
index b6e9a29df4..9c37f8be7c 100644
--- a/arm_compute/runtime/CL/CLSubTensor.h
+++ b/arm_compute/runtime/CL/CLSubTensor.h
@@ -37,6 +37,8 @@ class ITensorInfo;
 class CLSubTensor : public ICLTensor
 {
 public:
+    /** Default Constructor */
+    CLSubTensor();
     /** Constructor
      *
      * @param[in] parent        Parent tensor
diff --git a/arm_compute/runtime/CL/functions/CLGEMMConvolutionLayer.h b/arm_compute/runtime/CL/functions/CLGEMMConvolutionLayer.h
index 5f8830a361..ca805d90f1 100644
--- a/arm_compute/runtime/CL/functions/CLGEMMConvolutionLayer.h
+++ b/arm_compute/runtime/CL/functions/CLGEMMConvolutionLayer.h
@@ -49,13 +49,12 @@ class ICLTensor;
 
 /** Function to reshape and transpose the weights. This function calls the following kernels:
  * -# @ref CLWeightsReshapeKernel
- * -# @ref CLGEMMTranspose1xWKernel
  */
 class CLConvolutionLayerReshapeWeights : public IFunction
 {
 public:
     /** Constructor */
-    CLConvolutionLayerReshapeWeights(std::shared_ptr<IMemoryManager> memory_manager = nullptr);
+    CLConvolutionLayerReshapeWeights();
     /** Set the input and output tensors.
      *
      * @param[in]  weights Weights tensor. Weights are 4D tensor with dimensions [kernel_x, kernel_y, IFM, OFM].
@@ -78,10 +77,7 @@ public:
     void run() override;
 
 private:
-    CLMemoryGroup            _memory_group;
-    CLWeightsReshapeKernel   _weights_reshape_kernel;
-    CLGEMMTranspose1xWKernel _weights_transposed_kernel;
-    CLTensor                 _weights_reshaped;
+    CLWeightsReshapeKernel _weights_reshape_kernel;
 };
 
 /** Basic function to compute the convolution layer. This function calls the following OpenCL kernels/functions:
@@ -169,9 +165,7 @@ private:
     CLCol2ImKernel                                      _col2im_kernel;
 
     CLTensor _im2col_output;
-    CLTensor _interleave_output;
     CLTensor _weights_reshaped;
-    CLTensor _weights_transposed;
     CLTensor _gemm_output;
     CLTensor _tmp_output;
 
diff --git a/arm_compute/runtime/SubTensor.h b/arm_compute/runtime/SubTensor.h
index ba2f8682af..603783fa1e 100644
--- a/arm_compute/runtime/SubTensor.h
+++ b/arm_compute/runtime/SubTensor.h
@@ -37,6 +37,8 @@ class ITensorInfo;
 class SubTensor : public ITensor
 {
 public:
+    /** Default Constructor */
+    SubTensor();
     /** Constructor
      *
      * @param[in] parent        Parent tensor