diff --git a/Framework/Core/include/Framework/VariantJSONHelpers.h b/Framework/Core/include/Framework/VariantJSONHelpers.h
index 8fca73efbbb76..eab78d547ca13 100644
--- a/Framework/Core/include/Framework/VariantJSONHelpers.h
+++ b/Framework/Core/include/Framework/VariantJSONHelpers.h
@@ -160,22 +160,19 @@ struct VariantReader : public rapidjson::BaseReaderHandler<rapidjson::UTF8<>, Va
           if (currentKey == labels_rows_str) {
             labels_rows.push_back(str);
             return true;
-          } else if (currentKey == labels_cols_str) {
+          }
+          if (currentKey == labels_cols_str) {
             labels_cols.push_back(str);
             return true;
-          } else if (currentKey == "values") {
-            if constexpr (std::is_same_v<std::string, variant_array_element_type_t<V>>) {
-              accumulatedData.push_back(str);
-            } else {
-              states.push(State::IN_ERROR);
-            }
-            return true;
+          }
+        }
+        if (currentKey == "values") {
+          if constexpr (std::is_same_v<std::string, variant_array_element_type_t<V>>) {
+            accumulatedData.push_back(str);
           } else {
             states.push(State::IN_ERROR);
-            return true;
           }
-        } else {
-          accumulatedData.push_back(str);
+          return true;
         }
         return true;
       }
diff --git a/Framework/Core/include/Framework/VariantStringHelpers.h b/Framework/Core/include/Framework/VariantStringHelpers.h
deleted file mode 100644
index 63270167544df..0000000000000
--- a/Framework/Core/include/Framework/VariantStringHelpers.h
+++ /dev/null
@@ -1,100 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-#ifndef FRAMEWORK_VARIANTSTRINGHELPERS_H
-#define FRAMEWORK_VARIANTSTRINGHELPERS_H
-
-#include "Framework/Variant.h"
-#include <regex>
-
-namespace o2::framework
-{
-
-template <typename T>
-T lexical_cast(std::string const& input)
-{
-  if constexpr (std::is_same_v<T, int>) {
-    return std::stoi(input, nullptr);
-  } else if constexpr (std::is_same_v<T, int64_t>) {
-    return std::stol(input, nullptr);
-  } else if constexpr (std::is_same_v<T, float>) {
-    return std::stof(input, nullptr);
-  } else if constexpr (std::is_same_v<T, double>) {
-    return std::stod(input, nullptr);
-  } else if constexpr (std::is_same_v<T, bool>) {
-    return static_cast<bool>(std::stoi(input, nullptr));
-  }
-}
-
-template <typename T>
-std::vector<T> stringToVector(std::string const& input)
-{
-  std::vector<T> result;
-  //check if the array string has correct array type symbol
-  assert(input[0] == variant_array_symbol<T>::symbol);
-  std::regex nmatch(R"((?:(?!=,)|(?!=\[))[+-]?\d+\.?\d*(?:[eE][+-]?\d+)?(?=,|\]))");
-  auto end = std::sregex_iterator();
-  auto values = std::sregex_iterator(input.begin(), input.end(), nmatch);
-  for (auto& v = values; v != end; ++v) {
-    result.push_back(lexical_cast<T>(v->str()));
-  }
-  return result;
-}
-
-template <>
-std::vector<std::string> stringToVector(std::string const& input)
-{
-  std::vector<std::string> result;
-  //check if the array string has correct array type symbol
-  assert(input[0] == variant_array_symbol<std::string>::symbol);
-  std::regex smatch(R"((?:(?!=,)|(?!=\[))\w+(?=,|\]))");
-  auto end = std::sregex_iterator();
-  auto values = std::sregex_iterator(input.begin(), input.end(), smatch);
-  for (auto v = values; v != end; ++v) {
-    result.push_back(v->str());
-  }
-  return result;
-}
-
-template <typename T>
-Array2D<T> stringToArray2D(std::string const& input)
-{
-  std::vector<T> cache;
-  assert(input[0] == variant_array_symbol<T>::symbol);
-  std::regex mrows(R"(\[[^\[\]]+\])");
-  std::regex marray(R"((?:(?!=,)|(?!=\[))[+-]?\d+\.?\d*(?:[eE][+-]?\d+)?(?=,|\]))");
-  auto end = std::sregex_iterator();
-  auto rows = std::sregex_iterator(input.begin(), input.end(), mrows);
-  uint32_t nrows = 0;
-  uint32_t ncols = 0;
-  bool first = true;
-  for (auto& row = rows; row != end; ++row) {
-    auto str = row->str();
-    auto values = std::sregex_iterator(str.begin(), str.end(), marray);
-    if (first) {
-      ncols = 0;
-    }
-    for (auto& v = values; v != end; ++v) {
-      cache.push_back(lexical_cast<T>(v->str()));
-      if (first) {
-        ++ncols;
-      }
-    }
-    if (first) {
-      first = false;
-    }
-    ++nrows;
-  }
-  return Array2D<T>{cache, nrows, ncols};
-}
-
-} // namespace o2::framework
-
-#endif // FRAMEWORK_VARIANTSTRINGHELPERS_H
diff --git a/Framework/Core/src/PropertyTreeHelpers.cxx b/Framework/Core/src/PropertyTreeHelpers.cxx
index cf862b78e77b5..3f373ffe3a362 100644
--- a/Framework/Core/src/PropertyTreeHelpers.cxx
+++ b/Framework/Core/src/PropertyTreeHelpers.cxx
@@ -11,9 +11,9 @@
 
 #include "PropertyTreeHelpers.h"
 #include "Framework/ConfigParamSpec.h"
