diff --git a/src/backends/reference/workloads/CMakeLists.txt b/src/backends/reference/workloads/CMakeLists.txt
index 28f6d2f..9372568 100644
--- a/src/backends/reference/workloads/CMakeLists.txt
+++ b/src/backends/reference/workloads/CMakeLists.txt
@@ -180,6 +180,8 @@
     RefStackWorkload.hpp
     RefStridedSliceWorkload.cpp
     RefStridedSliceWorkload.hpp
+    RefTileWorkload.cpp
+    RefTileWorkload.hpp
     RefTransposeConvolution2dWorkload.cpp
     RefTransposeConvolution2dWorkload.hpp
     RefTransposeWorkload.cpp
@@ -209,6 +211,8 @@
     StridedSlice.cpp
     StringMapping.cpp
     StringMapping.hpp
+    Tile.cpp
+    Tile.hpp
     TensorBufferArrayView.hpp
     TransposeConvolution2d.cpp
     TransposeConvolution2d.hpp
diff --git a/src/backends/reference/workloads/RefTileWorkload.cpp b/src/backends/reference/workloads/RefTileWorkload.cpp
new file mode 100644
index 0000000..9fa8c8c
--- /dev/null
+++ b/src/backends/reference/workloads/RefTileWorkload.cpp
@@ -0,0 +1,47 @@
+//
+// Copyright © 2023 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#include "RefTileWorkload.hpp"
+#include "RefWorkloadUtils.hpp"
+#include "Tile.hpp"
+#include "Profiling.hpp"
+
+namespace armnn
+{
+
+    RefTileWorkload::RefTileWorkload(const TileQueueDescriptor& descriptor, const WorkloadInfo& info)
+        : RefBaseWorkload(descriptor, info)
+    {}
+
+    void RefTileWorkload::Execute() const
+    {
+        Execute(m_Data.m_Inputs, m_Data.m_Outputs);
+    }
+
+    void RefTileWorkload::ExecuteAsync(ExecutionData& executionData)
+    {
+        WorkingMemDescriptor* workingMemDescriptor = static_cast<WorkingMemDescriptor*>(executionData.m_Data);
+        Execute(workingMemDescriptor->m_Inputs, workingMemDescriptor->m_Outputs);
+    }
+
+    void RefTileWorkload::Execute(std::vector<ITensorHandle*> inputs, std::vector<ITensorHandle*> outputs) const
+    {
+        ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefTileWorkload_Execute");
+
+        const TensorInfo& inputInfo = GetTensorInfo(inputs[0]);
+
+        std::unique_ptr<Decoder<float>> inputDecoder = MakeDecoder<float>(GetTensorInfo(inputs[0]),
+                                                                          inputs[0]->Map());
+
+        std::unique_ptr<Encoder<float>> outputEncoder = MakeEncoder<float>(GetTensorInfo(outputs[0]),
+                                                                           outputs[0]->Map());
+
+        Tile(m_Data.m_Parameters,
+             inputInfo,
+             *inputDecoder,
+             *outputEncoder);
+    }
+
+} // namespace armnn
\ No newline at end of file
diff --git a/src/backends/reference/workloads/RefTileWorkload.hpp b/src/backends/reference/workloads/RefTileWorkload.hpp
new file mode 100644
index 0000000..2fb8eab
--- /dev/null
+++ b/src/backends/reference/workloads/RefTileWorkload.hpp
@@ -0,0 +1,30 @@
+//
+// Copyright © 2023 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include "RefBaseWorkload.hpp"
+#include <armnn/backends/WorkloadData.hpp>
+
+#include "Tile.hpp"
+
+namespace armnn
+{
+
+    class RefTileWorkload : public RefBaseWorkload<TileQueueDescriptor>
+    {
+    public:
+        explicit RefTileWorkload(const TileQueueDescriptor& descriptor,
+                                 const WorkloadInfo& info);
+
+        void Execute() const override;
+        void ExecuteAsync(ExecutionData& executionData) override;
+
+    private:
+        void Execute(std::vector<ITensorHandle*> inputs, std::vector<ITensorHandle*> outputs) const;
+
+    };
+
+} // namespace armnn
\ No newline at end of file
diff --git a/src/backends/reference/workloads/RefWorkloads.hpp b/src/backends/reference/workloads/RefWorkloads.hpp
index e15a7ca..a36eae5 100644
--- a/src/backends/reference/workloads/RefWorkloads.hpp
+++ b/src/backends/reference/workloads/RefWorkloads.hpp
@@ -62,6 +62,7 @@
 #include "RefStackWorkload.hpp"
 #include "RefStridedSliceWorkload.hpp"
 #include "RefSpaceToDepthWorkload.hpp"
+#include "RefTileWorkload.hpp"
 #include "RefTransposeConvolution2dWorkload.hpp"
 #include "RefTransposeWorkload.hpp"
 #include "RefUnidirectionalSequenceLstmWorkload.hpp"
