diff --git a/configure.ac b/configure.ac
index 8655c153..0d1b1498 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1,4 +1,4 @@
-# Copyright (C) 2018 RidgeRun, LLC (http://www.ridgerun.com)
+# Copyright (C) 2018-2020 RidgeRun, LLC (http://www.ridgerun.com)
 # All Rights Reserved.
 #
 # The contents of this software are proprietary and confidential to RidgeRun,
@@ -10,7 +10,7 @@
 
 # Initialize autoconf.
 AC_PREREQ([2.69])
-AC_INIT([RidgeRun inference library],[0.7.0],[https://github.com/RidgeRun/r2inference/issues],[r2inference])
+AC_INIT([RidgeRun inference library],[0.8.0],[https://github.com/RidgeRun/r2inference/issues],[r2inference])
 
 # Initialize our build utils
 RR_INIT
@@ -63,6 +63,9 @@ AM_COND_IF([HAVE_EDGETPU], [AM_COND_IF([HAVE_TFLITE], [], [AC_MSG_ERROR(The Edge
 
 RR_CHECK_FEATURE_LIB(TENSORRT, TensorRT Installation,
                      nvinfer, createInferBuilder_INTERNAL, NvInfer.h, no)
+
+RR_CHECK_FEATURE_LIB(ONNXRT, ONNX Runtime Installation,
+                     onnxruntime, OrtGetApiBase, onnxruntime/core/session/onnxruntime_cxx_api.h, no)
 AC_LANG_POP([C++])
 
 AM_CONDITIONAL([PLATFORM_IS_GPU], [false])
@@ -81,12 +84,14 @@ examples/Makefile
 examples/r2i/Makefile
 examples/r2i/edgetpu/Makefile
 examples/r2i/ncsdk/Makefile
+examples/r2i/onnxrt/Makefile
 examples/r2i/tensorflow/Makefile
 examples/r2i/tensorrt/Makefile
 examples/r2i/tflite/Makefile
 r2i/Makefile
 r2i/edgetpu/Makefile
 r2i/ncsdk/Makefile
+r2i/onnxrt/Makefile
 r2i/tensorflow/Makefile
 r2i/tensorrt/Makefile
 r2i/tflite/Makefile
@@ -96,6 +101,7 @@ tests/acceptance/Makefile
 tests/unit/Makefile
 tests/unit/r2i/Makefile
 tests/unit/r2i/ncsdk/Makefile
+tests/unit/r2i/onnxrt/Makefile
 tests/unit/r2i/tensorflow/Makefile
 tests/unit/r2i/tensorrt/Makefile
 tests/unit/r2i/tflite/Makefile
diff --git a/examples/external/list_backends.cc b/examples/external/list_backends.cc
index c45ea693..0babcc78 100644
--- a/examples/external/list_backends.cc
+++ b/examples/external/list_backends.cc
@@ -16,6 +16,7 @@ void PrintFramework (r2i::FrameworkMeta &meta) {
   std::cout << "Name        : " << meta.name << std::endl;
   std::cout << "Description : " << meta.description << std::endl;
   std::cout << "Version     : " << meta.version << std::endl;
+  std::cout << "Label       : " << meta.label << std::endl;
   std::cout << "---" << std::endl;
 }
 
diff --git a/examples/r2i/Makefile.am b/examples/r2i/Makefile.am
index 6d645ae9..bc4de473 100644
--- a/examples/r2i/Makefile.am
+++ b/examples/r2i/Makefile.am
@@ -27,6 +27,10 @@ if HAVE_NCSDK
 SUBDIRS += ncsdk
 endif
 
+if HAVE_ONNXRT
+SUBDIRS += onnxrt
+endif
+
 if HAVE_TENSORFLOW
 SUBDIRS += tensorflow
 endif
diff --git a/examples/r2i/meson.build b/examples/r2i/meson.build
index ef662b4b..1101b285 100644
--- a/examples/r2i/meson.build
+++ b/examples/r2i/meson.build
@@ -17,6 +17,10 @@ if get_option('enable-edgetpu')
   subdir('edgetpu')
 endif
 
+if get_option('enable-onnxrt')
+  subdir('onnxrt')
+endif
+
 if get_option('enable-tensorflow')
   subdir('tensorflow')
 endif
diff --git a/examples/r2i/onnxrt/Makefile.am b/examples/r2i/onnxrt/Makefile.am
new file mode 100644
index 00000000..b1a18661
--- /dev/null
+++ b/examples/r2i/onnxrt/Makefile.am
@@ -0,0 +1,36 @@
+# Copyright (C) 2020 RidgeRun, LLC (http://www.ridgerun.com)
+# All Rights Reserved.
+#
+# The contents of this software are proprietary and confidential to RidgeRun,
+# LLC.  No part of this program may be photocopied, reproduced or translated
+# into another programming language without prior written consent of
+# RidgeRun, LLC.  The user is free to modify the source code after obtaining
+# a software license from RidgeRun.  All source code changes must be provided
+# back to RidgeRun without any encumbrance.
+
+AM_DEFAULT_SOURCE_EXT = .cc
+
+if ENABLE_EXAMPLES
+
+noinst_PROGRAMS =                  \
+        inception
+
+AM_CXXFLAGS =                      \
+        $(RR_CXXFLAGS)             \
+        $(CODE_COVERAGE_CXXFLAGS)  \
+        -I../common/
+
+AM_CFLAGS =                        \
+        $(RR_CFLAGS)               \
+        $(CODE_COVERAGE_CFLAGS)
+
+AM_CPPFLAGS =                      \
+        $(RR_CPPFLAGS)             \
+        $(CODE_COVERAGE_CPPFLAGS)
+
+AM_LDFLAGS =                       \
+        $(RR_LIBS)                 \
+        $(CODE_COVERAGE_LIBS)      \
+        $(top_builddir)/r2i/libr2inference-@RR_PACKAGE_VERSION@.la
+
+endif # ENABLE_EXAMPLES
diff --git a/examples/r2i/onnxrt/inception.cc b/examples/r2i/onnxrt/inception.cc
new file mode 100644
index 00000000..5eeda9fc
--- /dev/null
+++ b/examples/r2i/onnxrt/inception.cc
@@ -0,0 +1,215 @@
+/* Copyright (C) 2018-2020 RidgeRun, LLC (http://www.ridgerun.com)
+ * All Rights Reserved.
+ *
+ * The contents of this software are proprietary and confidential to RidgeRun,
+ * LLC.  No part of this program may be photocopied, reproduced or translated
+ * into another programming language without prior written consent of
+ * RidgeRun, LLC.  The user is free to modify the source code after obtaining
+ * a software license from RidgeRun.  All source code changes must be provided
+ * back to RidgeRun without any encumbrance.
+*/
+
+#include <r2i/r2i.h>
+
+#include <getopt.h>
+#include <iostream>
+#include <memory>
+#include <string>
+
+#define STB_IMAGE_IMPLEMENTATION
+#include "stb_image.h"
+
+#define STB_IMAGE_RESIZE_IMPLEMENTATION
+#include "stb_image_resize.h"
+
+void PrintTopPrediction (std::shared_ptr<r2i::IPrediction> prediction) {
+  r2i::RuntimeError error;
+  int index = 0;
+  double max = -1;
+  int num_labels = prediction->GetResultSize();
+
+  for (int i = 0; i < num_labels; ++i) {
+    double current = prediction->At(i, error);
+    if (current > max) {
+      max = current;
+      index = i;
+    }
+  }
+
+  std::cout << "Highest probability is label "
+            << index << " (" << max << ")" << std::endl;
+}
+
+void PrintUsage() {
+  std::cerr << "Required arguments: "
+            << "-i [JPG input_image] "
+            << "-m [Inception ONNX Model] "
+            << "-s [Model Input Size] "
+            << "-I [Input Node] "
+            << "-O [Output Node] \n"
+            << " Example: "
+            << " ./inception -i cat.jpg -m graph_inceptionv2_tensorflow.pb "
+            << "-s 224"
+            << std::endl;
+}
+
+std::unique_ptr<float[]> PreProcessImage (const unsigned char *input,
+    int width, int height, int reqwidth, int reqheight) {
+
+  const int channels = 3;
+  const int scaled_size = channels * reqwidth * reqheight;
+  std::unique_ptr<unsigned char[]> scaled (new unsigned char[scaled_size]);
+  std::unique_ptr<float[]> adjusted (new float[scaled_size]);
+
+  stbir_resize_uint8(input, width, height, 0, scaled.get(), reqwidth,
+                     reqheight, 0, channels);
+
+  for (int i = 0; i < scaled_size; i += channels) {
+    /* RGB = (RGB - Mean)*StdDev */
+    adjusted[i + 0] = (static_cast<float>(scaled[i + 0]) - 128) / 128.0;
+    adjusted[i + 1] = (static_cast<float>(scaled[i + 1]) - 128) / 128.0;
+    adjusted[i + 2] = (static_cast<float>(scaled[i + 2]) - 128) / 128.0;
+  }
+
+  return adjusted;
+}
+
+std::unique_ptr<float[]> LoadImage(const std::string &path, int reqwidth,
+                                   int reqheight) {
+  int channels = 3;
+  int width, height, cp;
+
+  unsigned char *img = stbi_load(path.c_str(), &width, &height, &cp, channels);
+  if (!img) {
+    std::cerr << "The picture " << path << " could not be loaded";
+    return nullptr;
+  }
+
+  auto ret = PreProcessImage(img, width, height, reqwidth, reqheight);
+  free (img);
+
+  return ret;
+}
+
+bool ParseArgs (int &argc, char *argv[], std::string &image_path,
+                std::string &model_path, int &index, int &size,
+                std::string &in_node, std::string &out_node) {
+  int option = 0;
+  while ((option = getopt(argc, argv, "i:m:p:s:I:O:")) != -1) {
+    switch (option) {
+      case 'i' :
+        image_path = optarg;
+        break;
+      case 'm' :
+        model_path  = optarg;
+        break;
+      case 'p' :
+        index  = std::stoi (optarg);
+        break;
+      case 's' :
+        size = std::stoi (optarg);
+        break;
+      case 'I' :
+        in_node = optarg;
+        break;
+      case 'O' :
+        out_node = optarg;
+        break;
+      default:
+        return false;
+    }
+  }
+  return true;
+}
+
+int main (int argc, char *argv[]) {
+  r2i::RuntimeError error;
+  std::string model_path;
+  std::string image_path;
+  std::string in_node;
+  std::string out_node;
+  int Index = 0;
+  int size = 0;
+
+  if (false == ParseArgs (argc, argv, image_path, model_path, Index,
+                          size, in_node, out_node)) {
+    PrintUsage ();
+    exit (EXIT_FAILURE);
+  }
+
+  if (image_path.empty() || model_path.empty ()) {
+    PrintUsage ();
+    exit (EXIT_FAILURE);
+  }
+
+  auto factory = r2i::IFrameworkFactory::MakeFactory(
+                   r2i::FrameworkCode::ONNXRT,
+                   error);
+
+  if (nullptr == factory) {
+    std::cerr << "TensorFlow backend is not built: " << error << std::endl;
+    exit(EXIT_FAILURE);
+  }
+
+  std::cout << "Loading Model: " << model_path << std::endl;
+  auto loader = factory->MakeLoader (error);
+  std::shared_ptr<r2i::IModel> model = loader->Load (model_path, error);
+  if (error.IsError ()) {
+    std::cerr << "Loader error: " << error << std::endl;
+    exit(EXIT_FAILURE);
+  }
+
+  std::cout << "Setting model to engine" << std::endl;
+  std::shared_ptr<r2i::IEngine> engine = factory->MakeEngine (error);
+  error = engine->SetModel (model);
+
+  std::cout << "Configuring ONNXRT session parameters" << std::endl;
+  auto params = factory->MakeParameters (error);
+  error = params->Configure(engine, model);
+  /* Set OrtLoggingLevel::ORT_LOGGING_LEVEL_WARNING */
+  error = params->Set ("logging-level", 2);
+  error = params->Set ("log-id", "onnxrt_example");
+  error = params->Set ("intra-num-threads", 1);
+  /* Set GraphOptimizationLevel::ORT_ENABLE_EXTENDED */
+  error = params->Set ("graph-optimization-level", 2);
+
+  if (error.IsError ()) {
+    std::cerr << "Parameters error: " << error << std::endl;
+    exit(EXIT_FAILURE);
+  }
+
+  std::cout << "Loading image: " << image_path << std::endl;
+  std::unique_ptr<float[]> image_data = LoadImage (image_path, size,
+                                        size);
+
+  std::cout << "Configuring frame" << std::endl;
+  std::shared_ptr<r2i::IFrame> frame = factory->MakeFrame (error);
+
+  error = frame->Configure (image_data.get(), size, size,
+                            r2i::ImageFormat::Id::RGB);
+
+  std::cout << "Starting engine" << std::endl;
+  error = engine->Start ();
+  if (error.IsError ()) {
+    std::cerr << "Engine start error: " << error << std::endl;
+    exit(EXIT_FAILURE);
+  }
+
+  std::cout << "Predicting..." << std::endl;
+  auto prediction = engine->Predict (frame, error);
+  if (error.IsError ()) {
+    std::cerr << "Engine prediction error: " << error << std::endl;
+    exit(EXIT_FAILURE);
+  }
+
+  PrintTopPrediction (prediction);
+
+  std::cout << "Stopping engine" << std::endl;
+  error = engine->Stop ();
+  if (error.IsError ()) {
+    std::cerr << "Engine stop error: " << error << std::endl;
+    exit(EXIT_FAILURE);
+  }
+
+  return EXIT_SUCCESS;
+}
diff --git a/examples/r2i/onnxrt/meson.build b/examples/r2i/onnxrt/meson.build
new file mode 100644
index 00000000..b568b5f2
--- /dev/null
+++ b/examples/r2i/onnxrt/meson.build
@@ -0,0 +1,11 @@
+# Compile examples
+app_examples = [
+  'inception',
+]
+
+foreach app : app_examples
+  executable(app, '@0@.cc'.format(app),
+    include_directories: [configinc, common_inc_dir],
+    dependencies : [r2inference_lib_dep],
+    install: false)
+endforeach
diff --git a/meson.build b/meson.build
index 4ee72e87..69a4ca6d 100644
--- a/meson.build
+++ b/meson.build
@@ -1,5 +1,5 @@
 project('r2inference', ['cpp'], default_options : ['cpp_std=c++11'],
-  version : '0.7.0',
+  version : '0.8.0',
   meson_version : '>= 0.50',)
 
 # Set project information
@@ -88,8 +88,17 @@ if get_option('enable-tensorrt')
   cdata.set('HAVE_TENSORRT', 1)
 endif
 
+# Define library dependencies for ONNX support
+if get_option('enable-onnxrt')
+  onnxrt = cpp.find_library('onnxruntime', required: true)
+  onnxrt_dep = declare_dependency(dependencies: onnxrt)
+  lib_onnxrt_dep = [onnxrt_dep]
+  cdata.set('HAVE_ONNXRT', 1)
+endif
+
 # Check if at least one backend is enabled
-if not (cdata.has('HAVE_TENSORFLOW') or cdata.has('HAVE_TFLITE') or cdata.has('HAVE_TENSORRT'))
+if not (cdata.has('HAVE_TENSORFLOW') or cdata.has('HAVE_TFLITE') or
+        cdata.has('HAVE_TENSORRT') or cdata.has('HAVE_ONNXRT'))
   error ('No backend selected, you must choose at least one')
 endif
 
diff --git a/meson_options.txt b/meson_options.txt
index c9fd6c80..8f42e424 100644
--- a/meson_options.txt
+++ b/meson_options.txt
@@ -14,3 +14,5 @@ option('enable-tflite', type : 'boolean', value: false,
        description : 'Enable Tensorflow Lite backend support')
 option('enable-tensorrt', type : 'boolean', value: false,
        description : 'Enable TensorRT backend support')
+option('enable-onnxrt', type : 'boolean', value: false,
+       description : 'Enable ONNX Runtime backend support')
diff --git a/r2i/Makefile.am b/r2i/Makefile.am
index d275106e..25787f02 100644
--- a/r2i/Makefile.am
+++ b/r2i/Makefile.am
@@ -1,4 +1,4 @@
-# Copyright (C) 2018 RidgeRun, LLC (http://www.ridgerun.com)
+# Copyright (C) 2018-2020 RidgeRun, LLC (http://www.ridgerun.com)
 # All Rights Reserved.
 #
 # The contents of this software are proprietary and confidential to RidgeRun,
@@ -18,6 +18,10 @@ if HAVE_NCSDK
 SUBDIRS += ncsdk
 endif
 
+if HAVE_ONNXRT
+SUBDIRS += onnxrt
+endif
+
 if HAVE_TENSORFLOW
 SUBDIRS += tensorflow
 endif
@@ -33,6 +37,7 @@ endif
 DIST_SUBDIRS =          \
         edgetpu         \
         ncsdk           \
+        onnxrt          \
         tensorflow      \
         tensorrt        \
         tflite
@@ -91,6 +96,11 @@ libr2inference_@RR_PACKAGE_VERSION@_la_LIBADD +=    \
         $(top_builddir)/r2i/ncsdk/libncsdk.la
 endif
 
+if HAVE_ONNXRT
+libr2inference_@RR_PACKAGE_VERSION@_la_LIBADD +=    \
+        $(top_builddir)/r2i/onnxrt/libonnxrt.la
+endif
+
 if HAVE_TENSORFLOW
 libr2inference_@RR_PACKAGE_VERSION@_la_LIBADD +=    \
         $(top_builddir)/r2i/tensorflow/libtf.la
diff --git a/r2i/edgetpu/frameworkfactory.cc b/r2i/edgetpu/frameworkfactory.cc
index c08c4f68..90220401 100644
--- a/r2i/edgetpu/frameworkfactory.cc
+++ b/r2i/edgetpu/frameworkfactory.cc
@@ -28,7 +28,8 @@ r2i::FrameworkMeta FrameworkFactory::GetDescription (
   RuntimeError &error) {
   const FrameworkMeta meta {
     .code = r2i::FrameworkCode::EDGETPU,
-    .name = "edgetpu",
+    .name = "EdgeTPU",
+    .label = "edgetpu",
     .description = "Google's TensorFlow Lite with EdgeTPU support",
     .version = ::edgetpu::EdgeTpuManager::GetSingleton()->Version()
   };
diff --git a/r2i/frameworkmeta.h b/r2i/frameworkmeta.h
index 02d41442..542a0abe 100644
--- a/r2i/frameworkmeta.h
+++ b/r2i/frameworkmeta.h
@@ -35,6 +35,11 @@ struct FrameworkMeta {
    */
   const std::string name;
 
+  /**
+   * A short string to identify the framework
+   */
+  const std::string label;
+
   /**
   * A string with a description for the framework
   */
diff --git a/r2i/frameworks.h b/r2i/frameworks.h
index 3000e275..3ff627b5 100644
--- a/r2i/frameworks.h
+++ b/r2i/frameworks.h
@@ -14,11 +14,11 @@
 
 namespace r2i {
 /**
- * Numerical codes identifying supported frameworks. Not that not
+ * Numerical codes identifying supported frameworks. Note that not
  * all frameworks will be available at runtime. For example, some of
  * them may be disabled at configure by the user, automatically if
  * no development where found or if the system doesn't seem to have
- * to appropriate hardware.
+ * the appropriate hardware.
  */
 enum FrameworkCode {
 
@@ -32,6 +32,11 @@ enum FrameworkCode {
    */
   NCSDK,
 
+  /**
+   * Open Neural Network Exchange Runtime
+   */
+  ONNXRT,
+
   /**
    * Google's TensorFlow
    */
diff --git a/r2i/iframeworkfactory.cc b/r2i/iframeworkfactory.cc
index 7f330b3a..10c47545 100644
--- a/r2i/iframeworkfactory.cc
+++ b/r2i/iframeworkfactory.cc
@@ -17,6 +17,7 @@
 #include "config.h"
 #include "edgetpu/frameworkfactory.h"
 #include "ncsdk/frameworkfactory.h"
+#include "onnxrt/frameworkfactory.h"
 #include "tensorflow/frameworkfactory.h"
 #include "tensorrt/frameworkfactory.h"
 #include "tflite/frameworkfactory.h"
@@ -38,6 +39,15 @@ MakeNcsdkFactory (RuntimeError &error) {
 }
 #endif // HAVE_NCSDK
 
+#ifdef HAVE_ONNXRT
+static std::unique_ptr<IFrameworkFactory>
+MakeOnnxrtFactory(RuntimeError &error) {
+  return std::unique_ptr<onnxrt::FrameworkFactory>(new
+         onnxrt::FrameworkFactory);
+}
+#endif // HAVE_ONNXRT
+
+
 #ifdef HAVE_TENSORFLOW
 static std::unique_ptr<IFrameworkFactory>
 MakeTensorflowFactory (RuntimeError &error) {
@@ -74,6 +84,10 @@ const std::unordered_map<int, MakeFactory> frameworks ({
   {FrameworkCode::NCSDK, MakeNcsdkFactory},
 #endif //HAVE_NCSDK
 
+#ifdef HAVE_ONNXRT
+  {FrameworkCode::ONNXRT, MakeOnnxrtFactory},
+#endif //HAVE_ONNXRT
+
 #ifdef HAVE_TENSORFLOW
   {FrameworkCode::TENSORFLOW, MakeTensorflowFactory},
 #endif //HAVE_TENSORFLOW
diff --git a/r2i/meson.build b/r2i/meson.build
index ac559e42..6de3384d 100644
--- a/r2i/meson.build
+++ b/r2i/meson.build
@@ -20,6 +20,11 @@ if get_option('enable-tensorrt')
   r2inference_internal_dep += [internal_trt_dep]
 endif
 
+if get_option('enable-onnxrt')
+  subdir('onnxrt')
+  r2inference_internal_dep += [internal_onnxrt_dep]
+endif
+
 # Define source code
 r2inference_sources = [
   'datatype.cc',
diff --git a/r2i/ncsdk/frameworkfactory.cc b/r2i/ncsdk/frameworkfactory.cc
index 93e0e847..b944767d 100644
--- a/r2i/ncsdk/frameworkfactory.cc
+++ b/r2i/ncsdk/frameworkfactory.cc
@@ -51,6 +51,7 @@ r2i::FrameworkMeta FrameworkFactory::GetDescription (RuntimeError &error) {
   const FrameworkMeta meta {
     .code = r2i::FrameworkCode::NCSDK,
     .name = "NCSDK",
+    .label = "ncsdk",
     .description = "Intel Movidius Neural Compute software developer kit",
     .version = "2"
   };
diff --git a/r2i/onnxrt/Makefile.am b/r2i/onnxrt/Makefile.am
new file mode 100644
index 00000000..6523f202
--- /dev/null
+++ b/r2i/onnxrt/Makefile.am
@@ -0,0 +1,55 @@
+# Copyright (C) 2020 RidgeRun, LLC (http://www.ridgerun.com)
+# All Rights Reserved.
+#
+# The contents of this software are proprietary and confidential to RidgeRun,
+# LLC.  No part of this program may be photocopied, reproduced or translated
+# into another programming language without prior written consent of
+# RidgeRun, LLC.  The user is free to modify the source code after obtaining
+# a software license from RidgeRun.  All source code changes must be provided
+# back to RidgeRun without any encumbrance.
+
+if HAVE_ONNXRT
+
+noinst_LTLIBRARIES = libonnxrt.la
+
+# Define a custom area for our headers
+onnxrtincludedir = @R2IINCLUDEDIR@/r2i/onnxrt
+
+libonnxrt_la_SOURCES =           \
+    engine.cc                    \
+    frame.cc                     \
+    frameworkfactory.cc          \
+    loader.cc                    \
+    model.cc                     \
+    parameters.cc                \
+    prediction.cc
+
+libonnxrt_la_CPPFLAGS =          \
+    $(RR_CPPFLAGS)               \
+    $(CODE_COVERAGE_CPPFLAGS)
+
+libonnxrt_la_CFLAGS =            \
+    $(RR_CFLAGS)                 \
+    $(ONNXRT_CFLAGS)             \
+    $(CODE_COVERAGE_CFLAGS)
+
+libonnxrt_la_CXXFLAGS =          \
+    $(RR_CXXFLAGS)               \
+    $(ONNXRT_CFLAGS)             \
+    $(CODE_COVERAGE_CXXFLAGS)
+
+libonnxrt_la_LIBADD =            \
+    $(RR_LIBS)                   \
+    $(ONNXRT_LIBS)               \
+    $(CODE_COVERAGE_LIBS)
+
+onnxrtinclude_HEADERS =          \
+    engine.h                     \
+    frame.h                      \
+    frameworkfactory.h           \
+    loader.h                     \
+    model.h                      \
+    parameters.h                 \
+    prediction.h
+
+endif # HAVE_ONNXRT
diff --git a/r2i/onnxrt/engine.cc b/r2i/onnxrt/engine.cc
new file mode 100644
index 00000000..b876a8c8
--- /dev/null
+++ b/r2i/onnxrt/engine.cc
@@ -0,0 +1,515 @@
+/* Copyright (C) 2020 RidgeRun, LLC (http://www.ridgerun.com)
+ * All Rights Reserved.
+ *
+ * The contents of this software are proprietary and confidential to RidgeRun,
+ * LLC.  No part of this program may be photocopied, reproduced or translated
+ * into another programming language without prior written consent of
+ * RidgeRun, LLC.  The user is free to modify the source code after obtaining
+ * a software license from RidgeRun.  All source code changes must be provided
+ * back to RidgeRun without any encumbrance.
+ */
+
+#include "r2i/onnxrt/engine.h"
+
+#include <core/common/exceptions.h>
+#include <core/session/onnxruntime_cxx_api.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "r2i/onnxrt/frame.h"
+#include "r2i/onnxrt/model.h"
+#include "r2i/onnxrt/prediction.h"
+
+namespace r2i {
+namespace onnxrt {
+
+Engine::Engine () {
+  /* Initialize all variable members */
+  logging_level = OrtLoggingLevel::ORT_LOGGING_LEVEL_WARNING;
+  intra_num_threads = 1;
+  graph_opt_level = GraphOptimizationLevel::ORT_DISABLE_ALL;
+  log_id = "";
+  state = State::STOPPED;
+  model = nullptr;
+  output_size = 0;
+  num_input_nodes = 0;
+  num_output_nodes = 0;
+}
+
+Engine::~Engine () {
+  this->Stop();
+}
+
+RuntimeError Engine::SetModel (std::shared_ptr<r2i::IModel> in_model) {
+  RuntimeError error;
+
+  if (State::STOPPED != this->state) {
+    error.Set (RuntimeError::Code::WRONG_ENGINE_STATE,
+               "Attempting to set model in stopped state");
+    return error;
+  }
+
+  if (nullptr == in_model) {
+    error.Set (RuntimeError::Code:: NULL_PARAMETER,
+               "Received null model pointer");
+    return error;
+  }
+  auto model = std::dynamic_pointer_cast<r2i::onnxrt::Model, r2i::IModel>
+               (in_model);
+
+  if (nullptr == model) {
+    error.Set (RuntimeError::Code::FRAMEWORK_ERROR,
+               "The provided model is not an ONNXRT model");
+    return error;
+  }
+
+  this->model = model;
+
+  return error;
+}
+
+void Engine::CreateEnv() {
+  env = Ort::Env(this->logging_level, this->log_id.c_str());
+}
+
+void Engine::CreateSessionOptions() {
+  session_options = Ort::SessionOptions();
+  session_options.SetIntraOpNumThreads(this->intra_num_threads);
+  session_options.SetGraphOptimizationLevel(
+    this->graph_opt_level);
+}
+
+void Engine::CreateSession(const void *model_data,
+                           size_t model_data_size,
+                           RuntimeError &error) {
+
+  if (nullptr == this->env) {
+    error.Set (RuntimeError::Code:: NULL_PARAMETER,
+               "Ort::Env not initialized");
+  }
+
+  if (nullptr == this->session_options) {
+    error.Set (RuntimeError::Code:: NULL_PARAMETER,
+               "Ort::SessionOptions not initialized");
+  }
+
+  if (nullptr == model_data) {
+    error.Set (RuntimeError::Code:: NULL_PARAMETER,
+               "Received null model data pointer");
+  }
+
+  this->session = std::make_shared<Ort::Session>(this->env, model_data,
+                  model_data_size, this->session_options);
+}
+
+RuntimeError Engine::Start ()  {
+  RuntimeError error;
+
+  if (State::STARTED == this->state) {
+    error.Set (RuntimeError::Code::WRONG_ENGINE_STATE,
+               "Engine already started");
+    return error;
+  }
+
+  if (nullptr == this->model) {
+    error.Set (RuntimeError::Code:: NULL_PARAMETER,
+               "Model not set yet");
+    return error;
+  }
+
+  try {
+    this->CreateEnv();
+    this->CreateSessionOptions();
+    this->CreateSession((void *) this->model->GetOnnxrtModel().get(),
+                        this->model->GetOnnxrtModelSize(), error);
+    this->num_input_nodes = this->GetSessionInputCount(this->session, error);
+    this->num_output_nodes = this->GetSessionOutputCount(this->session, error);
+  }
+
+  catch (std::exception &excep) {
+    error.Set(RuntimeError::Code::FRAMEWORK_ERROR, excep.what());
+    return error;
+  }
+
+  /* In case it fails but not by an exception */
+  if (error.IsError ()) {
+    return error;
+  }
+
+  if (this->num_input_nodes > 1) {
+    error.Set(RuntimeError::Code::INCOMPATIBLE_MODEL,
+              "Number of inputs in the model is greater than 1, this is not supported");
+    return error;
+  }
+
+  if (this->num_output_nodes > 1) {
+    error.Set(RuntimeError::Code::INCOMPATIBLE_MODEL,
+              "Number of outputs in the model is greater than 1, this is not supported");
+    return error;
+  }
+
+  this->input_node_names.resize(num_input_nodes);
+  this->output_node_names.resize(num_output_nodes);
+
+  /* Warning: only 1 input and output supported */
+  error = GetSessionInfo(this->session, 0);
+  if (error.IsError ()) {
+    return error;
+  }
+
+  this->state = State::STARTED;
+
+  return error;
+}
+
+RuntimeError Engine::Stop () {
+  RuntimeError error;
+
+  if (State::STOPPED == this->state) {
+    error.Set (RuntimeError::Code::WRONG_ENGINE_STATE,
+               "Engine already stopped");
+  }
+
+  this->state = State::STOPPED;
+
+  return error;
+}
+
+std::shared_ptr<r2i::IPrediction> Engine::Predict (std::shared_ptr<r2i::IFrame>
+    in_frame, r2i::RuntimeError &error) {
+  ImageFormat frame_format;
+  int frame_width = 0;
+  int frame_height = 0;
+  int frame_channels = 0;
+  size_t input_image_size = 0;
+
+  auto prediction = std::make_shared<Prediction>();
+
+  error.Clean ();
+
+  if (State::STARTED != this->state) {
+    error.Set (RuntimeError::Code::WRONG_ENGINE_STATE,
+               "Engine not started");
+    return nullptr;
+  }
+
+  auto frame = std::dynamic_pointer_cast<Frame, IFrame> (in_frame);
+  if (!frame) {
+    error.Set (RuntimeError::Code::FRAMEWORK_ERROR,
+               "The provided frame is not an onnxrt frame");
+    return nullptr;
+  }
+
+  frame_format = frame->GetFormat();
+  frame_channels = frame_format.GetNumPlanes();
+  frame_height = frame->GetHeight();
+  frame_width = frame->GetWidth();
+  input_image_size = frame_height * frame_width * frame_channels;
+
+  error = this->ValidateInputTensorShape(frame_channels, frame_height,
+                                         frame_width, this->input_node_dims);
+  if (error.IsError ()) {
+    return nullptr;
+  }
+
+  /* Score model with input tensor, get back Prediction set with pointer
+   * of the output tensor result.
+   * Note that this implementation only supports 1 input and 1 output models.
+   */
+  error = this->ScoreModel(this->session, frame,
+                           input_image_size,
+                           this->output_size,
+                           this->input_node_dims,
+                           prediction);
+
+  if (error.IsError ()) {
+    return nullptr;
+  }
+
+  return prediction;
+}
+
+size_t Engine::GetSessionInputCount(std::shared_ptr<Ort::Session> session,
+                                    RuntimeError &error) {
+  if (nullptr == session) {
+    error.Set (RuntimeError::Code:: NULL_PARAMETER,
+               "Received null session pointer");
+    return 0;
+  }
+  return session->GetInputCount();
+}
+
+size_t Engine::GetSessionOutputCount(std::shared_ptr<Ort::Session> session,
+                                     RuntimeError &error) {
+  if (nullptr == session) {
+    error.Set (RuntimeError::Code:: NULL_PARAMETER,
+               "Received null session pointer");
+    return 0;
+  }
+  return session->GetOutputCount();
+}
+
+std::vector<int64_t> Engine::GetSessionInputNodeDims(
+  std::shared_ptr<Ort::Session> session, size_t index, RuntimeError &error) {
+  std::vector<int64_t> dims;
+  if (nullptr == session) {
+    error.Set (RuntimeError::Code:: NULL_PARAMETER,
+               "Received null session pointer");
+    return dims;
+  }
+  dims = session->GetInputTypeInfo(
+           index).GetTensorTypeAndShapeInfo().GetShape();
+  return dims;
+}
+
+size_t Engine::GetSessionOutputSize(std::shared_ptr<Ort::Session> session,
+                                    size_t index, RuntimeError &error) {
+  if (nullptr == session) {
+    error.Set (RuntimeError::Code:: NULL_PARAMETER,
+               "Received null session pointer");
+    return 0;
+  }
+  return session->GetOutputTypeInfo(
+           index).GetTensorTypeAndShapeInfo().GetElementCount();
+}
+
+const char *Engine::GetSessionInputName(std::shared_ptr<Ort::Session> session,
+                                        size_t index, OrtAllocator *allocator,
+                                        RuntimeError &error) {
+  const char *name = "";
+
+  if (nullptr == session) {
+    error.Set (RuntimeError::Code:: NULL_PARAMETER,
+               "Received null session pointer");
+    return name;
+  }
+
+  if (nullptr == allocator) {
+    error.Set (RuntimeError::Code:: NULL_PARAMETER,
+               "Received null allocator pointer");
+    return name;
+  }
+
+  name = session->GetInputName(index, allocator);
+  return name;
+}
+
+const char *Engine::GetSessionOutputName(std::shared_ptr<Ort::Session> session,
+    size_t index, OrtAllocator *allocator,
+    RuntimeError &error) {
+  const char *name = "";
+
+  if (nullptr == session) {
+    error.Set (RuntimeError::Code:: NULL_PARAMETER,
+               "Received null session pointer");
+    return name;
+  }
+
+  if (nullptr == allocator) {
+    error.Set (RuntimeError::Code:: NULL_PARAMETER,
+               "Received null allocator pointer");
+    return name;
+  }
+
+  name = session->GetOutputName(index, allocator);
+  return name;
+}
+
+RuntimeError Engine::GetSessionInfo(std::shared_ptr<Ort::Session> session,
+                                    size_t index) {
+  RuntimeError error;
+
+  Ort::AllocatorWithDefaultOptions input_allocator;
+  Ort::AllocatorWithDefaultOptions output_allocator;
+
+  try {
+    this->input_node_dims = this->GetSessionInputNodeDims(session, index, error);
+    this->output_size = this->GetSessionOutputSize(session, index, error);
+    this->input_node_names[index] = this->GetSessionInputName(session, index,
+                                    input_allocator, error);
+    this->output_node_names[index] = this->GetSessionOutputName(session, index,
+                                     output_allocator, error);
+  }
+
+  catch (std::exception &excep) {
+    error.Set(RuntimeError::Code::FRAMEWORK_ERROR, excep.what());
+    return error;
+  }
+
+  return error;
+}
+
+RuntimeError Engine::ValidateInputTensorShape (int channels, int height,
+    int width, std::vector<int64_t> input_dims) {
+  RuntimeError error;
+
+  /* We only support 1 batch */
+  if (1 != input_dims.at(0)) {
+    error.Set (RuntimeError::Code::INVALID_FRAMEWORK_PARAMETER,
+               "We only support a batch of 1 image(s) in our frames");
+    return error;
+  }
+
+  /* Check that channels match */
+  if (channels != input_dims.at(3)) {
+    std::string error_msg;
+    error_msg = "Channels per image:" + std::to_string(channels) +
+                ", needs to be equal to model input channels:" +
+                std::to_string(input_dims.at(1));
+    error.Set (RuntimeError::Code::INVALID_FRAMEWORK_PARAMETER, error_msg);
+    return error;
+  }
+
+  /* Check that heights match */
+  if (height != input_dims.at(2)) {
+    error.Set (RuntimeError::Code::INVALID_FRAMEWORK_PARAMETER,
+               "Unsupported image height");
+    return error;
+  }
+
+  /* Check that widths match */
+  if (width != input_dims.at(1)) {
+    error.Set (RuntimeError::Code::INVALID_FRAMEWORK_PARAMETER,
+               "Unsupported image width");
+    return error;
+  }
+
+  return error;
+}
+
+float *Engine::SessionRun (std::shared_ptr<Ort::Session> session,
+                           std::shared_ptr<Frame> frame,
+                           size_t input_image_size,
+                           std::vector<int64_t> input_node_dims,
+                           std::vector<Ort::Value> &output_tensor,
+                           RuntimeError &error) {
+  Ort::Value input_tensor{nullptr};
+  Ort::MemoryInfo memory_info = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator,
+                                OrtMemTypeDefault);
+  input_tensor = Ort::Value::CreateTensor<float>(memory_info,
+                 reinterpret_cast<float *>(frame->GetData()),
+                 input_image_size,
+                 input_node_dims.data(),
+                 input_node_dims.size());
+  output_tensor =
+    session->Run(Ort::RunOptions{nullptr}, input_node_names.data(),
+                 &input_tensor, num_input_nodes, output_node_names.data(),
+                 num_output_nodes);
+  return output_tensor.at(0).GetTensorMutableData<float>();
+}
+
+RuntimeError Engine::ScoreModel (std::shared_ptr<Ort::Session> session,
+                                 std::shared_ptr<Frame> frame,
+                                 size_t input_size,
+                                 size_t output_size,
+                                 std::vector<int64_t> input_node_dims,
+                                 std::shared_ptr<Prediction> prediction) {
+  RuntimeError error;
+  float *result;
+  std::vector<Ort::Value> output_tensor;
+
+  if (!frame->GetData()) {
+    error.Set (RuntimeError::Code::NULL_PARAMETER,
+               "The provided frame does not contain valid data");
+    return error;
+  }
+
+  try {
+    result = this->SessionRun(session, frame, input_size, input_node_dims,
+                              output_tensor, error);
+  }
+
+  catch (std::exception &excep) {
+    error.Set(RuntimeError::Code::FRAMEWORK_ERROR, excep.what());
+    return error;
+  }
+
+  error = prediction->SetTensorValues(result, output_size);
+  if (error.IsError ()) {
+    return error;
+  }
+
+  return error;
+}
+
+RuntimeError Engine::SetLoggingLevel (int logging_level) {
+  RuntimeError error;
+
+  if (State::STARTED == this->state) {
+    error.Set (RuntimeError::Code::WRONG_ENGINE_STATE,
+               "Parameter can't be set, engine already started");
+    return error;
+  }
+
+  /* We need to convert int to OrtLoggingLevel enum */
+  this->logging_level = static_cast<OrtLoggingLevel>(logging_level);
+
+  return error;
+}
+
+RuntimeError Engine::SetIntraNumThreads (int intra_num_threads) {
+  RuntimeError error;
+
+  if (State::STARTED == this->state) {
+    error.Set (RuntimeError::Code::WRONG_ENGINE_STATE,
+               "Parameter can't be set, engine already started");
+    return error;
+  }
+
+  this->intra_num_threads = intra_num_threads;
+
+  return error;
+}
+
+RuntimeError Engine::SetGraphOptLevel (int graph_opt_level) {
+  RuntimeError error;
+
+  if (State::STARTED == this->state) {
+    error.Set (RuntimeError::Code::WRONG_ENGINE_STATE,
+               "Parameter can't be set, engine already started");
+    return error;
+  }
+
+  /* We need to convert int to GraphOptimizationLevel enum */
+  this->graph_opt_level = static_cast<GraphOptimizationLevel>(graph_opt_level);
+
+  return error;
+}
+
+RuntimeError Engine::SetLogId (const std::string &log_id) {
+  RuntimeError error;
+
+  if (State::STARTED == this->state) {
+    error.Set (RuntimeError::Code::WRONG_ENGINE_STATE,
+               "Parameter can't be set, engine already started");
+    return error;
+  }
+
+  this->log_id = log_id;
+
+  return error;
+}
+
+int Engine::GetLoggingLevel () {
+  /* We need to convert OrtLoggingLevel enum to int */
+  return static_cast<int>(this->logging_level);
+}
+
+int Engine::GetIntraNumThreads () {
+
+  return this->intra_num_threads;
+}
+
+int Engine::GetGraphOptLevel () {
+  /* We need to convert GraphOptimizationLevel enum to int */
+  return static_cast<int>(this->graph_opt_level);
+}
+
+const std::string Engine::GetLogId () {
+  return this->log_id;
+}
+
+}  // namespace onnxrt
+}  // namespace r2i
diff --git a/r2i/onnxrt/engine.h b/r2i/onnxrt/engine.h
new file mode 100644
index 00000000..ed73d6cf
--- /dev/null
+++ b/r2i/onnxrt/engine.h
@@ -0,0 +1,109 @@
+/* Copyright (C) 2020 RidgeRun, LLC (http://www.ridgerun.com)
+ * All Rights Reserved.
+ *
+ * The contents of this software are proprietary and confidential to RidgeRun,
+ * LLC.  No part of this program may be photocopied, reproduced or translated
+ * into another programming language without prior written consent of
+ * RidgeRun, LLC.  The user is free to modify the source code after obtaining
+ * a software license from RidgeRun.  All source code changes must be provided
+ * back to RidgeRun without any encumbrance.
+*/
+
+#ifndef R2I_ONNXRT_ENGINE_H
+#define R2I_ONNXRT_ENGINE_H
+
+#include <r2i/iengine.h>
+
+#include <core/session/onnxruntime_cxx_api.h>
+
+#include <memory>
+#include <vector>
+
+#include <r2i/onnxrt/frame.h>
+#include <r2i/onnxrt/model.h>
+#include <r2i/onnxrt/prediction.h>
+
+namespace r2i {
+namespace onnxrt {
+
+class Engine : public IEngine {
+ public:
+  Engine ();
+  ~Engine ();
+  r2i::RuntimeError SetModel (std::shared_ptr<r2i::IModel> in_model) override;
+  r2i::RuntimeError Start () override;
+  r2i::RuntimeError Stop () override;
+  std::shared_ptr<r2i::IPrediction> Predict (std::shared_ptr<r2i::IFrame>
+      in_frame, r2i::RuntimeError &error) override;
+  r2i::RuntimeError SetLoggingLevel (int logging_level);
+  r2i::RuntimeError SetLogId (const std::string &log_id);
+  r2i::RuntimeError SetIntraNumThreads (int intra_num_threads);
+  r2i::RuntimeError SetGraphOptLevel (int graph_opt_level);
+  int GetLoggingLevel ();
+  int GetIntraNumThreads ();
+  int GetGraphOptLevel ();
+  const std::string GetLogId ();
+
+ private:
+  enum State {
+    STARTED,
+    STOPPED
+  };
+
+  /* ONNXRT parameters must be initialized in case user does not set any */
+  OrtLoggingLevel logging_level;
+  int intra_num_threads;
+  GraphOptimizationLevel graph_opt_level;
+  std::string log_id;
+  State state;
+  std::shared_ptr<Model> model;
+  std::vector<int64_t> input_node_dims;
+  std::vector<const char *> input_node_names;
+  std::vector<const char *> output_node_names;
+  size_t output_size;
+  size_t num_input_nodes;
+  size_t num_output_nodes;
+  Ort::Env env = Ort::Env(nullptr);
+  Ort::SessionOptions session_options = Ort::SessionOptions(nullptr);
+  std::shared_ptr<Ort::Session> session;
+
+  void CreateEnv();
+  void CreateSessionOptions();
+  void CreateSession(const void *model_data, size_t model_data_size,
+                     RuntimeError &error);
+  size_t GetSessionInputCount(std::shared_ptr<Ort::Session> session,
+                              RuntimeError &error);
+  size_t GetSessionOutputCount(std::shared_ptr<Ort::Session> session,
+                               RuntimeError &error);
+  std::vector<int64_t> GetSessionInputNodeDims(std::shared_ptr<Ort::Session>
+      session, size_t index, RuntimeError &error);
+  size_t GetSessionOutputSize(std::shared_ptr<Ort::Session> session,
+                              size_t index, RuntimeError &error);
+  const char *GetSessionInputName(std::shared_ptr<Ort::Session> session,
+                                  size_t index,
+                                  OrtAllocator *allocator, RuntimeError &error);
+  const char *GetSessionOutputName(std::shared_ptr<Ort::Session> session,
+                                   size_t index,
+                                   OrtAllocator *allocator, RuntimeError &error);
+  float *SessionRun (std::shared_ptr<Ort::Session> session,
+                     std::shared_ptr<Frame> frame,
+                     size_t input_image_size,
+                     std::vector<int64_t> input_node_dims,
+                     std::vector<Ort::Value> &output_tensor,
+                     RuntimeError &error);
+  r2i::RuntimeError GetSessionInfo(std::shared_ptr<Ort::Session> session,
+                                   size_t index);
+  r2i::RuntimeError ValidateInputTensorShape (int channels, int height, int width,
+      std::vector<int64_t> input_dims);
+  r2i::RuntimeError ScoreModel (std::shared_ptr<Ort::Session> session,
+                                std::shared_ptr<Frame> frame,
+                                size_t input_size,
+                                size_t output_size,
+                                std::vector<int64_t> input_node_dims,
+                                std::shared_ptr<Prediction> prediction);
+};
+
+}  // namespace onnxrt
+}  // namespace r2i
+
+#endif  //R2I_ONNXRT_ENGINE_H
diff --git a/r2i/onnxrt/frame.cc b/r2i/onnxrt/frame.cc
new file mode 100644
index 00000000..b1c7ca47
--- /dev/null
+++ b/r2i/onnxrt/frame.cc
@@ -0,0 +1,71 @@
+/* Copyright (C) 2020 RidgeRun, LLC (http://www.ridgerun.com)
+ * All Rights Reserved.
+ *
+ * The contents of this software are proprietary and confidential to RidgeRun,
+ * LLC.  No part of this program may be photocopied, reproduced or translated
+ * into another programming language without prior written consent of
+ * RidgeRun, LLC.  The user is free to modify the source code after obtaining
+ * a software license from RidgeRun.  All source code changes must be provided
+ * back to RidgeRun without any encumbrance.
+*/
+
+#include "r2i/onnxrt/frame.h"
+
+namespace r2i {
+namespace onnxrt {
+
+Frame::Frame () :
+  frame_data(nullptr), frame_width(0), frame_height(0),
+  frame_format(ImageFormat::Id::UNKNOWN_FORMAT) {
+}
+
+RuntimeError Frame::Configure (void *in_data, int width,
+                               int height, r2i::ImageFormat::Id format) {
+  RuntimeError error;
+  ImageFormat imageformat (format);
+
+  if (nullptr == in_data) {
+    error.Set (RuntimeError::Code::NULL_PARAMETER, "Received a NULL data pointer");
+    return error;
+  }
+  if (width <= 0) {
+    error.Set (RuntimeError::Code::WRONG_API_USAGE,
+               "Received an invalid image width");
+    return error;
+  }
+  if (height <= 0) {
+    error.Set (RuntimeError::Code::WRONG_API_USAGE,
+               "Received an invalid image height");
+    return error;
+  }
+
+  this->frame_data = static_cast<float *>(in_data);
+  this->frame_width = width;
+  this->frame_height = height;
+  this->frame_format = imageformat;
+
+  return error;
+}
+
+void *Frame::GetData () {
+  return this->frame_data;
+}
+
+int Frame::GetWidth () {
+  return this->frame_width;
+}
+
+int Frame::GetHeight () {
+  return this->frame_height;
+}
+
+ImageFormat Frame::GetFormat () {
+  return this->frame_format;
+}
+
+DataType Frame::GetDataType () {
+  return r2i::DataType::Id::FLOAT;
+}
+
+}  // namespace onnxrt
+}  // namespace r2i
diff --git a/r2i/onnxrt/frame.h b/r2i/onnxrt/frame.h
new file mode 100644
index 00000000..eab3cc7d
--- /dev/null
+++ b/r2i/onnxrt/frame.h
@@ -0,0 +1,48 @@
+/* Copyright (C) 2020 RidgeRun, LLC (http://www.ridgerun.com)
+ * All Rights Reserved.
+ *
+ * The contents of this software are proprietary and confidential to RidgeRun,
+ * LLC.  No part of this program may be photocopied, reproduced or translated
+ * into another programming language without prior written consent of
+ * RidgeRun, LLC.  The user is free to modify the source code after obtaining
+ * a software license from RidgeRun.  All source code changes must be provided
+ * back to RidgeRun without any encumbrance.
+*/
+
+#ifndef R2I_ONNXRT_FRAME_H
+#define R2I_ONNXRT_FRAME_H
+
+#include <r2i/iframe.h>
+
+namespace r2i {
+namespace onnxrt {
+
+class Frame : public IFrame {
+ public:
+  Frame ();
+
+  RuntimeError Configure (void *in_data, int width,
+                          int height, r2i::ImageFormat::Id format) override;
+
+  void *GetData () override;
+
+  int GetWidth () override;
+
+  int GetHeight () override;
+
+  ImageFormat GetFormat () override;
+
+  virtual DataType GetDataType () override;
+
+ private:
+  float *frame_data;
+  int frame_width;
+  int frame_height;
+  ImageFormat frame_format;
+
+};
+
+}  // namespace onnxrt
+}  // namespace r2i
+
+#endif //R2I_ONNXRT_FRAME_H
diff --git a/r2i/onnxrt/frameworkfactory.cc b/r2i/onnxrt/frameworkfactory.cc
new file mode 100644
index 00000000..7ae7e81b
--- /dev/null
+++ b/r2i/onnxrt/frameworkfactory.cc
@@ -0,0 +1,67 @@
+/* Copyright (C) 2020 RidgeRun, LLC (http://www.ridgerun.com)
+ * All Rights Reserved.
+ *
+ * The contents of this software are proprietary and confidential to RidgeRun,
+ * LLC.  No part of this program may be photocopied, reproduced or translated
+ * into another programming language without prior written consent of
+ * RidgeRun, LLC.  The user is free to modify the source code after obtaining
+ * a software license from RidgeRun.  All source code changes must be provided
+ * back to RidgeRun without any encumbrance.
+*/
+
+#include "frameworkfactory.h"
+
+#include <memory>
+
+#include "engine.h"
+#include "frame.h"
+#include "loader.h"
+#include "parameters.h"
+
+namespace r2i {
+namespace onnxrt {
+
+std::unique_ptr<r2i::ILoader> FrameworkFactory::MakeLoader (
+  RuntimeError &error) {
+  error.Clean ();
+
+  return std::unique_ptr<ILoader> (new Loader);
+}
+
+std::unique_ptr<r2i::IEngine> FrameworkFactory::MakeEngine (
+  RuntimeError &error) {
+  error.Clean ();
+
+  return std::unique_ptr<IEngine> (new Engine);
+}
+
+std::unique_ptr<r2i::IParameters> FrameworkFactory::MakeParameters (
+  RuntimeError &error) {
+  error.Clean ();
+
+  return std::unique_ptr<IParameters> (new Parameters);
+}
+
+std::unique_ptr<r2i::IFrame> FrameworkFactory::MakeFrame (
+  RuntimeError &error) {
+  error.Clean ();
+
+  return std::unique_ptr<IFrame> (new Frame);
+}
+
+r2i::FrameworkMeta FrameworkFactory::GetDescription (RuntimeError &error) {
+  const FrameworkMeta meta {
+    .code = r2i::FrameworkCode::ONNXRT,
+    .name = "ONNXRuntime",
+    .label = "onnxrt",
+    .description = "Microsoft ONNX Runtime",
+    .version = std::to_string(ORT_API_VERSION)
+  };
+
+  error.Clean ();
+
+  return meta;
+}
+
+} // namespace onnxrt
+} // namespace r2i
diff --git a/r2i/onnxrt/frameworkfactory.h b/r2i/onnxrt/frameworkfactory.h
new file mode 100644
index 00000000..b97e54ac
--- /dev/null
+++ b/r2i/onnxrt/frameworkfactory.h
@@ -0,0 +1,33 @@
+/* Copyright (C) 2020 RidgeRun, LLC (http://www.ridgerun.com)
+ * All Rights Reserved.
+ *
+ * The contents of this software are proprietary and confidential to RidgeRun,
+ * LLC.  No part of this program may be photocopied, reproduced or translated
+ * into another programming language without prior written consent of
+ * RidgeRun, LLC.  The user is free to modify the source code after obtaining
+ * a software license from RidgeRun.  All source code changes must be provided
+ * back to RidgeRun without any encumbrance.
+*/
+
+#ifndef R2I_ONNXRT_FRAMEWORK_FACTORY_H
+#define R2I_ONNXRT_FRAMEWORK_FACTORY_H
+
+#include <r2i/iframeworkfactory.h>
+
+namespace r2i {
+namespace onnxrt {
+
+class FrameworkFactory : public IFrameworkFactory {
+ public:
+  std::unique_ptr<r2i::ILoader> MakeLoader (RuntimeError &error) override;
+  std::unique_ptr<r2i::IEngine> MakeEngine (RuntimeError &error) override;
+  std::unique_ptr<r2i::IParameters> MakeParameters (RuntimeError &error) override;
+  std::unique_ptr<r2i::IFrame> MakeFrame (RuntimeError &error) override;
+
+  r2i::FrameworkMeta GetDescription (RuntimeError &error) override;
+};
+
+} // namespace onnxrt
+} // namespace r2i
+
+#endif //R2I_ONNXRT_FRAMEWORK_FACTORY_H
diff --git a/r2i/onnxrt/loader.cc b/r2i/onnxrt/loader.cc
new file mode 100644
index 00000000..b6951b18
--- /dev/null
+++ b/r2i/onnxrt/loader.cc
@@ -0,0 +1,66 @@
+/* Copyright (C) 2020 RidgeRun, LLC (http://www.ridgerun.com)
+ * All Rights Reserved.
+ *
+ * The contents of this software are proprietary and confidential to RidgeRun,
+ * LLC.  No part of this program may be photocopied, reproduced or translated
+ * into another programming language without prior written consent of
+ * RidgeRun, LLC.  The user is free to modify the source code after obtaining
+ * a software license from RidgeRun.  All source code changes must be provided
+ * back to RidgeRun without any encumbrance.
+*/
+
+#include "r2i/onnxrt/loader.h"
+
+#include <fstream>
+#include <memory>
+#include <string>
+
+#include "r2i/imodel.h"
+#include "r2i/onnxrt/model.h"
+
+namespace r2i {
+namespace onnxrt {
+
+std::shared_ptr<r2i::IModel> Loader::Load(const std::string &in_path,
+    r2i::RuntimeError &error) {
+  if (in_path.empty()) {
+    error.Set(RuntimeError::Code::WRONG_API_USAGE,
+              "Received NULL path to file");
+    return nullptr;
+  }
+
+  std::ifstream graphdef_file;
+  graphdef_file.open(in_path, std::ios::binary | std::ios::ate);
+  if (false == graphdef_file.is_open()) {
+    error.Set(RuntimeError::Code::FILE_ERROR, "Unable to open file");
+    return nullptr;
+  }
+
+  size_t graphdef_size = graphdef_file.tellg();
+  graphdef_file.seekg (0, std::ios::beg);
+
+  this->model_data = std::shared_ptr<char>(new char[graphdef_size],
+                     std::default_delete<char[]>());
+  if (nullptr == this->model_data) {
+    error.Set (RuntimeError::Code::MEMORY_ERROR,
+               "Can not allocate memory for graphdef");
+    return nullptr;
+  }
+
+  graphdef_file.read (model_data.get(), graphdef_size);
+  graphdef_file.close();
+
+  auto model = std::make_shared<Model>();
+
+  error = model->SetOnnxrtModel(std::static_pointer_cast<void>(this->model_data),
+                                graphdef_size);
+
+  if (error.IsError()) {
+    return nullptr;
+  }
+
+  return model;
+}
+
+}  // namespace onnxrt
+}  // namespace r2i
diff --git a/r2i/onnxrt/loader.h b/r2i/onnxrt/loader.h
new file mode 100644
index 00000000..d7f7a6af
--- /dev/null
+++ b/r2i/onnxrt/loader.h
@@ -0,0 +1,40 @@
+/* Copyright (C) 2020 RidgeRun, LLC (http://www.ridgerun.com)
+ * All Rights Reserved.
+ *
+ * The contents of this software are proprietary and confidential to RidgeRun,
+ * LLC.  No part of this program may be photocopied, reproduced or translated
+ * into another programming language without prior written consent of
+ * RidgeRun, LLC.  The user is free to modify the source code after obtaining
+ * a software license from RidgeRun.  All source code changes must be provided
+ * back to RidgeRun without any encumbrance.
+*/
+
+#ifndef R2I_ONNX_LOADER_H
+#define R2I_ONNX_LOADER_H
+
+#include <r2i/iloader.h>
+
+#include <core/session/onnxruntime_cxx_api.h>
+
+#include <memory>
+#include <string>
+
+#include <r2i/imodel.h>
+#include <r2i/onnxrt/model.h>
+
+namespace r2i {
+namespace onnxrt {
+
+class Loader : public ILoader {
+ public:
+  virtual std::shared_ptr<r2i::IModel> Load(const std::string &in_path,
+      r2i::RuntimeError &error) override;
+
+ private:
+  std::shared_ptr<Model> model;
+  std::shared_ptr<char> model_data;
+};
+}  // namespace onnxrt
+}  // namespace r2i
+
+#endif  // R2I_ONNX_LOADER_H
diff --git a/r2i/onnxrt/meson.build b/r2i/onnxrt/meson.build
new file mode 100644
index 00000000..49e20c94
--- /dev/null
+++ b/r2i/onnxrt/meson.build
@@ -0,0 +1,34 @@
+# Define source code
+onnxrt_sources = [
+  'engine.cc',
+  'frame.cc',
+  'frameworkfactory.cc',
+  'loader.cc',
+  'model.cc',
+  'parameters.cc',
+  'prediction.cc',
+]
+
+onnxrt_headers = [
+  'engine.h',
+  'frame.h',
+  'frameworkfactory.h',
+  'loader.h',
+  'model.h',
+  'parameters.h',
+  'prediction.h',
+]
+
+# Build library
+onnxrt_lib = static_library('onnxrt',
+  onnxrt_sources,
+  cpp_args : cpp_args,
+  include_directories : [configinc],
+  dependencies : [lib_onnxrt_dep],
+)
+
+# Install library header files
+install_headers(onnxrt_headers, subdir : inc_install_dir + '/r2i/onnxrt')
+
+# Define the library as an internal dependency to the current build
+internal_onnxrt_dep = declare_dependency(link_with: onnxrt_lib, dependencies: lib_onnxrt_dep)
diff --git a/r2i/onnxrt/model.cc b/r2i/onnxrt/model.cc
new file mode 100644
index 00000000..bbce4772
--- /dev/null
+++ b/r2i/onnxrt/model.cc
@@ -0,0 +1,55 @@
+/* Copyright (C) 2020 RidgeRun, LLC (http://www.ridgerun.com)
+ * All Rights Reserved.
+ *
+ * The contents of this software are proprietary and confidential to RidgeRun,
+ * LLC.  No part of this program may be photocopied, reproduced or translated
+ * into another programming language without prior written consent of
+ * RidgeRun, LLC.  The user is free to modify the source code after obtaining
+ * a software license from RidgeRun. All source code changes must be provided
+ * back to RidgeRun without any encumbrance.
+*/
+
+#include "r2i/onnxrt/model.h"
+
+#include <string>
+#include <vector>
+
+namespace r2i {
+namespace onnxrt {
+
+Model::Model() {
+  this->model_data = nullptr;
+}
+
+RuntimeError Model::Start(const std::string &name) {
+  RuntimeError error;
+
+  return error;
+}
+
+RuntimeError Model::SetOnnxrtModel(std::shared_ptr<void> model_data,
+                                   size_t model_data_size) {
+  RuntimeError error;
+
+  if (nullptr == model_data) {
+    error.Set(RuntimeError::Code::NULL_PARAMETER,
+              "Trying to set model data with null pointer");
+    return error;
+  }
+
+  this->model_data = model_data;
+  this->model_data_size = model_data_size;
+
+  return error;
+}
+
+std::shared_ptr<void> Model::GetOnnxrtModel() {
+  return this->model_data;
+}
+
+size_t Model::GetOnnxrtModelSize() {
+  return this->model_data_size;
+}
+
+}  // namespace onnxrt
+}  // namespace r2i
diff --git a/r2i/onnxrt/model.h b/r2i/onnxrt/model.h
new file mode 100644
index 00000000..66b6ebd8
--- /dev/null
+++ b/r2i/onnxrt/model.h
@@ -0,0 +1,46 @@
+/* Copyright (C) 2020 RidgeRun, LLC (http://www.ridgerun.com)
+ * All Rights Reserved.
+ *
+ * The contents of this software are proprietary and confidential to RidgeRun,
+ * LLC.  No part of this program may be photocopied, reproduced or translated
+ * into another programming language without prior written consent of
+ * RidgeRun, LLC.  The user is free to modify the source code after obtaining
+ * a software license from RidgeRun.  All source code changes must be provided
+ * back to RidgeRun without any encumbrance.
+*/
+
+#ifndef R2I_ONNX_MODEL_H
+#define R2I_ONNX_MODEL_H
+
+#include <r2i/imodel.h>
+
+#include <core/session/onnxruntime_cxx_api.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <r2i/runtimeerror.h>
+
+namespace r2i {
+namespace onnxrt {
+
+class Model : public IModel {
+ public:
+  Model();
+
+  std::shared_ptr<Ort::Session> GetOnnxrtSession();
+  RuntimeError Start(const std::string &name) override;
+  RuntimeError SetOnnxrtModel(std::shared_ptr<void> model_data,
+                              size_t model_data_size);
+  std::shared_ptr<void> GetOnnxrtModel();
+  size_t GetOnnxrtModelSize();
+
+ private:
+  std::shared_ptr<void> model_data;
+  size_t model_data_size;
+};
+}  // namespace onnxrt
+}  // namespace r2i
+
+#endif  // R2I_ONNX_MODEL_H
diff --git a/r2i/onnxrt/parameters.cc b/r2i/onnxrt/parameters.cc
new file mode 100644
index 00000000..877e08d4
--- /dev/null
+++ b/r2i/onnxrt/parameters.cc
@@ -0,0 +1,222 @@
+/* Copyright (C) 2020 RidgeRun, LLC (http://www.ridgerun.com)
+ * All Rights Reserved.
+ *
+ * The contents of this software are proprietary and confidential to RidgeRun,
+ * LLC.  No part of this program may be photocopied, reproduced or translated
+ * into another programming language without prior written consent of
+ * RidgeRun, LLC.  The user is free to modify the source code after obtaining
+ * a software license from RidgeRun.  All source code changes must be provided
+ * back to RidgeRun without any encumbrance.
+ */
+
+#include "parameters.h"
+
+#include <string>
+
+namespace r2i {
+namespace onnxrt {
+
+#define PARAM(_name, _desc, _flags, _type, _acc) \
+  {						 \
+    (_name),					 \
+    {						 \
+      .meta = {					 \
+	.name = (_name),			 \
+	.description = (_desc),			 \
+	.flags = (_flags),			 \
+	.type = (_type),			 \
+      },					 \
+      .accessor = (_acc)			 \
+    }						 \
+  }
+
+Parameters::Parameters () :
+  parameter_map ({
+  /* Engine parameters */
+  PARAM("logging-level", "ONNXRT Logging Level",
+        r2i::ParameterMeta::Flags::READWRITE | r2i::ParameterMeta::Flags::WRITE_BEFORE_START,
+        r2i::ParameterMeta::Type::INTEGER,
+        std::make_shared<LoggingLevelAccessor>(this)),
+  PARAM("log-id", "String identification for ONNXRT environment",
+        r2i::ParameterMeta::Flags::READWRITE | r2i::ParameterMeta::Flags::WRITE_BEFORE_START,
+        r2i::ParameterMeta::Type::STRING,
+        std::make_shared<LogIdAccessor>(this)),
+  PARAM("intra-num-threads", "Number of threads to parallelize execution within model nodes",
+        r2i::ParameterMeta::Flags::READWRITE | r2i::ParameterMeta::Flags::WRITE_BEFORE_START,
+        r2i::ParameterMeta::Type::INTEGER,
+        std::make_shared<IntraNumThreadsAccessor>(this)),
+  PARAM("graph-optimization-level", "ONNXRT graph optimization level",
+        r2i::ParameterMeta::Flags::READWRITE | r2i::ParameterMeta::Flags::WRITE_BEFORE_START,
+        r2i::ParameterMeta::Type::INTEGER,
+        std::make_shared<GraphOptLevelAccessor>(this)),
+}) {
+}
+
+RuntimeError Parameters::Configure (std::shared_ptr<r2i::IEngine> in_engine,
+                                    std::shared_ptr<r2i::IModel> in_model) {
+  RuntimeError error;
+
+  if (nullptr == in_engine) {
+    error.Set (RuntimeError::Code::NULL_PARAMETER, "Received null engine");
+    return error;
+  }
+
+  if (nullptr == in_model) {
+    error.Set (RuntimeError::Code::NULL_PARAMETER, "Received null model");
+    return error;
+  }
+
+  auto engine = std::dynamic_pointer_cast<Engine, IEngine>(in_engine);
+  if (nullptr == engine) {
+    error.Set (RuntimeError::Code::INCOMPATIBLE_ENGINE,
+               "The provided engine is not an onnxrt engine");
+    return error;
+  }
+
+  auto model = std::dynamic_pointer_cast<Model, IModel>(in_model);
+  if (nullptr == model) {
+    error.Set (RuntimeError::Code::INCOMPATIBLE_MODEL,
+               "The provided engine is not an onnxrt model");
+    return error;
+  }
+
+  this->engine = engine;
+  this->model = model;
+
+  return error;
+}
+
+std::shared_ptr<r2i::IEngine> Parameters::GetEngine () {
+  return this->engine;
+}
+
+
+std::shared_ptr<r2i::IModel> Parameters::GetModel () {
+  return this->model;
+}
+
+Parameters::ParamDesc Parameters::Validate (const std::string &in_parameter,
+    int type, const std::string &stype, RuntimeError &error) {
+  ParamDesc undefined = {{.name = "", .description = ""}, nullptr};
+
+  error.Clean ();
+
+  auto match = this->parameter_map.find (in_parameter);
+
+  /* The parameter wasn't found */
+  if (match == this->parameter_map.end ()) {
+    error.Set (RuntimeError::Code::INVALID_FRAMEWORK_PARAMETER,
+               "Parameter \"" + in_parameter + "\" does not exist");
+    return undefined;
+  }
+
+  ParamDesc param = match->second;
+
+  /* The parameter is not of the correct type */
+  if (param.meta.type != type) {
+    error.Set (RuntimeError::Code::INVALID_FRAMEWORK_PARAMETER,
+               "Parameter \"" + in_parameter + "\" is not of type " + stype);
+    return undefined;
+  }
+
+  return param;
+}
+
+RuntimeError Parameters::Get (const std::string &in_parameter, int &value) {
+  RuntimeError error;
+
+  ParamDesc param = this->Validate (in_parameter,
+                                    r2i::ParameterMeta::Type::INTEGER,
+                                    "integer", error);
+  if (error.IsError ()) {
+    return error;
+  }
+
+  auto accessor = std::dynamic_pointer_cast<IntAccessor>(param.accessor);
+
+  error = accessor->Get ();
+  if (error.IsError ()) {
+    return error;
+  }
+
+  value = accessor->value;
+  return error;
+}
+
+RuntimeError Parameters::Get (const std::string &in_parameter, double &value) {
+  RuntimeError error;
+  return error;
+}
+
+RuntimeError Parameters::Get (const std::string &in_parameter,
+                              std::string &value) {
+  RuntimeError error;
+
+  ParamDesc param = this->Validate (in_parameter,
+                                    r2i::ParameterMeta::Type::STRING,
+                                    "string", error);
+  if (error.IsError ()) {
+    return error;
+  }
+
+  auto accessor = std::dynamic_pointer_cast<StringAccessor>(param.accessor);
+
+  error = accessor->Get ();
+  if (error.IsError ()) {
+    return error;
+  }
+
+  value = accessor->value;
+  return error;
+}
+
+RuntimeError Parameters::Set (const std::string &in_parameter, int in_value) {
+  RuntimeError error;
+
+  ParamDesc param = this->Validate (in_parameter,
+                                    r2i::ParameterMeta::Type::INTEGER,
+                                    "integer", error);
+  if (error.IsError ()) {
+    return error;
+  }
+
+  auto accessor = std::dynamic_pointer_cast<IntAccessor>(param.accessor);
+
+  accessor->value = in_value;
+  return accessor->Set ();
+}
+
+RuntimeError Parameters::Set (const std::string &in_parameter,
+                              const std::string &in_value) {
+  RuntimeError error;
+
+  ParamDesc param = this->Validate (in_parameter,
+                                    r2i::ParameterMeta::Type::STRING,
+                                    "string", error);
+  if (error.IsError ()) {
+    return error;
+  }
+
+  auto accessor = std::dynamic_pointer_cast<StringAccessor>(param.accessor);
+
+  accessor->value = in_value;
+  return accessor->Set ();
+}
+
+RuntimeError Parameters::Set (const std::string &in_parameter,
+                              double in_value) {
+  RuntimeError error;
+  return error;
+}
+
+RuntimeError Parameters::List (std::vector<ParameterMeta> &metas) {
+  for (auto &param : this->parameter_map) {
+    r2i::ParameterMeta meta = param.second.meta;
+    metas.push_back(meta);
+  }
+
+  return RuntimeError();
+}
+
+}  // namespace onnxrt
+}  // namespace r2i
diff --git a/r2i/onnxrt/parameters.h b/r2i/onnxrt/parameters.h
new file mode 100644
index 00000000..05b26535
--- /dev/null
+++ b/r2i/onnxrt/parameters.h
@@ -0,0 +1,144 @@
+/* Copyright (C) 2020 RidgeRun, LLC (http://www.ridgerun.com)
+ * All Rights Reserved.
+ *
+ * The contents of this software are proprietary and confidential to RidgeRun,
+ * LLC.  No part of this program may be photocopied, reproduced or translated
+ * into another programming language without prior written consent of
+ * RidgeRun, LLC.  The user is free to modify the source code after obtaining
+ * a software license from RidgeRun.  All source code changes must be provided
+ * back to RidgeRun without any encumbrance.
+*/
+
+#ifndef R2I_ONNXRT_PARAMETERS_H
+#define R2I_ONNXRT_PARAMETERS_H
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+#include <r2i/iparameters.h>
+#include <r2i/runtimeerror.h>
+#include <r2i/onnxrt/engine.h>
+#include <r2i/onnxrt/model.h>
+
+namespace r2i {
+namespace onnxrt {
+
+class Parameters: public IParameters {
+ public:
+  Parameters ();
+  RuntimeError Configure (std::shared_ptr<IEngine> in_engine,
+                          std::shared_ptr<IModel> in_model) override;
+  std::shared_ptr<IEngine> GetEngine () override;
+  std::shared_ptr<IModel> GetModel ( ) override;
+  RuntimeError Get (const std::string &in_parameter, int &value) override;
+  RuntimeError Get (const std::string &in_parameter, double &value) override;
+  RuntimeError Get (const std::string &in_parameter,
+                    std::string &value) override;
+  RuntimeError Set (const std::string &in_parameter,
+                    const std::string &in_value) override;
+  RuntimeError Set (const std::string &in_parameter, int in_value) override;
+  RuntimeError Set (const std::string &in_parameter, double in_value) override;
+  RuntimeError List (std::vector<ParameterMeta> &metas) override;
+
+ private:
+  std::shared_ptr <Engine> engine;
+  std::shared_ptr <Model> model;
+
+  friend class Accessor;
+
+  class Accessor {
+   public:
+    Accessor (Parameters *target) : target(target) {}
+    virtual RuntimeError Set () = 0;
+    virtual RuntimeError Get () = 0;
+    virtual ~Accessor() {}
+
+   public:
+    Parameters *target;
+  };
+
+  class StringAccessor : public Accessor {
+   public:
+    StringAccessor (Parameters *target) : Accessor(target) {}
+    std::string value;
+  };
+
+  class IntAccessor : public Accessor {
+   public:
+    IntAccessor (Parameters *target) : Accessor(target) {}
+    int value;
+  };
+
+  class LoggingLevelAccessor : public IntAccessor {
+   public:
+    LoggingLevelAccessor (Parameters *target) : IntAccessor(target) {}
+
+    RuntimeError Set () {
+      return target->engine->SetLoggingLevel(this->value);
+    }
+
+    RuntimeError Get () {
+      this->value = target->engine->GetLoggingLevel();
+      return RuntimeError ();
+    }
+  };
+
+  class LogIdAccessor : public StringAccessor {
+   public:
+    LogIdAccessor (Parameters *target) : StringAccessor(target) {}
+    RuntimeError Set () {
+      return target->engine->SetLogId(this->value);
+    }
+
+    RuntimeError Get () {
+      this->value = target->engine->GetLogId();
+      return RuntimeError ();
+    }
+  };
+
+  class IntraNumThreadsAccessor : public IntAccessor {
+   public:
+    IntraNumThreadsAccessor (Parameters *target) : IntAccessor(target) {}
+
+    RuntimeError Set () {
+      return target->engine->SetIntraNumThreads(this->value);
+    }
+
+    RuntimeError Get () {
+      this->value = target->engine->GetIntraNumThreads();
+      return RuntimeError ();
+    }
+  };
+
+  class GraphOptLevelAccessor : public IntAccessor {
+   public:
+    GraphOptLevelAccessor (Parameters *target) : IntAccessor(target) {}
+
+    RuntimeError Set () {
+      return target->engine->SetGraphOptLevel(this->value);
+    }
+
+    RuntimeError Get () {
+      this->value = target->engine->GetGraphOptLevel();
+      return RuntimeError ();
+    }
+  };
+
+  struct ParamDesc {
+    ParameterMeta meta;
+    std::shared_ptr<Accessor> accessor;
+  };
+
+  typedef std::unordered_map<std::string, ParamDesc> ParamMap;
+  const ParamMap parameter_map;
+
+  ParamDesc Validate (const std::string &in_parameter, int type,
+                      const std::string &stype, RuntimeError &error);
+
+};
+
+}  // namespace onnxrt
+}  // namespace r2i
+
+#endif //R2I_ONNXRT_PARAMETERS_H
diff --git a/r2i/onnxrt/prediction.cc b/r2i/onnxrt/prediction.cc
new file mode 100644
index 00000000..ebf4f115
--- /dev/null
+++ b/r2i/onnxrt/prediction.cc
@@ -0,0 +1,79 @@
+/* Copyright (C) 2020 RidgeRun, LLC (http://www.ridgerun.com)
+ * All Rights Reserved.
+ *
+ * The contents of this software are proprietary and confidential to RidgeRun,
+ * LLC.  No part of this program may be photocopied, reproduced or translated
+ * into another programming language without prior written consent of
+ * RidgeRun, LLC.  The user is free to modify the source code after obtaining
+ * a software license from RidgeRun.  All source code changes must be provided
+ * back to RidgeRun without any encumbrance.
+*/
+
+#include "r2i/onnxrt/prediction.h"
+
+#include <cstring>
+
+namespace r2i {
+namespace onnxrt {
+
+Prediction::Prediction ():
+  output_data(nullptr), tensor_size(0) {
+}
+
+Prediction::~Prediction () {
+}
+
+RuntimeError Prediction::SetTensorValues(float *output_data, int data_size) {
+  RuntimeError error;
+
+  if (nullptr == output_data) {
+    error.Set (RuntimeError::Code::NULL_PARAMETER,
+               "Invalid output tensor values passed to prediction");
+    return error;
+  }
+
+  if (0 == data_size) {
+    error.Set (RuntimeError::Code::NULL_PARAMETER,
+               "Invalid tensor size passed to prediction");
+    return error;
+  }
+
+  this->tensor_size = data_size;
+
+  this->output_data = std::shared_ptr<float>(new float[this->tensor_size],
+                      std::default_delete<float[]>());
+
+  std::memcpy(this->output_data.get(), output_data,
+              this->tensor_size * sizeof(float));
+
+  return error;
+}
+
+double Prediction::At (unsigned int index,  r2i::RuntimeError &error) {
+  error.Clean ();
+
+  if (nullptr == this->output_data) {
+    error.Set (RuntimeError::Code::INVALID_FRAMEWORK_PARAMETER,
+               "Prediction was not properly initialized");
+    return 0;
+  }
+
+  unsigned int n_results =  this->GetResultSize();
+  if (n_results < index) {
+    error.Set (RuntimeError::Code::MEMORY_ERROR,
+               "Triying to access an non-existing index");
+    return 0;
+  }
+  return this->output_data.get()[index];
+}
+
+void *Prediction::GetResultData () {
+  return reinterpret_cast<void *>(this->output_data.get());
+}
+
+unsigned int Prediction::GetResultSize () {
+  return this->tensor_size;
+}
+
+}  // namespace onnxrt
+}  // namespace r2i
diff --git a/r2i/onnxrt/prediction.h b/r2i/onnxrt/prediction.h
new file mode 100644
index 00000000..4c00fc43
--- /dev/null
+++ b/r2i/onnxrt/prediction.h
@@ -0,0 +1,40 @@
+/* Copyright (C) 2020 RidgeRun, LLC (http://www.ridgerun.com)
+ * All Rights Reserved.
+ *
+ * The contents of this software are proprietary and confidential to RidgeRun,
+ * LLC.  No part of this program may be photocopied, reproduced or translated
+ * into another programming language without prior written consent of
+ * RidgeRun, LLC.  The user is free to modify the source code after obtaining
+ * a software license from RidgeRun.  All source code changes must be provided
+ * back to RidgeRun without any encumbrance.
+*/
+
+#ifndef R2I_ONNXRT_PREDICTION_H
+#define R2I_ONNXRT_PREDICTION_H
+
+#include <memory>
+
+#include <r2i/iprediction.h>
+#include <r2i/runtimeerror.h>
+
+namespace r2i {
+namespace onnxrt {
+
+class Prediction: public IPrediction {
+ public:
+  Prediction ();
+  ~Prediction ();
+  double At (unsigned int index,  r2i::RuntimeError &error) override;
+  void *GetResultData () override;
+  unsigned int GetResultSize () override;
+  RuntimeError SetTensorValues(float *output_data, int tensor_size);
+
+ private:
+  std::shared_ptr<float> output_data;
+  int tensor_size;
+};
+
+}  // namespace onnxrt
+}  // namespace r2i
+
+#endif  // R2I_ONNXRT_PREDICTION_H
diff --git a/r2i/tensorflow/frameworkfactory.cc b/r2i/tensorflow/frameworkfactory.cc
index 2a29ab99..ab54e2c0 100644
--- a/r2i/tensorflow/frameworkfactory.cc
+++ b/r2i/tensorflow/frameworkfactory.cc
@@ -53,6 +53,7 @@ r2i::FrameworkMeta FrameworkFactory::GetDescription (RuntimeError &error) {
   const FrameworkMeta meta {
     .code = r2i::FrameworkCode::TENSORFLOW,
     .name = "Tensorflow",
+    .label = "tensorflow",
     .description = "Google's TensorFlow",
     .version = TF_Version ()
   };
diff --git a/r2i/tensorrt/frameworkfactory.cc b/r2i/tensorrt/frameworkfactory.cc
index 3c6a0383..0f3fb21d 100644
--- a/r2i/tensorrt/frameworkfactory.cc
+++ b/r2i/tensorrt/frameworkfactory.cc
@@ -51,6 +51,7 @@ r2i::FrameworkMeta FrameworkFactory::GetDescription (RuntimeError &error) {
   const FrameworkMeta meta {
     .code = r2i::FrameworkCode::TENSORRT,
     .name = "TensorRT",
+    .label = "tensorrt",
     .description = "NVIDIA's TensorRT",
     .version = std::to_string(NV_TENSORRT_VERSION)
   };
diff --git a/r2i/tflite/frameworkfactory.cc b/r2i/tflite/frameworkfactory.cc
index 49cd1dd9..fa6a8b45 100644
--- a/r2i/tflite/frameworkfactory.cc
+++ b/r2i/tflite/frameworkfactory.cc
@@ -52,7 +52,8 @@ std::unique_ptr<r2i::IFrame> FrameworkFactory::MakeFrame (
 r2i::FrameworkMeta FrameworkFactory::GetDescription (RuntimeError &error) {
   const FrameworkMeta meta {
     .code = r2i::FrameworkCode::TFLITE,
-    .name = "tensorflow-lite",
+    .name = "TensorflowLite",
+    .label = "tflite",
     .description = "Google's TensorFlow Lite",
     .version = TFLITE_VERSION_STRING
   };
diff --git a/tests/unit/r2i/Makefile.am b/tests/unit/r2i/Makefile.am
index 925bb48f..75f11300 100644
--- a/tests/unit/r2i/Makefile.am
+++ b/tests/unit/r2i/Makefile.am
@@ -51,6 +51,7 @@ CLEANFILES = cpputest_*.xml
 
 DIST_SUBDIRS =                     \
         ncsdk                      \
+        onnxrt                     \
         tensorflow                 \
         tensorrt                   \
         tflite
@@ -60,6 +61,10 @@ if HAVE_NCSDK
 SUBDIRS += ncsdk
 endif
 
+if HAVE_ONNXRT
+SUBDIRS += onnxrt
+endif
+
 if HAVE_TENSORFLOW
 SUBDIRS += tensorflow
 endif
diff --git a/tests/unit/r2i/meson.build b/tests/unit/r2i/meson.build
index f6295fd5..109183f6 100644
--- a/tests/unit/r2i/meson.build
+++ b/tests/unit/r2i/meson.build
@@ -16,6 +16,10 @@ foreach t : lib_r2inference_tests
 
 endforeach
 
+if get_option('enable-onnxrt')
+  subdir('onnxrt')
+endif
+
 if get_option('enable-tensorflow')
   subdir('tensorflow')
 endif
diff --git a/tests/unit/r2i/onnxrt/Makefile.am b/tests/unit/r2i/onnxrt/Makefile.am
new file mode 100644
index 00000000..70faa49e
--- /dev/null
+++ b/tests/unit/r2i/onnxrt/Makefile.am
@@ -0,0 +1,60 @@
+# Copyright (C) 2020 RidgeRun, LLC (http://www.ridgerun.com)
+# All Rights Reserved.
+#
+# The contents of this software are proprietary and confidential to RidgeRun,
+# LLC.  No part of this program may be photocopied, reproduced or translated
+# into another programming language without prior written consent of
+# RidgeRun, LLC.  The user is free to modify the source code after obtaining
+# a software license from RidgeRun.  All source code changes must be provided
+# back to RidgeRun without any encumbrance.
+
+AM_DEFAULT_SOURCE_EXT = .cc
+
+if ENABLE_TESTS
+if HAVE_ONNXRT
+
+TESTS =                   \
+        engine            \
+        frame             \
+        frameworkfactory  \
+        loader            \
+        model             \
+        prediction
+
+check_PROGRAMS=$(TESTS)
+
+endif # HAVE_ONNXRT
+endif # ENABLE_TESTS
+
+if ENABLE_CODE_COVERAGE
+SINGLE_PROCESS=--single-process yes
+else
+SINGLE_PROCESS=
+endif
+
+LOG_DRIVER=$(top_builddir)/common/rr-test-driver.py $(SINGLE_PROCESS)
+
+AM_CXXFLAGS =                       \
+        $(RR_CXXFLAGS)              \
+        $(TESTS_CFLAGS)             \
+        $(ONNXRT_CFLAGS)            \
+        $(CODE_COVERAGE_CXXFLAGS)
+
+AM_CFLAGS =                         \
+        $(RR_CFLAGS)                \
+        $(TESTS_CFLAGS)             \
+        $(ONNXRT_CFLAGS)            \
+        $(CODE_COVERAGE_CFLAGS)
+
+AM_CPPFLAGS =                       \
+        $(RR_CPPFLAGS)              \
+        $(CODE_COVERAGE_CPPFLAGS)
+
+AM_LDFLAGS =                        \
+        $(RR_LIBS)                  \
+        $(ONNXRT_LIBS)              \
+        $(TESTS_LIBS)               \
+        $(CODE_COVERAGE_LIBS)       \
+        $(top_builddir)/r2i/libr2inference-@RR_PACKAGE_VERSION@.la
+
+CLEANFILES = cpputest_*.xml
diff --git a/tests/unit/r2i/onnxrt/engine.cc b/tests/unit/r2i/onnxrt/engine.cc
new file mode 100644
index 00000000..66ec4c02
--- /dev/null
+++ b/tests/unit/r2i/onnxrt/engine.cc
@@ -0,0 +1,421 @@
+/* Copyright (C) 2020 RidgeRun, LLC (http://www.ridgerun.com)
+ * All Rights Reserved.
+ *
+ * The contents of this software are proprietary and confidential to RidgeRun,
+ * LLC.  No part of this program may be photocopied, reproduced or translated
+ * into another programming language without prior written consent of
+ * RidgeRun, LLC.  The user is free to modify the source code after obtaining
+ * a software license from RidgeRun.  All source code changes must be provided
+ * back to RidgeRun without any encumbrance.
+*/
+
+#include <r2i/r2i.h>
+#include <r2i/onnxrt/engine.h>
+#include <r2i/onnxrt/frame.h>
+#include <r2i/onnxrt/model.h>
+
+#include <core/common/exceptions.h>
+#include <core/session/onnxruntime_cxx_api.h>
+
+#include <memory>
+
+#include <CppUTest/CommandLineTestRunner.h>
+#include <CppUTest/MemoryLeakDetectorNewMacros.h>
+#include <CppUTest/MemoryLeakDetectorMallocMacros.h>
+#include <CppUTest/TestHarness.h>
+
+#define FRAME_WIDTH  224
+#define FRAME_HEIGHT  224
+#define CHANNELS 3
+#define INVALID_FRAME_WIDTH  64
+#define INVALID_FRAME_HEIGHT  64
+#define INVALID_CHANNELS 1
+#define INPUT_NUMBER 1
+#define OUTPUT_NUMBER 1
+#define INVALID_INPUT_NUMBER 2
+#define BATCH_SIZE 1
+#define OUTPUT_SIZE 1000
+#define EXPECTED_OUT_TENSOR_VAL 0
+
+static bool null_input_name = false;
+static bool invalid_input_number = false;
+static bool get_input_number_fail = false;
+static bool invalid_frame = false;
+static bool session_create_fail = false;
+static bool session_run_fail = false;
+static bool session_null = false;
+static bool session_create_null_env = false;
+
+std::string dummy_string_input = "input";
+std::string dummy_string_output = "output";
+std::vector<float> dummy_output_tensor_values(OUTPUT_SIZE);
+std::vector<float> dummy_frame_data(CHANNELS *FRAME_WIDTH *FRAME_HEIGHT);
+
+/* To simulate exceptions thrown by onnxruntime API. Exceptions in this
+ * API are derived from std::exception.
+ */
+class OnnxrtExcep : public std::exception {
+  virtual const char *what() const throw() { return "ONNXRT exception thrown"; }
+} onnxrtexcep;
+
+class MockModel : public r2i::IModel {
+  r2i::RuntimeError Start (const std::string &name) override {
+    r2i::RuntimeError error;
+    return error;
+  }
+};
+
+namespace r2i {
+
+int ImageFormat::GetNumPlanes () {
+  if (invalid_frame) {
+    return INVALID_CHANNELS;
+  }
+  return CHANNELS;
+}
+
+namespace onnxrt {
+
+Frame::Frame () {}
+void *Frame::GetData () {
+  return dummy_frame_data.data();
+}
+
+int Frame::GetWidth () {
+  if (invalid_frame) {
+    return INVALID_FRAME_WIDTH;
+  }
+
+  return FRAME_WIDTH;
+}
+
+int Frame::GetHeight () {
+  if (invalid_frame) {
+    return INVALID_FRAME_HEIGHT;
+  }
+
+  return FRAME_HEIGHT;
+}
+
+void Engine::CreateEnv() {
+
+}
+
+void Engine::CreateSessionOptions() {
+
+}
+
+void Engine::CreateSession(const void *model_data,
+                           size_t model_data_size,
+                           RuntimeError &error) {
+  if (session_create_null_env) {
+    error.Set (RuntimeError::Code:: NULL_PARAMETER,
+               "Received null Ort::Env pointer");
+  }
+
+  if (session_create_fail) {
+    throw onnxrtexcep;
+  }
+}
+
+size_t Engine::GetSessionInputCount(std::shared_ptr<Ort::Session> session,
+                                    RuntimeError &error) {
+  if (session_null) {
+    error.Set (RuntimeError::Code:: NULL_PARAMETER,
+               "Received null session pointer");
+    return 0;
+  }
+  if (invalid_input_number) {
+    return INVALID_INPUT_NUMBER;
+  }
+  if (get_input_number_fail) {
+    throw onnxrtexcep;
+  }
+  return INPUT_NUMBER;
+}
+
+size_t Engine::GetSessionOutputCount(std::shared_ptr<Ort::Session> session,
+                                     RuntimeError &error) {
+  if (session_null) {
+    error.Set (RuntimeError::Code:: NULL_PARAMETER,
+               "Received null session pointer");
+    return 0;
+  }
+  return OUTPUT_NUMBER;
+}
+
+std::vector<int64_t> Engine::GetSessionInputNodeDims(
+  std::shared_ptr<Ort::Session> session, size_t index, RuntimeError &error) {
+  std::vector<int64_t> vect{ BATCH_SIZE, FRAME_HEIGHT, FRAME_WIDTH, CHANNELS };
+  if (session_null) {
+    error.Set (RuntimeError::Code:: NULL_PARAMETER,
+               "Received null session pointer");
+  }
+  return vect;
+}
+
+size_t Engine::GetSessionOutputSize(std::shared_ptr<Ort::Session> session,
+                                    size_t index, RuntimeError &error) {
+  if (session_null) {
+    error.Set (RuntimeError::Code:: NULL_PARAMETER,
+               "Received null session pointer");
+    return 0;
+  }
+  return OUTPUT_SIZE;
+}
+
+const char *Engine::GetSessionInputName(std::shared_ptr<Ort::Session> session,
+                                        size_t index, OrtAllocator *allocator, RuntimeError &error) {
+  if (session_null) {
+    error.Set (RuntimeError::Code:: NULL_PARAMETER,
+               "Received null session pointer");
+    return dummy_string_input.c_str();
+  }
+  if (null_input_name) {
+    throw onnxrtexcep;
+  }
+  return dummy_string_input.c_str();
+}
+
+const char *Engine::GetSessionOutputName(std::shared_ptr<Ort::Session> session,
+    size_t index, OrtAllocator *allocator, RuntimeError &error) {
+  if (session_null) {
+    error.Set (RuntimeError::Code:: NULL_PARAMETER,
+               "Received null session pointer");
+    return dummy_string_input.c_str();
+  }
+  if (null_input_name) {
+    throw onnxrtexcep;
+  }
+  return dummy_string_output.c_str();
+}
+
+/* Mock for wrapper of Ort::Session::Run method */
+float *Engine::SessionRun (std::shared_ptr<Ort::Session> session,
+                           std::shared_ptr<Frame> frame,
+                           size_t input_image_size,
+                           std::vector<int64_t> input_node_dims,
+                           std::vector<Ort::Value> &output_tensor,
+                           RuntimeError &error) {
+  if (session_run_fail) {
+    throw onnxrtexcep;
+  }
+
+  /* Fill data with dummy values */
+  for (unsigned int i = 0; i < OUTPUT_SIZE; i++)
+    dummy_output_tensor_values[i] = (float)i / (OUTPUT_SIZE + 1);
+
+  return dummy_output_tensor_values.data();
+}
+
+}
+}
+
+TEST_GROUP (OnnxrtEngine) {
+  std::shared_ptr<r2i::onnxrt::Engine> engine;
+  std::shared_ptr<r2i::IModel> model;
+  std::shared_ptr<r2i::IModel> inc_model;
+  std::shared_ptr<r2i::IFrame> frame;
+
+  void setup () {
+    model = std::make_shared<r2i::onnxrt::Model> ();
+    inc_model = std::make_shared<MockModel> ();
+    engine = std::make_shared<r2i::onnxrt::Engine> ();
+    frame = std::make_shared<r2i::onnxrt::Frame> ();
+  }
+};
+
+TEST (OnnxrtEngine, SetModel) {
+  r2i::RuntimeError error;
+
+  error = engine->SetModel (model);
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+}
+
+TEST (OnnxrtEngine, SetModelNull) {
+  r2i::RuntimeError error;
+
+  error = engine->SetModel (nullptr);
+  LONGS_EQUAL (r2i::RuntimeError::Code::NULL_PARAMETER, error.GetCode ());
+}
+
+TEST (OnnxrtEngine, SetModelInvalid) {
+  r2i::RuntimeError error;
+
+  error = engine->SetModel (inc_model);
+  LONGS_EQUAL (r2i::RuntimeError::Code::FRAMEWORK_ERROR, error.GetCode ());
+}
+
+TEST (OnnxrtEngine, NullInputNameException) {
+  r2i::RuntimeError error;
+  null_input_name = true;
+
+  error = engine->SetModel (model);
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+
+  error = engine->Start ();
+  LONGS_EQUAL (r2i::RuntimeError::Code::FRAMEWORK_ERROR, error.GetCode ());
+}
+
+TEST (OnnxrtEngine, CreateSessionNullEnvError) {
+  r2i::RuntimeError error;
+  session_create_null_env = true;
+
+  error = engine->SetModel (model);
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+
+  error = engine->Start ();
+  LONGS_EQUAL (r2i::RuntimeError::Code::NULL_PARAMETER, error.GetCode ());
+}
+
+TEST (OnnxrtEngine, CreateSessionException) {
+  r2i::RuntimeError error;
+  session_create_fail = true;
+
+  error = engine->SetModel (model);
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+
+  error = engine->Start ();
+  LONGS_EQUAL (r2i::RuntimeError::Code::FRAMEWORK_ERROR, error.GetCode ());
+}
+
+TEST (OnnxrtEngine, GetInfoSessionNull) {
+  r2i::RuntimeError error;
+  session_null = true;
+
+  error = engine->SetModel (model);
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+
+  error = engine->Start ();
+  LONGS_EQUAL (r2i::RuntimeError::Code::NULL_PARAMETER, error.GetCode ());
+}
+
+TEST (OnnxrtEngine, StartEngineEmpty) {
+  r2i::RuntimeError error;
+
+  error = engine->Start ();
+  LONGS_EQUAL (r2i::RuntimeError::Code::NULL_PARAMETER, error.GetCode ());
+}
+
+TEST (OnnxrtEngine, StartEngineTwice) {
+  r2i::RuntimeError error;
+
+  error = engine->SetModel (model);
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+
+  error = engine->Start ();
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+
+  error = engine->Start ();
+  LONGS_EQUAL (r2i::RuntimeError::Code::WRONG_ENGINE_STATE, error.GetCode ());
+}
+
+TEST (OnnxrtEngine, StartStopEngine) {
+  r2i::RuntimeError error;
+
+  error = engine->SetModel (model);
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+
+  error = engine->Start ();
+  error = engine->Stop ();
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+}
+
+TEST (OnnxrtEngine, StopEngine) {
+  r2i::RuntimeError error;
+
+  error = engine->SetModel (model);
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+
+  error = engine->Stop ();
+  LONGS_EQUAL (r2i::RuntimeError::Code::WRONG_ENGINE_STATE, error.GetCode ());
+}
+
+TEST (OnnxrtEngine, StopStopEngine) {
+  r2i::RuntimeError error;
+
+  error = engine->SetModel (model);
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+
+  error = engine->Stop ();
+  error = engine->Stop ();
+  LONGS_EQUAL (r2i::RuntimeError::Code::WRONG_ENGINE_STATE, error.GetCode ());
+}
+
+TEST (OnnxrtEngine, GetInputNumberException) {
+  r2i::RuntimeError error;
+  get_input_number_fail = true;
+
+  error = engine->SetModel (model);
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+
+  error = engine->Start ();
+  LONGS_EQUAL (r2i::RuntimeError::Code::FRAMEWORK_ERROR, error.GetCode ());
+}
+
+TEST (OnnxrtEngine, InvalidInputNumber) {
+  r2i::RuntimeError error;
+  invalid_input_number = true;
+
+  error = engine->SetModel (model);
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+
+  error = engine->Start ();
+  LONGS_EQUAL (r2i::RuntimeError::Code::INCOMPATIBLE_MODEL, error.GetCode ());
+}
+
+TEST (OnnxrtEngine, EnginePredictInvalidFrame) {
+  r2i::RuntimeError error;
+  invalid_frame = true;
+  std::shared_ptr<r2i::IPrediction> prediction;
+
+  error = engine->SetModel (model);
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+
+  error = engine->Start ();
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+
+  prediction = engine->Predict (frame, error);
+  LONGS_EQUAL (r2i::RuntimeError::Code::INVALID_FRAMEWORK_PARAMETER,
+               error.GetCode ());
+}
+
+TEST (OnnxrtEngine, EngineSessionRunFail) {
+  r2i::RuntimeError error;
+  std::shared_ptr<r2i::IPrediction> prediction;
+  session_run_fail = true;
+
+  error = engine->SetModel (model);
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+
+  error = engine->Start ();
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+
+  prediction = engine->Predict (frame, error);
+  LONGS_EQUAL (r2i::RuntimeError::Code::FRAMEWORK_ERROR, error.GetCode ());
+}
+
+TEST (OnnxrtEngine, EnginePredictSuccess) {
+  r2i::RuntimeError error;
+  std::shared_ptr<r2i::IPrediction> prediction;
+
+  error = engine->SetModel (model);
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+
+  error = engine->Start ();
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+
+  prediction = engine->Predict (frame, error);
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+
+  auto prediction_onnxrt =
+    std::dynamic_pointer_cast<r2i::onnxrt::Prediction, r2i::IPrediction>
+    (prediction);
+
+  LONGS_EQUAL (prediction_onnxrt->At(0, error), EXPECTED_OUT_TENSOR_VAL);
+}
+
+int main (int ac, char **av) {
+  MemoryLeakWarningPlugin::turnOffNewDeleteOverloads();
+  return CommandLineTestRunner::RunAllTests (ac, av);
+}
diff --git a/tests/unit/r2i/onnxrt/frame.cc b/tests/unit/r2i/onnxrt/frame.cc
new file mode 100644
index 00000000..70082784
--- /dev/null
+++ b/tests/unit/r2i/onnxrt/frame.cc
@@ -0,0 +1,113 @@
+/* Copyright (C) 2020 RidgeRun, LLC (http://www.ridgerun.com)
+ * All Rights Reserved.
+ *
+ * The contents of this software are proprietary and confidential to RidgeRun,
+ * LLC.  No part of this program may be photocopied, reproduced or translated
+ * into another programming language without prior written consent of
+ * RidgeRun, LLC.  The user is free to modify the source code after obtaining
+ * a software license from RidgeRun.  All source code changes must be provided
+ * back to RidgeRun without any encumbrance.
+*/
+
+#include <r2i/r2i.h>
+#include <r2i/onnxrt/frame.h>
+
+#include <core/session/onnxruntime_cxx_api.h>
+
+#include <CppUTest/CommandLineTestRunner.h>
+#include <CppUTest/MemoryLeakDetectorNewMacros.h>
+#include <CppUTest/MemoryLeakDetectorMallocMacros.h>
+#include <CppUTest/TestHarness.h>
+
+#define FRAME_WIDTH  2
+#define FRAME_HEIGHT  2
+
+TEST_GROUP (OnnxrtFrame) {
+  std::shared_ptr<r2i::onnxrt::Frame> frame =
+    std::make_shared<r2i::onnxrt::Frame>();
+  std::shared_ptr<r2i::ImageFormat> format =
+    std::make_shared<r2i::ImageFormat>(r2i::ImageFormat::Id::RGB);
+  int width = FRAME_WIDTH;
+  int height = FRAME_HEIGHT;
+  float data[4] = {0.1, 0.2, 0.3, 0.4};
+};
+
+TEST (OnnxrtFrame, FrameConfigure) {
+  r2i::RuntimeError error;
+
+  error = frame->Configure(data, width, height, format->GetId());
+
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode());
+}
+
+TEST (OnnxrtFrame, FrameConfigureNullData) {
+  r2i::RuntimeError error;
+
+  error = frame->Configure(nullptr, width, height, format->GetId());
+
+  LONGS_EQUAL (r2i::RuntimeError::Code::NULL_PARAMETER, error.GetCode());
+}
+
+TEST (OnnxrtFrame, FrameConfigureNegativeWidth) {
+  r2i::RuntimeError error;
+
+  error = frame->Configure(data, -1, height, format->GetId());
+
+  LONGS_EQUAL (r2i::RuntimeError::Code::WRONG_API_USAGE, error.GetCode());
+}
+
+TEST (OnnxrtFrame, FrameConfigureNegativeHeight) {
+  r2i::RuntimeError error;
+
+  error = frame->Configure(data, width, -1, format->GetId());
+
+  LONGS_EQUAL (r2i::RuntimeError::Code::WRONG_API_USAGE, error.GetCode());
+}
+
+TEST (OnnxrtFrame, FrameGetData) {
+  r2i::RuntimeError error;
+  void *local_data;
+
+  error = frame->Configure(data, width, height, format->GetId());
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode());
+
+  local_data = frame->GetData();
+  POINTERS_EQUAL (data, local_data);
+}
+
+TEST (OnnxrtFrame, FrameGetWidth) {
+  r2i::RuntimeError error;
+  int local_width;
+
+  error = frame->Configure(data, width, height, format->GetId());
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode());
+
+  local_width = frame->GetWidth();
+  LONGS_EQUAL (width, local_width);
+}
+
+TEST (OnnxrtFrame, FrameGetHeight) {
+  r2i::RuntimeError error;
+  int local_height;
+
+  error = frame->Configure(data, width, height, format->GetId());
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode());
+
+  local_height = frame->GetHeight();
+  LONGS_EQUAL (height, local_height);
+}
+
+TEST (OnnxrtFrame, FrameGetFormat) {
+  r2i::RuntimeError error;
+  r2i::ImageFormat local_format;
+
+  error = frame->Configure(data, width, height, format->GetId());
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode());
+
+  local_format = frame->GetFormat();
+  LONGS_EQUAL (format->GetId(), local_format.GetId());
+}
+
+int main (int ac, char **av) {
+  return CommandLineTestRunner::RunAllTests (ac, av);
+}
diff --git a/tests/unit/r2i/onnxrt/frameworkfactory.cc b/tests/unit/r2i/onnxrt/frameworkfactory.cc
new file mode 100644
index 00000000..b9bd62ad
--- /dev/null
+++ b/tests/unit/r2i/onnxrt/frameworkfactory.cc
@@ -0,0 +1,54 @@
+/* Copyright (C) 2018-2020 RidgeRun, LLC (http://www.ridgerun.com)
+ * All Rights Reserved.
+ *
+ * The contents of this software are proprietary and confidential to RidgeRun,
+ * LLC.  No part of this program may be photocopied, reproduced or translated
+ * into another programming language without prior written consent of
+ * RidgeRun, LLC.  The user is free to modify the source code after obtaining
+ * a software license from RidgeRun.  All source code changes must be provided
+ * back to RidgeRun without any encumbrance.
+*/
+
+#include <r2i/iframeworkfactory.h>
+#include <r2i/onnxrt/frameworkfactory.h>
+
+#include <memory>
+
+#include <CppUTest/CommandLineTestRunner.h>
+#include <CppUTest/MemoryLeakDetectorNewMacros.h>
+#include <CppUTest/MemoryLeakDetectorMallocMacros.h>
+#include <CppUTest/TestHarness.h>
+
+#include <r2i/onnxrt/loader.h>
+
+TEST_GROUP (OnnxFrameworkFactory) {
+};
+
+TEST (OnnxFrameworkFactory, ValidFactory) {
+  r2i::RuntimeError error;
+  std::shared_ptr<r2i::IFrameworkFactory> factory;
+
+  factory = r2i::IFrameworkFactory::MakeFactory(r2i::FrameworkCode::ONNXRT,
+            error);
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+
+  /* Is this a valid ONNX Runtime factory? */
+  auto ufactory =
+    std::dynamic_pointer_cast<r2i::onnxrt::FrameworkFactory, r2i::IFrameworkFactory>
+    (factory);
+  CHECK (nullptr != ufactory);
+
+  /* Test for loader */
+  std::shared_ptr<r2i::ILoader> loader = factory->MakeLoader(error);
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+  auto uloader =
+    std::dynamic_pointer_cast<r2i::onnxrt::Loader, r2i::ILoader> (loader);
+  CHECK (nullptr != uloader);
+
+  /* Test for meta */
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+}
+
+int main (int ac, char **av) {
+  return CommandLineTestRunner::RunAllTests (ac, av);
+}
diff --git a/tests/unit/r2i/onnxrt/loader.cc b/tests/unit/r2i/onnxrt/loader.cc
new file mode 100644
index 00000000..cb10d84a
--- /dev/null
+++ b/tests/unit/r2i/onnxrt/loader.cc
@@ -0,0 +1,60 @@
+/* Copyright (C) 2020 RidgeRun, LLC (http://www.ridgerun.com)
+ * All Rights Reserved.
+ *
+ * The contents of this software are proprietary and confidential to RidgeRun,
+ * LLC.  No part of this program may be photocopied, reproduced or translated
+ * into another programming language without prior written consent of
+ * RidgeRun, LLC.  The user is free to modify the source code after obtaining
+ * a software license from RidgeRun.  All source code changes must be provided
+ * back to RidgeRun without any encumbrance.
+*/
+
+#include <r2i/onnxrt/loader.h>
+
+#include <memory>
+
+#include <CppUTest/CommandLineTestRunner.h>
+#include <CppUTest/MemoryLeakDetectorMallocMacros.h>
+#include <CppUTest/MemoryLeakDetectorNewMacros.h>
+#include <CppUTest/TestHarness.h>
+
+#include <r2i/r2i.h>
+
+TEST_GROUP(OnnxrtLoader) {
+  r2i::RuntimeError error;
+  std::shared_ptr<r2i::onnxrt::Loader> loader =
+    std::make_shared<r2i::onnxrt::Loader>();
+
+  void setup() {
+    error.Clean();
+  }
+};
+
+TEST(OnnxrtLoader, WrongApiUsage) {
+  std::string empty_string = "";
+
+  auto model = loader->Load(empty_string, error);
+
+  CHECK_TEXT(error.IsError(), error.GetDescription().c_str());
+  LONGS_EQUAL(r2i::RuntimeError::Code::WRONG_API_USAGE, error.GetCode());
+}
+
+TEST(OnnxrtLoader, UnableToOpenFile) {
+  std::string non_existent_file = "resources/squeezenet_typo.onnx";
+
+  auto model = loader->Load(non_existent_file, error);
+
+  CHECK_TEXT(error.IsError(), error.GetDescription().c_str());
+  LONGS_EQUAL(r2i::RuntimeError::Code::FILE_ERROR, error.GetCode());
+}
+
+TEST(OnnxrtLoader, LoadValidFile) {
+  std::string model_path = "resources/squeezenet.onnx";
+  auto model = loader->Load(model_path, error);
+
+  LONGS_EQUAL(r2i::RuntimeError::Code::EOK, error.GetCode());
+}
+
+int main(int ac, char **av) {
+  return CommandLineTestRunner::RunAllTests(ac, av);
+}
diff --git a/tests/unit/r2i/onnxrt/meson.build b/tests/unit/r2i/onnxrt/meson.build
new file mode 100644
index 00000000..3d879d8c
--- /dev/null
+++ b/tests/unit/r2i/onnxrt/meson.build
@@ -0,0 +1,29 @@
+subdir('resources')
+
+lib_onnxrt_tests = [
+  ['engine.cc'],
+  ['frame.cc'],
+  ['frameworkfactory.cc'],
+  ['loader.cc'],
+  ['model.cc'],
+  ['parameters.cc'],
+  ['prediction.cc'],
+]
+
+# Build and run tests
+foreach t : lib_onnxrt_tests
+  fname = t[0]
+  test_name = fname.split('.')[0].underscorify()
+
+  exe = executable(test_name, fname,
+      include_directories : [configinc],
+      dependencies : [r2inference_lib_dep, tests_dep, lib_onnxrt_dep],
+  )
+
+  # Run tests
+  test(test_name, exe,
+       args : '-p',
+       timeout : 60,
+       workdir : meson.current_build_dir())
+
+endforeach
diff --git a/tests/unit/r2i/onnxrt/model.cc b/tests/unit/r2i/onnxrt/model.cc
new file mode 100644
index 00000000..120e2f03
--- /dev/null
+++ b/tests/unit/r2i/onnxrt/model.cc
@@ -0,0 +1,51 @@
+/* Copyright (C) 2020 RidgeRun, LLC (http://www.ridgerun.com)
+ * All Rights Reserved.
+ *
+ * The contents of this software are proprietary and confidential to RidgeRun,
+ * LLC.  No part of this program may be photocopied, reproduced or translated
+ * into another programming language without prior written consent of
+ * RidgeRun, LLC.  The user is free to modify the source code after obtaining
+ * a software license from RidgeRun.  All source code changes must be provided
+ * back to RidgeRun without any encumbrance.
+*/
+
+#include <r2i/onnxrt/model.h>
+
+#include <memory>
+
+#include <CppUTest/CommandLineTestRunner.h>
+#include <CppUTest/TestHarness.h>
+
+#include <r2i/r2i.h>
+
+#define SIZE 1
+
+TEST_GROUP(OnnxrtModel) {
+  r2i::RuntimeError error;
+  r2i::onnxrt::Model model;
+  std::shared_ptr<char> model_data;
+
+  void setup() {
+    error.Clean();
+    model = r2i::onnxrt::Model();
+  }
+};
+
+TEST(OnnxrtModel, SetModelNull) {
+  error = model.SetOnnxrtModel(nullptr, 0);
+  LONGS_EQUAL(r2i::RuntimeError::Code::NULL_PARAMETER, error.GetCode());
+}
+
+TEST(OnnxrtModel, SetModelAllocated) {
+  model_data = std::shared_ptr<char>(new char[SIZE],
+                                     std::default_delete<char[]>());
+  error = model.SetOnnxrtModel(std::static_pointer_cast<void>(model_data), SIZE);
+  LONGS_EQUAL(r2i::RuntimeError::Code::EOK, error.GetCode());
+  POINTERS_EQUAL((void *)model_data.get(), (void *)model.GetOnnxrtModel().get());
+  LONGS_EQUAL(SIZE, model.GetOnnxrtModelSize());
+}
+
+int main(int ac, char **av) {
+  return CommandLineTestRunner::RunAllTests(ac, av);
+}
+
diff --git a/tests/unit/r2i/onnxrt/parameters.cc b/tests/unit/r2i/onnxrt/parameters.cc
new file mode 100644
index 00000000..cf37ac35
--- /dev/null
+++ b/tests/unit/r2i/onnxrt/parameters.cc
@@ -0,0 +1,435 @@
+/* Copyright (C) 2020 RidgeRun, LLC (http://www.ridgerun.com)
+ * All Rights Reserved.
+ *
+ * The contents of this software are proprietary and confidential to RidgeRun,
+ * LLC.  No part of this program may be photocopied, reproduced or translated
+ * into another programming language without prior written consent of
+ * RidgeRun, LLC.  The user is free to modify the source code after obtaining
+ * a software license from RidgeRun.  All source code changes must be provided
+ * back to RidgeRun without any encumbrance.
+*/
+
+#include <r2i/r2i.h>
+#include <r2i/onnxrt/engine.h>
+#include <r2i/onnxrt/model.h>
+#include <r2i/onnxrt/parameters.h>
+
+#include <CppUTest/CommandLineTestRunner.h>
+#include <CppUTest/TestHarness.h>
+
+namespace mock {
+class Model : public r2i::IModel {
+ public:
+  Model () {}
+  r2i::RuntimeError Start (const std::string &name) {
+    return r2i::RuntimeError();
+  }
+};
+
+class Engine : public r2i::IEngine {
+ public:
+  r2i::RuntimeError Start () {
+    return r2i::RuntimeError();
+  };
+  r2i::RuntimeError Stop () {
+    return r2i::RuntimeError();
+  };
+  r2i::RuntimeError SetModel (std::shared_ptr<r2i::IModel> in_model) {
+    return r2i::RuntimeError();
+  };
+  virtual std::shared_ptr<r2i::IPrediction> Predict (std::shared_ptr<r2i::IFrame>
+      in_frame, r2i::RuntimeError &error) { return nullptr; }
+};
+}
+
+namespace r2i {
+namespace onnxrt {
+
+Engine::Engine ()  { }
+RuntimeError Engine::Start () {
+  RuntimeError error;
+  this->state = State::STARTED;
+  return error;
+}
+
+}
+}
+
+TEST_GROUP (OnnxrtParameters) {
+};
+
+TEST (OnnxrtParameters, ConfigureIncompatibleEngine) {
+  r2i::RuntimeError error;
+  r2i::onnxrt::Parameters parameters;
+
+  std::shared_ptr<r2i::IEngine> engine(new mock::Engine);
+  std::shared_ptr<r2i::IModel> model(new r2i::onnxrt::Model);
+
+  error = parameters.Configure(engine, model);
+
+  CHECK_TEXT (error.IsError(), error.GetDescription().c_str());
+  LONGS_EQUAL (r2i::RuntimeError::Code::INCOMPATIBLE_ENGINE, error.GetCode ());
+}
+
+TEST (OnnxrtParameters, ConfigureIncompatibleModel) {
+  r2i::RuntimeError error;
+  r2i::onnxrt::Parameters parameters;
+
+  std::shared_ptr<r2i::IEngine> engine(new r2i::onnxrt::Engine);
+  std::shared_ptr<r2i::IModel> model(new mock::Model);
+
+  error = parameters.Configure(engine, model);
+
+  CHECK_TEXT (error.IsError(), error.GetDescription().c_str());
+  LONGS_EQUAL (r2i::RuntimeError::Code::INCOMPATIBLE_MODEL, error.GetCode ());
+}
+
+TEST (OnnxrtParameters, ConfigureNullEngine) {
+  r2i::RuntimeError error;
+  r2i::onnxrt::Parameters parameters;
+
+  std::shared_ptr<r2i::IModel> model(new r2i::onnxrt::Model);
+
+  error = parameters.Configure(nullptr, model);
+
+  CHECK_TEXT (error.IsError(), error.GetDescription().c_str());
+  LONGS_EQUAL (r2i::RuntimeError::Code::NULL_PARAMETER, error.GetCode ());
+}
+
+TEST (OnnxrtParameters, ConfigureNullModel) {
+  r2i::RuntimeError error;
+  r2i::onnxrt::Parameters parameters;
+
+  std::shared_ptr<r2i::IEngine> engine(new r2i::onnxrt::Engine);
+
+  error = parameters.Configure(engine, nullptr);
+
+  CHECK_TEXT (error.IsError(), error.GetDescription().c_str());
+  LONGS_EQUAL (r2i::RuntimeError::Code::NULL_PARAMETER, error.GetCode ());
+}
+
+TEST (OnnxrtParameters, ConfigureSuccess) {
+  r2i::RuntimeError error;
+  r2i::onnxrt::Parameters parameters;
+
+  std::shared_ptr<r2i::IEngine> engine(new r2i::onnxrt::Engine);
+  std::shared_ptr<r2i::IModel> model(new r2i::onnxrt::Model);
+
+  error = parameters.Configure(engine, model);
+
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+}
+
+TEST (OnnxrtParameters, SetAndGetModel) {
+  r2i::RuntimeError error;
+  r2i::onnxrt::Parameters parameters;
+
+  std::shared_ptr<r2i::IEngine> engine(new r2i::onnxrt::Engine);
+  std::shared_ptr<r2i::IModel> model(new r2i::onnxrt::Model);
+
+  error = parameters.Configure(engine, model);
+
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+
+  std::shared_ptr<r2i::IModel> internalModel = parameters.GetModel();
+
+  POINTERS_EQUAL(internalModel.get(), model.get());
+}
+
+TEST (OnnxrtParameters, SetAndGetEngine) {
+  r2i::RuntimeError error;
+  r2i::onnxrt::Parameters parameters;
+
+  std::shared_ptr<r2i::IEngine> engine(new r2i::onnxrt::Engine);
+  std::shared_ptr<r2i::IModel> model(new r2i::onnxrt::Model);
+
+  error = parameters.Configure(engine, model);
+
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+
+  std::shared_ptr<r2i::IEngine> internalEngine = parameters.GetEngine();
+
+  POINTERS_EQUAL(internalEngine.get(), engine.get());
+}
+
+TEST (OnnxrtParameters, SetUndefinedIntegerParameter) {
+  r2i::RuntimeError error;
+  r2i::onnxrt::Parameters parameters;
+  int value;
+
+  std::shared_ptr<r2i::IEngine> engine(new r2i::onnxrt::Engine);
+  std::shared_ptr<r2i::IModel> model(new r2i::onnxrt::Model);
+
+  error = parameters.Configure(engine, model);
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+
+  value = 0;
+  error = parameters.Set("undefined-parameter", value);
+  LONGS_EQUAL (r2i::RuntimeError::Code::INVALID_FRAMEWORK_PARAMETER,
+               error.GetCode ());
+}
+
+TEST (OnnxrtParameters, GetUndefinedIntegerParameter) {
+  r2i::RuntimeError error;
+  r2i::onnxrt::Parameters parameters;
+  int value;
+
+  std::shared_ptr<r2i::IEngine> engine(new r2i::onnxrt::Engine);
+  std::shared_ptr<r2i::IModel> model(new r2i::onnxrt::Model);
+
+  error = parameters.Configure(engine, model);
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+
+  error = parameters.Get("undefined-parameter", value);
+  LONGS_EQUAL (r2i::RuntimeError::Code::INVALID_FRAMEWORK_PARAMETER,
+               error.GetCode ());
+}
+
+TEST (OnnxrtParameters, SetUndefinedStringParameter) {
+  r2i::RuntimeError error;
+  r2i::onnxrt::Parameters parameters;
+  std::string value;
+
+  std::shared_ptr<r2i::IEngine> engine(new r2i::onnxrt::Engine);
+  std::shared_ptr<r2i::IModel> model(new r2i::onnxrt::Model);
+
+  error = parameters.Configure(engine, model);
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+
+  value = "test";
+  error = parameters.Set("undefined-parameter", value);
+  LONGS_EQUAL (r2i::RuntimeError::Code::INVALID_FRAMEWORK_PARAMETER,
+               error.GetCode ());
+}
+
+TEST (OnnxrtParameters, GetUndefinedStringParameter) {
+  r2i::RuntimeError error;
+  r2i::onnxrt::Parameters parameters;
+  std::string value;
+
+  std::shared_ptr<r2i::IEngine> engine(new r2i::onnxrt::Engine);
+  std::shared_ptr<r2i::IModel> model(new r2i::onnxrt::Model);
+
+  error = parameters.Configure(engine, model);
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+
+  error = parameters.Get("undefined-parameter", value);
+  LONGS_EQUAL (r2i::RuntimeError::Code::INVALID_FRAMEWORK_PARAMETER,
+               error.GetCode ());
+}
+
+TEST (OnnxrtParameters, SetAndGetLogId) {
+  r2i::RuntimeError error;
+  r2i::onnxrt::Parameters parameters;
+  std::string in_value;
+  std::string out_value;
+
+  std::shared_ptr<r2i::IEngine> engine(new r2i::onnxrt::Engine);
+  std::shared_ptr<r2i::IModel> model(new r2i::onnxrt::Model);
+
+  error = parameters.Configure(engine, model);
+
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+
+  /* Value different from the default */
+  in_value = "test";
+  error = parameters.Set("log-id", in_value);
+
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+
+  error = parameters.Get("log-id", out_value);
+
+  STRCMP_EQUAL(in_value.c_str(), out_value.c_str());
+}
+
+TEST (OnnxrtParameters, SetAndGetLoggingLevel) {
+  r2i::RuntimeError error;
+  r2i::onnxrt::Parameters parameters;
+  int in_value;
+  int out_value;
+
+  std::shared_ptr<r2i::IEngine> engine(new r2i::onnxrt::Engine);
+  std::shared_ptr<r2i::IModel> model(new r2i::onnxrt::Model);
+
+  error = parameters.Configure(engine, model);
+
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+
+  /* Value different from the default */
+  in_value = 0;
+  error = parameters.Set("logging-level", in_value);
+
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+
+  error = parameters.Get("logging-level", out_value);
+
+  LONGS_EQUAL(in_value, out_value);
+}
+
+TEST (OnnxrtParameters, SetAndGetIntraNumThreads) {
+  r2i::RuntimeError error;
+  r2i::onnxrt::Parameters parameters;
+  int in_value;
+  int out_value;
+
+  std::shared_ptr<r2i::IEngine> engine(new r2i::onnxrt::Engine);
+  std::shared_ptr<r2i::IModel> model(new r2i::onnxrt::Model);
+
+  error = parameters.Configure(engine, model);
+
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+
+  /* Value different from the default */
+  in_value = 0;
+  error = parameters.Set("intra-num-threads", in_value);
+
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+
+  error = parameters.Get("intra-num-threads", out_value);
+
+  LONGS_EQUAL(in_value, out_value);
+}
+
+TEST (OnnxrtParameters, SetAndGetGraphOptLevel) {
+  r2i::RuntimeError error;
+  r2i::onnxrt::Parameters parameters;
+  int in_value;
+  int out_value;
+
+  std::shared_ptr<r2i::IEngine> engine(new r2i::onnxrt::Engine);
+  std::shared_ptr<r2i::IModel> model(new r2i::onnxrt::Model);
+
+  error = parameters.Configure(engine, model);
+
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+
+  /* Value different from the default */
+  in_value = 1;
+  error = parameters.Set("graph-optimization-level", in_value);
+
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+
+  error = parameters.Get("graph-optimization-level", out_value);
+
+  LONGS_EQUAL(in_value, out_value);
+}
+
+TEST (OnnxrtParameters, SetLogIdAtWrongEngineState) {
+  r2i::RuntimeError error;
+  r2i::onnxrt::Parameters parameters;
+  std::string in_value;
+
+  std::shared_ptr<r2i::IEngine> engine(new r2i::onnxrt::Engine);
+  std::shared_ptr<r2i::IModel> model(new r2i::onnxrt::Model);
+
+  error = engine->Start();
+
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+
+  error = parameters.Configure(engine, model);
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+
+  /* Value different from the default */
+  in_value = "test";
+  error = parameters.Set("log-id", in_value);
+  LONGS_EQUAL (r2i::RuntimeError::Code::WRONG_ENGINE_STATE, error.GetCode ());
+}
+
+TEST (OnnxrtParameters, SetLoggingLevelAtWrongEngineState) {
+  r2i::RuntimeError error;
+  r2i::onnxrt::Parameters parameters;
+  int in_value;
+
+  std::shared_ptr<r2i::IEngine> engine(new r2i::onnxrt::Engine);
+  std::shared_ptr<r2i::IModel> model(new r2i::onnxrt::Model);
+
+  error = engine->Start();
+
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+
+  error = parameters.Configure(engine, model);
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+
+  /* Value different from the default */
+  in_value = 0;
+  error = parameters.Set("logging-level", in_value);
+  LONGS_EQUAL (r2i::RuntimeError::Code::WRONG_ENGINE_STATE, error.GetCode ());
+}
+
+TEST (OnnxrtParameters, SetIntraNumThreadsAtWrongEngineState) {
+  r2i::RuntimeError error;
+  r2i::onnxrt::Parameters parameters;
+  int in_value;
+
+  std::shared_ptr<r2i::IEngine> engine(new r2i::onnxrt::Engine);
+  std::shared_ptr<r2i::IModel> model(new r2i::onnxrt::Model);
+
+  error = engine->Start();
+
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+
+  error = parameters.Configure(engine, model);
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+
+  /* Value different from the default */
+  in_value = 0;
+  error = parameters.Set("intra-num-threads", in_value);
+  LONGS_EQUAL (r2i::RuntimeError::Code::WRONG_ENGINE_STATE, error.GetCode ());
+}
+
+TEST (OnnxrtParameters, SetGraphOptLevelAtWrongEngineState) {
+  r2i::RuntimeError error;
+  r2i::onnxrt::Parameters parameters;
+  int in_value;
+
+  std::shared_ptr<r2i::IEngine> engine(new r2i::onnxrt::Engine);
+  std::shared_ptr<r2i::IModel> model(new r2i::onnxrt::Model);
+
+  error = engine->Start();
+
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+
+  error = parameters.Configure(engine, model);
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+
+  /* Value different from the default */
+  in_value = 2;
+  error = parameters.Set("graph-optimization-level", in_value);
+  LONGS_EQUAL (r2i::RuntimeError::Code::WRONG_ENGINE_STATE, error.GetCode ());
+}
+
+TEST (OnnxrtParameters, SetWrongType) {
+  r2i::RuntimeError error;
+  r2i::onnxrt::Parameters parameters;
+  int value = 0;
+
+  error = parameters.Set("log-id", value);
+
+  LONGS_EQUAL (r2i::RuntimeError::Code::INVALID_FRAMEWORK_PARAMETER,
+               error.GetCode ());
+}
+
+TEST (OnnxrtParameters, GetWrongType) {
+  r2i::RuntimeError error;
+  r2i::onnxrt::Parameters parameters;
+  int value = 0;
+
+  error = parameters.Get("log-id", value);
+
+  LONGS_EQUAL (r2i::RuntimeError::Code::INVALID_FRAMEWORK_PARAMETER,
+               error.GetCode ());
+}
+
+TEST (OnnxrtParameters, GetList) {
+  r2i::RuntimeError error;
+  r2i::onnxrt::Parameters parameters;
+  std::vector<r2i::ParameterMeta> desc;
+
+  error = parameters.List (desc);
+
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode ());
+}
+
+int main (int ac, char **av) {
+  return CommandLineTestRunner::RunAllTests (ac, av);
+}
diff --git a/tests/unit/r2i/onnxrt/prediction.cc b/tests/unit/r2i/onnxrt/prediction.cc
new file mode 100644
index 00000000..3070216b
--- /dev/null
+++ b/tests/unit/r2i/onnxrt/prediction.cc
@@ -0,0 +1,102 @@
+/* Copyright (C) 2020 RidgeRun, LLC (http://www.ridgerun.com)
+ * All Rights Reserved.
+ *
+ * The contents of this software are proprietary and confidential to RidgeRun,
+ * LLC.  No part of this program may be photocopied, reproduced or translated
+ * into another programming language without prior written consent of
+ * RidgeRun, LLC.  The user is free to modify the source code after obtaining
+ * a software license from RidgeRun.  All source code changes must be provided
+ * back to RidgeRun without any encumbrance.
+*/
+
+#include <r2i/r2i.h>
+#include <r2i/onnxrt/prediction.h>
+
+#include <cstring>
+#include <fstream>
+#include <memory>
+
+#include <CppUTest/CommandLineTestRunner.h>
+#include <CppUTest/TestHarness.h>
+
+#define INPUTS 3
+
+bool model_sucess = true;
+
+TEST_GROUP (OnnxrtPrediction) {
+  r2i::RuntimeError error;
+
+  std::shared_ptr<r2i::onnxrt::Prediction> prediction =
+    std::make_shared<r2i::onnxrt::Prediction>();
+  float matrix[INPUTS] = {0.2, 0.4, 0.6};
+  float *tensordata = nullptr;
+
+  void setup () {
+    tensordata = nullptr;
+  }
+
+  void teardown () {
+  }
+};
+
+TEST (OnnxrtPrediction, SetTensorSuccess) {
+  r2i::RuntimeError error;
+
+  tensordata = &matrix[0];
+
+  error = prediction->SetTensorValues(tensordata, INPUTS);
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode());
+}
+
+TEST (OnnxrtPrediction, SetTensorNullValue) {
+  r2i::RuntimeError error;
+
+  error = prediction->SetTensorValues(tensordata, INPUTS);
+  LONGS_EQUAL (r2i::RuntimeError::Code::NULL_PARAMETER, error.GetCode());
+}
+
+TEST (OnnxrtPrediction, SetTensorZeroSize) {
+  r2i::RuntimeError error;
+
+  tensordata = &matrix[0];
+
+  error = prediction->SetTensorValues(tensordata, 0);
+  LONGS_EQUAL (r2i::RuntimeError::Code::NULL_PARAMETER, error.GetCode());
+}
+
+TEST (OnnxrtPrediction, Prediction) {
+  r2i::RuntimeError error;
+  tensordata = &matrix[0];
+  double result = 0;
+
+  error = prediction->SetTensorValues(tensordata, INPUTS);
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode());
+
+  result = prediction->At (0, error);
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode());
+  DOUBLES_EQUAL (matrix[0], result, 0.05);
+}
+
+TEST (OnnxrtPrediction, PredictionNoTensorValues) {
+  r2i::RuntimeError error;
+
+  prediction->At (0, error);
+  LONGS_EQUAL (r2i::RuntimeError::Code::INVALID_FRAMEWORK_PARAMETER,
+               error.GetCode());
+}
+
+TEST (OnnxrtPrediction, PredictionNonExistentIndex) {
+  r2i::RuntimeError error;
+
+  tensordata = &matrix[0];
+
+  error = prediction->SetTensorValues(tensordata, INPUTS);
+  LONGS_EQUAL (r2i::RuntimeError::Code::EOK, error.GetCode());
+
+  prediction->At (5, error);
+  LONGS_EQUAL (r2i::RuntimeError::Code::MEMORY_ERROR, error.GetCode());
+}
+
+int main (int ac, char **av) {
+  return CommandLineTestRunner::RunAllTests (ac, av);
+}
diff --git a/tests/unit/r2i/onnxrt/resources/meson.build b/tests/unit/r2i/onnxrt/resources/meson.build
new file mode 100644
index 00000000..bf6b5a78
--- /dev/null
+++ b/tests/unit/r2i/onnxrt/resources/meson.build
@@ -0,0 +1,8 @@
+onnx_tests_resources = [
+  ['squeezenet.onnx'],
+]
+
+# Copy resources files
+foreach t : onnx_tests_resources
+  configure_file(copy : true, input : t[0], output : t[0])
+endforeach
diff --git a/tests/unit/r2i/onnxrt/resources/squeezenet.onnx b/tests/unit/r2i/onnxrt/resources/squeezenet.onnx
new file mode 100644
index 00000000..810cf8f8
Binary files /dev/null and b/tests/unit/r2i/onnxrt/resources/squeezenet.onnx differ