-#include "Framework/VariantStringHelpers.h"
 #include "Framework/VariantPropertyTreeHelpers.h"
 #include "Framework/RuntimeError.h"
+#include "Framework/VariantJSONHelpers.h"
 
 #include <boost/program_options/variables_map.hpp>
 
@@ -22,7 +22,16 @@
 
 namespace o2::framework
 {
-
+namespace {
+/// Helper to get a Variant from a @a str
+template <VariantType T>
+inline Variant fromString(std::string const& str)
+{
+  std::stringstream ss;
+  ss.str(str);
+  return VariantJSONHelpers::read<T>(ss);
+}
+}
 void PropertyTreeHelpers::populateDefaults(std::vector<ConfigParamSpec> const& schema,
                                            boost::property_tree::ptree& pt,
                                            boost::property_tree::ptree& provenance)
@@ -177,28 +186,73 @@ void PropertyTreeHelpers::populate(std::vector<ConfigParamSpec> const& schema,
           pt.put(key, vmap[key].as<bool>());
           break;
         case VariantType::ArrayInt:
-          pt.put_child(key, vectorToBranch<int>(stringToVector<int>(vmap[key].as<std::string>())));
+        {
+          auto v = fromString<VariantType::ArrayInt>(vmap[key].as<std::string>());
+          pt.put_child(key, vectorToBranch<int>(v.get<int*>(), v.size()));
+        }
           break;
         case VariantType::ArrayFloat:
-          pt.put_child(key, vectorToBranch<float>(stringToVector<float>(vmap[key].as<std::string>())));
+        {
+          auto v = fromString<VariantType::ArrayFloat>(vmap[key].as<std::string>());
+          pt.put_child(key, vectorToBranch<float>(v.get<float*>(), v.size()));
+        }
           break;
         case VariantType::ArrayDouble:
-          pt.put_child(key, vectorToBranch<double>(stringToVector<double>(vmap[key].as<std::string>())));
+        {
+          auto v = fromString<VariantType::ArrayDouble>(vmap[key].as<std::string>());
+          pt.put_child(key, vectorToBranch<double>(v.get<double*>(), v.size()));
+        }
           break;
         case VariantType::ArrayBool:
           //          pt.put_child(key, vectorToBranch<bool>(stringToVector<bool>(vmap[key].as<std::string>())));
           break;
         case VariantType::ArrayString:
-          pt.put_child(key, vectorToBranch<std::string>(stringToVector<std::string>(vmap[key].as<std::string>())));
+        {
+          auto v = fromString<VariantType::ArrayString>(vmap[key].as<std::string>());
+          pt.put_child(key, vectorToBranch<std::string>(v.get<std::string*>(), v.size()));
+        }
           break;
         case VariantType::Array2DInt:
-          pt.put_child(key, array2DToBranch<int>(stringToArray2D<int>(vmap[key].as<std::string>())));
+        {
+          auto v = fromString<VariantType::Array2DInt>(vmap[key].as<std::string>());
+          pt.put_child(key, array2DToBranch<int>(v.get<Array2D<int>>()));
+        }
           break;
         case VariantType::Array2DFloat:
-          pt.put_child(key, array2DToBranch<float>(stringToArray2D<float>(vmap[key].as<std::string>())));
+        {
+          auto v = fromString<VariantType::Array2DFloat>(vmap[key].as<std::string>());
+          pt.put_child(key, array2DToBranch<float>(v.get<Array2D<float>>()));
+        }
           break;
         case VariantType::Array2DDouble:
-          pt.put_child(key, array2DToBranch<double>(stringToArray2D<double>(vmap[key].as<std::string>())));
+        {
+          auto v = fromString<VariantType::Array2DDouble>(vmap[key].as<std::string>());
+          pt.put_child(key, array2DToBranch<double>(v.get<Array2D<double>>()));
+        }
+          break;
+        case VariantType::LabeledArrayInt:
+        {
+          auto v = fromString<VariantType::LabeledArrayInt>(vmap[key].as<std::string>());
+          pt.put_child(key, labeledArrayToBranch(v.get<LabeledArray<int>>()));
+        }
+          break;
+        case VariantType::LabeledArrayFloat:
+        {
+          auto v = fromString<VariantType::LabeledArrayFloat>(vmap[key].as<std::string>());
+          pt.put_child(key, labeledArrayToBranch(v.get<LabeledArray<float>>()));
+        }
+          break;
+        case VariantType::LabeledArrayDouble:
+        {
+          auto v = fromString<VariantType::LabeledArrayDouble>(vmap[key].as<std::string>());
+          pt.put_child(key, labeledArrayToBranch(v.get<LabeledArray<double>>()));
+        }
+          break;
+        case VariantType::LabeledArrayString:
+        {
+          auto v = fromString<VariantType::LabeledArrayString>(vmap[key].as<std::string>());
+          pt.put_child(key, labeledArrayToBranch(v.get<LabeledArray<std::string>>()));
+        }
           break;
         case VariantType::Dict:
           pt.put_child(key, vmap[key].as<boost::property_tree::ptree>());
diff --git a/Framework/Core/src/PropertyTreeHelpers.h b/Framework/Core/src/PropertyTreeHelpers.h
index fb200335585b4..8b929dc061a67 100644
--- a/Framework/Core/src/PropertyTreeHelpers.h
+++ b/Framework/Core/src/PropertyTreeHelpers.h
@@ -23,7 +23,7 @@ namespace o2::framework
 
 /// Helpers to manipulate property_trees.
 struct PropertyTreeHelpers {
-  /// For all the options specified in @a schama, this fills
+  /// For all the options specified in @a schema, this fills
   /// @a tree with the contents of @a vmap, which is populated via boost
   /// program options. Any key in the @a schema will be marked as
   /// "default" in the provenance ptree.
diff --git a/Framework/Core/src/Variant.cxx b/Framework/Core/src/Variant.cxx
index 4c2246f6e573b..3f71ec339511e 100644
--- a/Framework/Core/src/Variant.cxx
+++ b/Framework/Core/src/Variant.cxx
@@ -10,46 +10,12 @@
 // or submit itself to any jurisdiction.
 #include "Framework/Variant.h"
 #include "Framework/VariantPropertyTreeHelpers.h"
+#include "Framework/VariantJSONHelpers.h"
 #include <iostream>
 #include <sstream>
 
 namespace o2::framework
 {
-
-namespace
-{
-template <typename T>
-void printArray(std::ostream& oss, T* array, size_t size)
-{
-  oss << variant_array_symbol<T>::symbol << "[";
-  oss << array[0];
-  for (auto i = 1U; i < size; ++i) {
-    oss << ", " << array[i];
-  }
-  oss << "]";
-}
-
-template <typename T>
-void printMatrix(std::ostream& oss, Array2D<T> const& m)
-{
-  oss << variant_array_symbol<T>::symbol << "[[";
-  oss << m(0, 0);
-  for (auto j = 1U; j < m.cols; ++j) {
-    oss << ", " << m(0, j);
-  }
-  oss << "]";
-  for (auto i = 1U; i < m.rows; ++i) {
-    oss << ", [";
-    oss << m(i, 0);
-    for (auto j = 1U; j < m.cols; ++j) {
-      oss << ", " << m(i, j);
-    }
-    oss << "]";
-  }
-  oss << "]";
-}
-} // namespace
-
 std::ostream& operator<<(std::ostream& oss, Variant const& val)
 {
   switch (val.type()) {
@@ -90,28 +56,14 @@ std::ostream& operator<<(std::ostream& oss, Variant const& val)
       oss << val.get<bool>();
       break;
     case VariantType::ArrayInt:
-      printArray<int>(oss, val.get<int*>(), val.size());
-      break;
     case VariantType::ArrayFloat:
-      printArray<float>(oss, val.get<float*>(), val.size());
-      break;
     case VariantType::ArrayDouble:
-      printArray<double>(oss, val.get<double*>(), val.size());
-      break;
     case VariantType::ArrayBool:
-      printArray<bool>(oss, val.get<bool*>(), val.size());
-      break;
     case VariantType::ArrayString:
-      printArray<std::string>(oss, val.get<std::string*>(), val.size());
-      break;
     case VariantType::Array2DInt:
-      printMatrix<int>(oss, val.get<Array2D<int>>());
-      break;
     case VariantType::Array2DFloat:
-      printMatrix<float>(oss, val.get<Array2D<float>>());
-      break;
     case VariantType::Array2DDouble:
-      printMatrix<double>(oss, val.get<Array2D<double>>());
+      VariantJSONHelpers::write(oss, val);
       break;
     case VariantType::Empty:
       break;
diff --git a/Framework/Core/test/test_Variants.cxx b/Framework/Core/test/test_Variants.cxx
index f4f8dcb1a6cda..80530f13acb20 100644
--- a/Framework/Core/test/test_Variants.cxx
+++ b/Framework/Core/test/test_Variants.cxx
@@ -11,7 +11,6 @@
 
 #include <catch_amalgamated.hpp>
 #include "Framework/Variant.h"
-#include "Framework/VariantStringHelpers.h"
 #include "Framework/VariantPropertyTreeHelpers.h"
 #include "Framework/VariantJSONHelpers.h"
 #include <sstream>
@@ -168,7 +167,7 @@ TEST_CASE("VariantTest")
   }
   std::stringstream ssm;
   ssm << vmma;
-  REQUIRE(ssm.str() == "f[[0.1, 0.2, 0.3, 0.4], [0.5, 0.6, 0.7, 0.8], [0.9, 1, 1.1, 1.2]]");
+  REQUIRE(ssm.str() == "{\"values\":[[0.10000000149011612,0.20000000298023225,0.30000001192092898,0.4000000059604645],[0.5,0.6000000238418579,0.699999988079071,0.800000011920929],[0.8999999761581421,1.0,1.100000023841858,1.2000000476837159]]}");
 
   LabeledArray<float> laf{&m[0][0], 3, 4, {"r1", "r2", "r3"}, {"c1", "c2", "c3", "c4"}};
   Variant vlaf(laf);
@@ -253,7 +252,7 @@ TEST_CASE("LabeledArrayTest")
 
 TEST_CASE("VariantTreeConversionsTest")
 {
-  std::vector<std::string> vstrings{"0.1", "0.2", "0.3"};
+  std::vector<std::string> vstrings{"0 1", "0 2", "0 3"};
   Variant vvstr(std::move(vstrings));
 
   auto tree = vectorToBranch(vvstr.get<std::string*>(), vvstr.size());
@@ -326,7 +325,7 @@ TEST_CASE("VariantJSONConversionsTest")
     }
   }
 
-  std::vector<std::string> vstrings{"s1", "s2", "s3"};
+  std::vector<std::string> vstrings{"myoption_one", "myoption_two"};
   Variant vvstr(vstrings);
   std::stringstream osal;
   VariantJSONHelpers::write(osal, vvstr);