diff --git a/src/backends/reference/workloads/Tile.cpp b/src/backends/reference/workloads/Tile.cpp
new file mode 100644
index 0000000..148c51d
--- /dev/null
+++ b/src/backends/reference/workloads/Tile.cpp
@@ -0,0 +1,102 @@
+//
+// Copyright © 2023 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#include "Tile.hpp"
+#include "Encoders.hpp"
+#include <numeric>
+#include <armnn/backends/WorkloadData.hpp>
+#include <armnn/Logging.hpp>
+
+namespace armnn
+{
+
+// Converts a flatten index into a multi-dimensional coordinate.
+std::vector<uint32_t> IndexToCoordinates(std::vector<uint32_t>& shape, uint32_t index)
+{
+    std::vector<uint32_t> coordinates;
+    // Iterating through dimensions starting from the last dimension to the first
+    for (std::size_t i = shape.size() - 1; i < shape.size(); --i)
+    {
+        // Coordinate is found by getting the index and modulus it by the current dimension size
+        // shape of dimension = dimension size
+        coordinates.insert(coordinates.begin(), index % shape[i]);
+        // Pass the index to next iteration making index = index / size of the current dimension
+        index = index/shape[i];
+    }
+    return coordinates;
+}
+
+// Convert a multidimensional coordinate to a flattened index.
+uint32_t CoordinatesToIndex(TensorShape& shape, std::vector<uint32_t>& coordinates)
+{
+    uint32_t index = 0;
+    uint32_t base = 1;
+    uint32_t rank = shape.GetNumDimensions();
+    for (uint32_t i = rank; i > 0; --i)
+    {
+        index = index + coordinates[i - 1] * base;
+        base = base * shape[i - 1];
+    }
+    return index;
+}
+
+void Tile(const TileDescriptor& params,
+          const TensorInfo& inputInfo,
+          Decoder<float>& inputDecoder,
+          Encoder<float>& outputEncoder)
+{
+    // Input and output will always have same rank
+    uint32_t rank = inputInfo.GetNumDimensions();
+
+    TensorShape inputShape = inputInfo.GetShape();
+
+    std::vector<uint32_t> outputShape(rank);
+    for (uint32_t i = 0; i < rank; ++i)
+    {
+        outputShape[i] = inputShape[i] * params.m_Multiples[i];
+    }
+
+    // If all values of multiples are 1, then return the input
+    if ( std::adjacent_find( params.m_Multiples.begin(), params.m_Multiples.end(),
+                             std::not_equal_to<>() ) == params.m_Multiples.end() && params.m_Multiples[0] == 1)
+    {
+        for (uint32_t idx = 0; idx < inputInfo.GetNumElements(); ++idx)
+        {
+            float inputValue = inputDecoder.Get();
+            ++inputDecoder;
+            outputEncoder.Set(inputValue);
+            ++outputEncoder;
+        }
+        return;
+    }
+
+    std::vector<float> inputData = inputDecoder.DecodeTensor(inputInfo.GetShape());
+    std::vector<float> outputData;
+    auto outputNumElements = inputData.size() * static_cast<uint32_t>(std::accumulate(begin(params.m_Multiples),
+                                                                                      end(params.m_Multiples),
+                                                                                      1,
+                                                                                      std::multiplies<>()));
+    outputData.reserve(outputNumElements);
+
+    for (uint32_t outputIndex = 0; outputIndex < outputNumElements; ++outputIndex)
+    {
+        std::vector<uint32_t> outputCoords = IndexToCoordinates(outputShape, outputIndex);
+
+        // Converting output coordinates to input coordinates using modulus
+        std::vector<uint32_t> inputCoordinates;
+        inputCoordinates.reserve(rank);
+        for (uint32_t i = 0; i < rank; ++i)
+        {
+            inputCoordinates.push_back(outputCoords[i] % inputShape[i]);
+        }
+
+        uint32_t inputIndex = CoordinatesToIndex(inputShape, inputCoordinates);
+
+        outputEncoder[outputIndex];
+        outputEncoder.Set(inputData[inputIndex]);
+    }
+}
+
+} // namespace armnn
\ No newline at end of file
diff --git a/src/backends/reference/workloads/Tile.hpp b/src/backends/reference/workloads/Tile.hpp
new file mode 100644
index 0000000..4e7ffc9
--- /dev/null
+++ b/src/backends/reference/workloads/Tile.hpp
@@ -0,0 +1,21 @@
+//
+// Copyright © 2023 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include <armnn/Tensor.hpp>
+#include "Encoders.hpp"
+#include "Decoders.hpp"
+#include "armnn/Descriptors.hpp"
+
+namespace armnn
+{
+
+void Tile(const TileDescriptor& params,
+          const TensorInfo& inputInfo,
+          Decoder<float>& inputDecoder,
+          Encoder<float>& outputEncoder);
+
+} // namespace armnn
\ No newline at end of file