diff --git a/CMakeLists.txt b/CMakeLists.txt
index cb0ec43..a913623 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -81,9 +81,11 @@ FILE (GLOB_RECURSE core_SRCS
     ./include/Plugin/IPlugin.h
     ./include/Data/ArrayDataIterator.h
     ./include/Data/VectorSeries.h
+    ./include/Data/VectorTimeSerie.h
     ./include/Data/DateTimeRange.h
     ./include/Data/DateTimeRangeHelper.h
     ./include/Data/ScalarSeries.h
+    ./include/Data/ScalarTimeSerie.h
     ./include/Data/DataSeriesMergeHelper.h
     ./include/Data/DataSeries.h
     ./include/Data/DataSeriesType.h
@@ -125,12 +127,14 @@ FILE (GLOB_RECURSE core_SRCS
     ./src/Common/StringUtils.cpp
     ./src/Common/SignalWaiter.cpp
     ./src/Data/ScalarSeries.cpp
+    ./src/Data/ScalarTimeSerie.cpp
     ./src/Data/DataSeriesIterator.cpp
     ./src/Data/OptionalAxis.cpp
     ./src/Data/ArrayDataIterator.cpp
     ./src/Data/SpectrogramSeries.cpp
     ./src/Data/DataSeriesUtils.cpp
     ./src/Data/VectorSeries.cpp
+    ./src/Data/VectorTimeSerie.cpp
     ./src/Network/NetworkController.cpp
     ./src/Network/Downloader.cpp
     ./src/Visualization/VisualizationController.cpp
@@ -172,6 +176,7 @@ target_include_directories(sciqlopcore PUBLIC
 target_link_libraries(sciqlopcore PUBLIC
   Qt5::Core
   Qt5::Network
+  TimeSeries
 )
 
 if(Catalog)
diff --git a/include/Data/DataSeriesType.h b/include/Data/DataSeriesType.h
index d019c83..ba31397 100644
--- a/include/Data/DataSeriesType.h
+++ b/include/Data/DataSeriesType.h
@@ -3,24 +3,33 @@
 
 #include <QString>
 
-enum class DataSeriesType { SCALAR, SPECTROGRAM, VECTOR, UNKNOWN };
+enum class DataSeriesType
+{
+  SCALAR,
+  SPECTROGRAM,
+  VECTOR,
+  UNKNOWN
+};
 
-struct DataSeriesTypeUtils {
-    static DataSeriesType fromString(const QString &type)
+struct DataSeriesTypeUtils
+{
+  static DataSeriesType fromString(const QString& type)
+  {
+    if(type.toLower() == QStringLiteral("scalar"))
+    { return DataSeriesType::SCALAR; }
+    else if(type.toLower() == QStringLiteral("spectrogram"))
+    {
+      return DataSeriesType::SPECTROGRAM;
+    }
+    else if(type.toLower() == QStringLiteral("vector"))
+    {
+      return DataSeriesType::VECTOR;
+    }
+    else
     {
-        if (type == QStringLiteral("scalar")) {
-            return DataSeriesType::SCALAR;
-        }
-        else if (type == QStringLiteral("spectrogram")) {
-            return DataSeriesType::SPECTROGRAM;
-        }
-        else if (type == QStringLiteral("vector")) {
-            return DataSeriesType::VECTOR;
-        }
-        else {
-            return DataSeriesType::UNKNOWN;
-        }
+      return DataSeriesType::UNKNOWN;
     }
+  }
 };
 
 #endif // SCIQLOP_DATASERIESTYPE_H
diff --git a/include/Data/IDataProvider.h b/include/Data/IDataProvider.h
index 5a1aae3..396273a 100644
--- a/include/Data/IDataProvider.h
+++ b/include/Data/IDataProvider.h
@@ -2,54 +2,48 @@
 #define SCIQLOP_IDATAPROVIDER_H
 
 #include "CoreGlobal.h"
-#include <Common/deprecate.h>
-
-#include <memory>
-
-#include <QObject>
-#include <QUuid>
 
 #include <Common/MetaTypes.h>
-
+#include <Common/deprecate.h>
 #include <Data/DateTimeRange.h>
-
+#include <QObject>
+#include <QUuid>
 #include <functional>
+#include <memory>
 
 class DataProviderParameters;
 class IDataSeries;
-DEPRECATE(
-    class QNetworkReply;
-    class QNetworkRequest;
-)
+DEPRECATE(class QNetworkReply; class QNetworkRequest;)
 
 /**
  * @brief The IDataProvider interface aims to declare a data provider.
  *
- * A data provider is an entity that generates data and returns it according to various parameters
- * (time interval, product to retrieve the data, etc.)
- * Since its client mihgt use it from different threads it has to be either stateless  and/or thread safe
+ * A data provider is an entity that generates data and returns it according to
+ * various parameters (time interval, product to retrieve the data, etc.) Since
+ * its client mihgt use it from different threads it has to be either stateless
+ * and/or thread safe
  *
  * @sa IDataSeries
  */
-class SCIQLOP_CORE_EXPORT IDataProvider : public QObject {
-
-    Q_OBJECT
+class SCIQLOP_CORE_EXPORT IDataProvider : public QObject
+{
+  Q_OBJECT
 public:
-    virtual ~IDataProvider() noexcept = default;
-    virtual std::shared_ptr<IDataProvider> clone() const = 0;
+  virtual ~IDataProvider() noexcept                    = default;
+  virtual std::shared_ptr<IDataProvider> clone() const = 0;
 
-    // Synchronous call -> asyncGetData may be written for asynchronous get
-    virtual IDataSeries* getData(const DataProviderParameters &parameters) = 0;
+  // Synchronous call -> asyncGetData may be written for asynchronous get
+  virtual IDataSeries* getData(const DataProviderParameters& parameters) = 0;
 
 signals:
 
-    void progress(QUuid requestID, double progress);
-
+  void progress(QUuid requestID, double progress);
 };
 
 // Required for using shared_ptr in signals/slots
-SCIQLOP_REGISTER_META_TYPE(IDATAPROVIDER_PTR_REGISTRY, std::shared_ptr<IDataProvider>)
+SCIQLOP_REGISTER_META_TYPE(IDATAPROVIDER_PTR_REGISTRY,
+                           std::shared_ptr<IDataProvider>)
 SCIQLOP_REGISTER_META_TYPE(IDATAPROVIDER_FUNCTION_REGISTRY,
-                           std::function<void(QNetworkReply *, QUuid)>)
+                           std::function<void(QNetworkReply*, QUuid)>)
 
 #endif // SCIQLOP_IDATAPROVIDER_H
diff --git a/include/Data/ScalarTimeSerie.h b/include/Data/ScalarTimeSerie.h
new file mode 100644
index 0000000..bc1549d
--- /dev/null
+++ b/include/Data/ScalarTimeSerie.h
@@ -0,0 +1,17 @@
+#ifndef SCIQLOP_SCALARTIMESERIE_H
+#define SCIQLOP_SCALARTIMESERIE_H
+
+#include "CoreGlobal.h"
+
+#include <TimeSeries.h>
+
+class SCIQLOP_CORE_EXPORT ScalarTimeSerie
+    : public TimeSeries::TimeSerie<double, ScalarTimeSerie>
+{
+public:
+  ScalarTimeSerie() {}
+  ~ScalarTimeSerie() = default;
+  using TimeSerie::TimeSerie;
+};
+
+#endif // SCIQLOP_SCALARSERIES_H
diff --git a/include/Data/VectorTimeSerie.h b/include/Data/VectorTimeSerie.h
new file mode 100644
index 0000000..13cb128
--- /dev/null
+++ b/include/Data/VectorTimeSerie.h
@@ -0,0 +1,22 @@
+#ifndef SCIQLOP_VECTORTIMESERIE_H
+#define SCIQLOP_VECTORTIMESERIE_H
+
+#include "CoreGlobal.h"
+
+#include <TimeSeries.h>
+
+struct Vector
+{
+  double x, y, z;
+};
+
+class SCIQLOP_CORE_EXPORT VectorTimeSerie
+    : public TimeSeries::TimeSerie<Vector, VectorTimeSerie>
+{
+public:
+  VectorTimeSerie() {}
+  ~VectorTimeSerie() = default;
+  using TimeSerie::TimeSerie;
+};
+
+#endif // SCIQLOP_VECTORTIMESERIE_H
diff --git a/include/Variable/VariableCacheStrategy.h b/include/Variable/VariableCacheStrategy.h
index f44e872..7c6d675 100644
--- a/include/Variable/VariableCacheStrategy.h
+++ b/include/Variable/VariableCacheStrategy.h
@@ -3,30 +3,15 @@
 
 #include "CoreGlobal.h"
 
-#include <QLoggingCategory>
-#include <QObject>
-
 #include <Data/DateTimeRange.h>
 
-#include <QLoggingCategory>
-
-#include <Common/spimpl.h>
-#include <utility>
-
-
-Q_DECLARE_LOGGING_CATEGORY(LOG_VariableCacheStrategy)
-
-class Variable;
-
 /// This class aims to hande the cache strategy.
-class SCIQLOP_CORE_EXPORT VariableCacheStrategy {
-
+class SCIQLOP_CORE_EXPORT VariableCacheStrategy
+{
 public:
-    virtual ~VariableCacheStrategy() noexcept = default;
-    virtual DateTimeRange computeRange(const DateTimeRange &currentCacheRange,
-                                                       const DateTimeRange &rangeRequested)
-        = 0;
+  virtual ~VariableCacheStrategy() noexcept = default;
+  virtual DateTimeRange computeRange(const DateTimeRange& currentCacheRange,
+                                     const DateTimeRange& rangeRequested) = 0;
 };
 
-
 #endif // SCIQLOP_VARIABLECACHESTRATEGY_H
diff --git a/src/Data/ScalarTimeSerie.cpp b/src/Data/ScalarTimeSerie.cpp
new file mode 100644
index 0000000..b58999b
--- /dev/null
+++ b/src/Data/ScalarTimeSerie.cpp
@@ -0,0 +1 @@
+#include <Data/ScalarTimeSerie.h>
diff --git a/src/Data/VectorTimeSerie.cpp b/src/Data/VectorTimeSerie.cpp
new file mode 100644
index 0000000..30260ee
--- /dev/null
+++ b/src/Data/VectorTimeSerie.cpp
@@ -0,0 +1 @@
+#include <Data/VectorTimeSerie.h>
diff --git a/src/Variable/VariableController2.cpp b/src/Variable/VariableController2.cpp
index 19d918c..92a8ab9 100644
--- a/src/Variable/VariableController2.cpp
+++ b/src/Variable/VariableController2.cpp
@@ -1,432 +1,452 @@
-#include <QQueue>
-#include <QThreadPool>
-#include <QRunnable>
-#include <QObject>
-#include <QDataStream>
-
 #include "Variable/VariableController2.h"
+
 #include "Variable/VariableSynchronizationGroup2.h"
+
 #include <Common/containers.h>
 #include <Common/debug.h>
 #include <Data/DataProviderParameters.h>
-#include <Data/DateTimeRangeHelper.h>
 #include <Data/DateTimeRange.h>
+#include <Data/DateTimeRangeHelper.h>
+#include <QCoreApplication>
+#include <QDataStream>
+#include <QObject>
+#include <QQueue>
+#include <QRunnable>
+#include <QThreadPool>
 #include <Variable/VariableCacheStrategyFactory.h>
 #include <Variable/private/VCTransaction.h>
-#include <QCoreApplication>
-
 
 class VariableController2::VariableController2Private
 {
-    struct threadSafeVaraiblesMaps
+  struct threadSafeVaraiblesMaps
+  {
+    inline void
+    addVariable(const std::shared_ptr<Variable>& variable,
+                const std::shared_ptr<IDataProvider>& provider,
+                const std::shared_ptr<VariableSynchronizationGroup2>&
+                    synchronizationGroup)
     {
-        inline void addVariable(const std::shared_ptr<Variable>& variable, const std::shared_ptr<IDataProvider>& provider, const std::shared_ptr<VariableSynchronizationGroup2>& synchronizationGroup)
-        {
-            QWriteLocker lock{&_lock};
-            _variables[*variable] = variable;
-            _providers[*variable] = provider;
-            _synchronizationGroups[*variable] = synchronizationGroup;
-        }
-
-        inline void removeVariable(const std::shared_ptr<Variable>& variable)
-        {
-            QWriteLocker lock{&_lock};
-            _variables.erase(*variable);
-            _providers.remove(*variable);
-            _synchronizationGroups.remove(*variable);
-        }
-
-        inline void synchronize(const std::shared_ptr<Variable>& variable, const std::optional<std::shared_ptr<Variable>>& with)
-        {
-            QWriteLocker lock{&_lock};
-            if(with.has_value())
-            {
-                auto newGroup = _synchronizationGroups[*with.value()];
-                newGroup->addVariable(*variable);
-                _synchronizationGroups[*variable] = newGroup;
-            }
-            else
-            {
-                _synchronizationGroups[*variable] = std::make_shared<VariableSynchronizationGroup2>(*variable);
-            }
-        }
-
-        inline std::shared_ptr<Variable> variable(QUuid variable)
-        {
-            QReadLocker lock{&_lock};
-            auto it = _variables.find(variable);
-            [[unlikely]]
-            if(it==_variables.end())
-                SCIQLOP_ERROR(threadSafeVaraiblesMaps,"Unknown Variable");
-            return (*it).second;
-        }
-
-        inline std::shared_ptr<Variable> variable(int index)
-        {
-            QReadLocker lock{&_lock};
-            [[unlikely]]
-            if(!_variables.size() > index)
-                SCIQLOP_ERROR(threadSafeVaraiblesMaps,"Index is out of bounds");
-            auto it = _variables.cbegin();
-            while (index!=0) {
-                index-=1;
-                it++;
-            }
-            return (*it).second;
-        }
-
-        inline const std::vector<std::shared_ptr<Variable>> variables()
-        {
-            std::vector<std::shared_ptr<Variable>> vars;
-            QReadLocker lock{&_lock};
-            for(const auto&[id, var]:_variables)
-            {
-                vars.push_back(var);
-            }
-            return  vars;
-        }
-
-        inline std::shared_ptr<IDataProvider> provider(QUuid variable)
-        {
-            QReadLocker lock{&_lock};
-            [[unlikely]]
-            if(!_providers.contains(variable))
-                SCIQLOP_ERROR(threadSafeVaraiblesMaps,"Unknown Variable");
-            return _providers[variable];
-        }
-
-        inline std::shared_ptr<VariableSynchronizationGroup2> group(QUuid variable)
-        {
-            QReadLocker lock{&_lock};
-            [[unlikely]]
-            if(!_synchronizationGroups.contains(variable))
-                SCIQLOP_ERROR(threadSafeVaraiblesMaps,"Unknown Variable");
-            return _synchronizationGroups[variable];
-        }
-
-        inline bool has(const std::shared_ptr<Variable>& variable)
-        {
-            QReadLocker lock{&_lock};
-            return _variables.find(*variable)==_variables.end();
-        }
-
-    private:
-        std::map<QUuid,std::shared_ptr<Variable>> _variables;
-        QMap<QUuid,std::shared_ptr<IDataProvider>> _providers;
-        QMap<QUuid,std::shared_ptr<VariableSynchronizationGroup2>> _synchronizationGroups;
-        QReadWriteLock _lock{QReadWriteLock::Recursive};
-    }_maps;
-    std::vector<QUuid> _variablesToRemove;
-    QThreadPool* _ThreadPool;
-    VCTransactionsQueues _transactions;
-    std::unique_ptr<VariableCacheStrategy> _cacheStrategy;
-
-    void _transactionComplete(QUuid group, std::shared_ptr<VCTransaction> transaction)
-    {
-        if(transaction->done())
-        {
-            _transactions.complete(group);
-        }
-        this->_processTransactions();
+      QWriteLocker lock{&_lock};
+      _variables[*variable]             = variable;
+      _providers[*variable]             = provider;
+      _synchronizationGroups[*variable] = synchronizationGroup;
     }
 
-    void _cleanupVariables()
+    inline void removeVariable(const std::shared_ptr<Variable>& variable)
     {
-        for(auto id:_variablesToRemove)
-        {
-            auto v = this->variable(id);
-            if(!hasPendingTransactions(v))
-            {
-                _variablesToRemove.erase(std::remove(_variablesToRemove.begin(), _variablesToRemove.end(), id), _variablesToRemove.end());
-                this->deleteVariable(v);
-            }
-        }
+      QWriteLocker lock{&_lock};
+      _variables.erase(*variable);
+      _providers.remove(*variable);
+      _synchronizationGroups.remove(*variable);
     }
 
-    void _processTransactions(bool fragmented=false)
+    inline void
+    synchronize(const std::shared_ptr<Variable>& variable,
+                const std::optional<std::shared_ptr<Variable>>& with)
     {
-        auto nextTransactions = _transactions.nextTransactions();
-        auto pendingTransactions = _transactions.pendingTransactions();
-        for( auto [groupID, newTransaction] : nextTransactions)
-        {
-            if(newTransaction.has_value() && !pendingTransactions[groupID].has_value())
-            {
-                _transactions.start(groupID);
-                auto refVar = _maps.variable(newTransaction.value()->refVar);
-                auto ranges = _computeAllRangesInGroup(refVar,newTransaction.value()->range);
-                for( auto const& [ID, range] : ranges)
-                {
-                    auto provider = _maps.provider(ID);
-                    auto variable = _maps.variable(ID);
-                    if(fragmented)
-                    {
-                        auto [missingRanges, newCacheRange] = _computeMissingRanges(variable,range);
-
-                        auto exe = new TransactionExe(variable, provider, missingRanges, range, newCacheRange);
-                        QObject::connect(exe,
-                                &TransactionExe::transactionComplete,
-                                [groupID=groupID,transaction=newTransaction.value(),this]()
-                                {
-                                    this->_transactionComplete(groupID, transaction);
-                                }
-                        );
-                        _ThreadPool->start(exe);
-                    }
-                    else
-                    {
-                            auto exe = new TransactionExe(variable, provider, {range}, range, range);
-                            QObject::connect(exe,
-                                    &TransactionExe::transactionComplete,
-                                    [groupID=groupID,transaction=newTransaction.value(),this]()
-                                    {
-                                        this->_transactionComplete(groupID, transaction);
-                                    }
-                            );
-                            _ThreadPool->start(exe);
-                    }
-                }
-            }
-        }
-        //after each transaction update we get a new distribution of idle and working variables
-        //so we can delete variables which are waiting to be deleted if they are now idle
-        _cleanupVariables();
+      QWriteLocker lock{&_lock};
+      if(with.has_value())
+      {
+        auto newGroup = _synchronizationGroups[*with.value()];
+        newGroup->addVariable(*variable);
+        _synchronizationGroups[*variable] = newGroup;
+      }
+      else
+      {
+        _synchronizationGroups[*variable] =
+            std::make_shared<VariableSynchronizationGroup2>(*variable);
+      }
     }
 
-    std::map<QUuid,DateTimeRange> _computeAllRangesInGroup(const std::shared_ptr<Variable>& refVar, DateTimeRange r)
+    inline std::shared_ptr<Variable> variable(QUuid variable)
     {
-        std::map<QUuid,DateTimeRange> ranges;
-        if(!DateTimeRangeHelper::hasnan(r))
-        {
-            auto group = _maps.group(*refVar);
-            if(auto transformation = DateTimeRangeHelper::computeTransformation(refVar->range(),r);
-                    transformation.has_value())
-            {
-                for(auto varId:group->variables())
-                {
-                    auto var = _maps.variable(varId);
-                    auto newRange = var->range().transform(transformation.value());
-                    ranges[varId] = newRange;
-                }
-            }
-            else // force new range to all variables -> may be weird if more than one var in the group
-                // @TODO ensure that there is no side effects
-            {
-                for(auto varId:group->variables())
-                {
-                    auto var = _maps.variable(varId);
-                    ranges[varId] = r;
-                }
-            }
-        }
-        else
-        {
-            SCIQLOP_ERROR(VariableController2Private, "Invalid range containing NaN");
-        }
-        return ranges;
+      QReadLocker lock{&_lock};
+      auto it = _variables.find(variable);
+      [[unlikely]] if(it == _variables.end())
+          SCIQLOP_ERROR(threadSafeVaraiblesMaps, "Unknown Variable");
+      return (*it).second;
     }
 
-    std::pair<std::vector<DateTimeRange>,DateTimeRange> _computeMissingRanges(const std::shared_ptr<Variable>& var, DateTimeRange r)
+    inline std::shared_ptr<Variable> variable(int index)
     {
-        DateTimeRange newCacheRange;
-        std::vector<DateTimeRange> missingRanges;
-        if(DateTimeRangeHelper::hasnan(var->cacheRange()))
-        {
-            newCacheRange = _cacheStrategy->computeRange(r,r);
-            missingRanges = {newCacheRange};
-        }
-        else
-        {
-            newCacheRange = _cacheStrategy->computeRange(var->cacheRange(),r);
-            missingRanges = newCacheRange - var->cacheRange();
-        }
-        return {missingRanges,newCacheRange};
+      QReadLocker lock{&_lock};
+      [[unlikely]] if(!_variables.size() > index)
+          SCIQLOP_ERROR(threadSafeVaraiblesMaps, "Index is out of bounds");
+      auto it = _variables.cbegin();
+      while(index != 0)
+      {
+        index -= 1;
+        it++;
+      }
+      return (*(it)).second;
     }
 
-    void _changeRange(QUuid id, DateTimeRange r)
+    inline const std::vector<std::shared_ptr<Variable>> variables()
     {
-        _changeRange(_maps.variable(id) ,r);
+      std::vector<std::shared_ptr<Variable>> vars;
+      QReadLocker lock{&_lock};
+      for(const auto& [id, var] : _variables)
+      {
+        vars.push_back(var);
+      }
+      return vars;
     }
-    void _changeRange(const std::shared_ptr<Variable>& var, DateTimeRange r)
+
+    inline std::shared_ptr<IDataProvider> provider(QUuid variable)
     {
-        auto provider = _maps.provider(*var);
-        auto [missingRanges, newCacheRange] = _computeMissingRanges(var,r);
-        std::vector<IDataSeries*> data;
-        for(auto range:missingRanges)
-        {
-            data.push_back(provider->getData(DataProviderParameters{{range}, var->metadata()}));
-        }
-        var->updateData(data, r, newCacheRange, true);
+      QReadLocker lock{&_lock};
+      [[unlikely]] if(!_providers.contains(variable))
+          SCIQLOP_ERROR(threadSafeVaraiblesMaps, "Unknown Variable");
+      return _providers[variable];
     }
-public:
-    VariableController2Private(QObject* parent=Q_NULLPTR)
-        :_cacheStrategy(VariableCacheStrategyFactory::createCacheStrategy(CacheStrategy::SingleThreshold))
+
+    inline std::shared_ptr<VariableSynchronizationGroup2> group(QUuid variable)
     {
-        Q_UNUSED(parent);
-        this->_ThreadPool = new QThreadPool();
-        this->_ThreadPool->setMaxThreadCount(32);
+      QReadLocker lock{&_lock};
+      [[unlikely]] if(!_synchronizationGroups.contains(variable))
+          SCIQLOP_ERROR(threadSafeVaraiblesMaps, "Unknown Variable");
+      return _synchronizationGroups[variable];
     }
 
-    /*
-     * This dtor has to like this even if this is ugly, because default dtor would rely on
-     * declaration order to destruct members and that would always lead to regressions when
-     * modifying class members
-    */
-    ~VariableController2Private()
+    inline bool has(const std::shared_ptr<Variable>& variable)
     {
-        delete this->_ThreadPool;
+      QReadLocker lock{&_lock};
+      return _variables.find(*variable) == _variables.end();
     }
 
-    std::shared_ptr<Variable> createVariable(const QString &name, const QVariantHash &metadata, std::shared_ptr<IDataProvider> provider)
+  private:
+    std::map<QUuid, std::shared_ptr<Variable>> _variables;
+    QMap<QUuid, std::shared_ptr<IDataProvider>> _providers;
+    QMap<QUuid, std::shared_ptr<VariableSynchronizationGroup2>>
+        _synchronizationGroups;
+    QReadWriteLock _lock{QReadWriteLock::Recursive};
+  } _maps;
+  std::vector<QUuid> _variablesToRemove;
+  QThreadPool* _ThreadPool;
+  VCTransactionsQueues _transactions;
+  std::unique_ptr<VariableCacheStrategy> _cacheStrategy;
+
+  void _transactionComplete(QUuid group,
+                            std::shared_ptr<VCTransaction> transaction)
+  {
+    if(transaction->done()) { _transactions.complete(group); }
+    this->_processTransactions();
+  }
+
+  void _cleanupVariables()
+  {
+    for(auto id : _variablesToRemove)
     {
-        auto newVar = std::make_shared<Variable>(name,metadata);
-        auto group = std::make_shared<VariableSynchronizationGroup2>(newVar->ID());
-        _maps.addVariable(newVar,std::move(provider),group);
-        this->_transactions.addEntry(*group);
-        return newVar;
+      auto v = this->variable(id);
+      if(!hasPendingTransactions(v))
+      {
+        _variablesToRemove.erase(std::remove(_variablesToRemove.begin(),
+                                             _variablesToRemove.end(), id),
+                                 _variablesToRemove.end());
+        this->deleteVariable(v);
+      }
     }
+  }
 
-    std::shared_ptr<Variable> variable(QUuid ID)
+  void _processTransactions(bool fragmented = false)
+  {
+    auto nextTransactions    = _transactions.nextTransactions();
+    auto pendingTransactions = _transactions.pendingTransactions();
+    for(auto [groupID, newTransaction] : nextTransactions)
     {
-        return _maps.variable(ID);
+      if(newTransaction.has_value() &&
+         !pendingTransactions[groupID].has_value())
+      {
+        _transactions.start(groupID);
+        auto refVar = _maps.variable(newTransaction.value()->refVar);
+        auto ranges =
+            _computeAllRangesInGroup(refVar, newTransaction.value()->range);
+        for(auto const& [ID, range] : ranges)
+        {
+          auto provider = _maps.provider(ID);
+          auto variable = _maps.variable(ID);
+          if(fragmented)
+          {
+            auto [missingRanges, newCacheRange] =
+                _computeMissingRanges(variable, range);
+
+            auto exe = new TransactionExe(variable, provider, missingRanges,
+                                          range, newCacheRange);
+            QObject::connect(
+                exe, &TransactionExe::transactionComplete,
+                [groupID = groupID, transaction = newTransaction.value(),
+                 this]() { this->_transactionComplete(groupID, transaction); });
+            _ThreadPool->start(exe);
+          }
+          else
+          {
+            auto exe =
+                new TransactionExe(variable, provider, {range}, range, range);
+            QObject::connect(
+                exe, &TransactionExe::transactionComplete,
+                [groupID = groupID, transaction = newTransaction.value(),
+                 this]() { this->_transactionComplete(groupID, transaction); });
+            _ThreadPool->start(exe);
+          }
+        }
+      }
     }
-
-    std::shared_ptr<Variable> variable(int index)
+    // after each transaction update we get a new distribution of idle and
+    // working variables so we can delete variables which are waiting to be
+    // deleted if they are now idle
+    _cleanupVariables();
+  }
+
+  std::map<QUuid, DateTimeRange>
+  _computeAllRangesInGroup(const std::shared_ptr<Variable>& refVar,
+                           DateTimeRange r)
+  {
+    std::map<QUuid, DateTimeRange> ranges;
+    if(!DateTimeRangeHelper::hasnan(r))
     {
-        return _maps.variable(index);
+      auto group = _maps.group(*refVar);
+      if(auto transformation =
+             DateTimeRangeHelper::computeTransformation(refVar->range(), r);
+         transformation.has_value())
+      {
+        for(auto varId : group->variables())
+        {
+          auto var      = _maps.variable(varId);
+          auto newRange = var->range().transform(transformation.value());
+          ranges[varId] = newRange;
+        }
+      }
+      else // force new range to all variables -> may be weird if more than one
+           // var in the group
+           // @TODO ensure that there is no side effects
+      {
+        for(auto varId : group->variables())
+        {
+          auto var      = _maps.variable(varId);
+          ranges[varId] = r;
+        }
+      }
     }
-
-    std::shared_ptr<Variable> cloneVariable(const std::shared_ptr<Variable>& variable)
+    else
     {
-        auto newVar = variable->clone();
-        _maps.synchronize(newVar,std::nullopt);
-        _maps.addVariable(newVar,_maps.provider(*variable),_maps.group(*newVar));
-        this->_transactions.addEntry(*_maps.group(*newVar));
-        return newVar;
+      SCIQLOP_ERROR(VariableController2Private, "Invalid range containing NaN");
     }
-
-    bool hasPendingTransactions(const std::shared_ptr<Variable>& variable)
+    return ranges;
+  }
+
+  std::pair<std::vector<DateTimeRange>, DateTimeRange>
+  _computeMissingRanges(const std::shared_ptr<Variable>& var, DateTimeRange r)
+  {
+    DateTimeRange newCacheRange;
+    std::vector<DateTimeRange> missingRanges;
+    if(DateTimeRangeHelper::hasnan(var->cacheRange()))
     {
-        return _transactions.active(*_maps.group(*variable));
+      newCacheRange = _cacheStrategy->computeRange(r, r);
+      missingRanges = {newCacheRange};
     }
-
-    bool hasPendingTransactions()
+    else
     {
-        bool has = false;
-        for(const auto& var:_maps.variables())
-        {
-            has |= _transactions.active(*_maps.group(*var));
-        }
-        return has;
+      newCacheRange = _cacheStrategy->computeRange(var->cacheRange(), r);
+      missingRanges = newCacheRange - var->cacheRange();
     }
-
-    void deleteVariable(const std::shared_ptr<Variable>& variable)
+    return {missingRanges, newCacheRange};
+  }
+
+  void _changeRange(QUuid id, DateTimeRange r)
+  {
+    _changeRange(_maps.variable(id), r);
+  }
+  void _changeRange(const std::shared_ptr<Variable>& var, DateTimeRange r)
+  {
+    auto provider                       = _maps.provider(*var);
+    auto [missingRanges, newCacheRange] = _computeMissingRanges(var, r);
+    std::vector<IDataSeries*> data;
+    for(auto range : missingRanges)
     {
-        if(!hasPendingTransactions(variable))
-            _maps.removeVariable(variable);
-        else
-            _variablesToRemove.push_back(variable->ID());
+      data.push_back(
+          provider->getData(DataProviderParameters{{range}, var->metadata()}));
     }
+    var->updateData(data, r, newCacheRange, true);
+  }
 
-    void asyncChangeRange(const std::shared_ptr<Variable>& variable, const DateTimeRange& r)
+public:
+  VariableController2Private(QObject* parent = Q_NULLPTR)
+      : _cacheStrategy(VariableCacheStrategyFactory::createCacheStrategy(
+            CacheStrategy::SingleThreshold))
+  {
+    Q_UNUSED(parent);
+    this->_ThreadPool = new QThreadPool();
+    this->_ThreadPool->setMaxThreadCount(32);
+  }
+
+  /*
+   * This dtor has to like this even if this is ugly, because default dtor would
+   * rely on declaration order to destruct members and that would always lead to
+   * regressions when modifying class members
+   */
+  ~VariableController2Private() { delete this->_ThreadPool; }
+
+  std::shared_ptr<Variable>
+  createVariable(const QString& name, const QVariantHash& metadata,
+                 std::shared_ptr<IDataProvider> provider)
+  {
+    auto newVar = std::make_shared<Variable>(name, metadata);
+    auto group  = std::make_shared<VariableSynchronizationGroup2>(newVar->ID());
+    _maps.addVariable(newVar, std::move(provider), group);
+    this->_transactions.addEntry(*group);
+    return newVar;
+  }
+
+  std::shared_ptr<Variable> variable(QUuid ID) { return _maps.variable(ID); }
+
+  std::shared_ptr<Variable> variable(int index)
+  {
+    return _maps.variable(index);
+  }
+
+  std::shared_ptr<Variable>
+  cloneVariable(const std::shared_ptr<Variable>& variable)
+  {
+    auto newVar = variable->clone();
+    _maps.synchronize(newVar, std::nullopt);
+    _maps.addVariable(newVar, _maps.provider(*variable), _maps.group(*newVar));
+    this->_transactions.addEntry(*_maps.group(*newVar));
+    return newVar;
+  }
+
+  bool hasPendingTransactions(const std::shared_ptr<Variable>& variable)
+  {
+    return _transactions.active(*_maps.group(*variable));
+  }
+
+  bool hasPendingTransactions()
+  {
+    bool has = false;
+    for(const auto& var : _maps.variables())
     {
-        if(!DateTimeRangeHelper::hasnan(r))
-        {
-            auto group = _maps.group(*variable);
-            // Just overwrite next transaction
-            {
-                _transactions.enqueue(*group,std::make_shared<VCTransaction>(variable->ID(), r, static_cast<int>(group->variables().size())));
-            }
-            _processTransactions();
-        }
-        else
-        {
-            SCIQLOP_ERROR(VariableController2Private, "Invalid range containing NaN");
-        }
+      has |= _transactions.active(*_maps.group(*var));
     }
+    return has;
+  }
 
-    void changeRange(const std::shared_ptr<Variable>& variable, DateTimeRange r)
+  void deleteVariable(const std::shared_ptr<Variable>& variable)
+  {
+    if(!hasPendingTransactions(variable))
+      _maps.removeVariable(variable);
+    else
+      _variablesToRemove.push_back(variable->ID());
+  }
+
+  void asyncChangeRange(const std::shared_ptr<Variable>& variable,
+                        const DateTimeRange& r)
+  {
+    if(!DateTimeRangeHelper::hasnan(r))
     {
-        asyncChangeRange(variable,r);
-        while (hasPendingTransactions(variable))
-        {
-            QCoreApplication::processEvents();
-        }
+      auto group = _maps.group(*variable);
+      // Just overwrite next transaction
+      {
+        _transactions.enqueue(*group,
+                              std::make_shared<VCTransaction>(
+                                  variable->ID(), r,
+                                  static_cast<int>(group->variables().size())));
+      }
+      _processTransactions();
     }
-
-    inline void synchronize(const std::shared_ptr<Variable>& var, const std::shared_ptr<Variable>& with)
+    else
     {
-        _maps.synchronize(var, with);
+      SCIQLOP_ERROR(VariableController2Private, "Invalid range containing NaN");
     }
+  }
 
-    inline const std::vector<std::shared_ptr<Variable>> variables()
+  void changeRange(const std::shared_ptr<Variable>& variable, DateTimeRange r)
+  {
+    asyncChangeRange(variable, r);
+    while(hasPendingTransactions(variable))
     {
-        return _maps.variables();
+      QCoreApplication::processEvents();
     }
-
+  }
+
+  inline void synchronize(const std::shared_ptr<Variable>& var,
+                          const std::shared_ptr<Variable>& with)
+  {
+    _maps.synchronize(var, with);
+  }
+
+  inline const std::vector<std::shared_ptr<Variable>> variables()
+  {
+    return _maps.variables();
+  }
 };
 
 VariableController2::VariableController2()
-    :impl{spimpl::make_unique_impl<VariableController2Private>()}
+    : impl{spimpl::make_unique_impl<VariableController2Private>()}
 {}
 
-std::shared_ptr<Variable> VariableController2::createVariable(const QString &name, const QVariantHash &metadata, const std::shared_ptr<IDataProvider>& provider, const DateTimeRange &range)
+std::shared_ptr<Variable> VariableController2::createVariable(
+    const QString& name, const QVariantHash& metadata,
+    const std::shared_ptr<IDataProvider>& provider, const DateTimeRange& range)
 {
-    auto var =  impl->createVariable(name, metadata, provider);
-    var->setRange(range); // even with no data this is it's range
-    if(!DateTimeRangeHelper::hasnan(range))
-        impl->asyncChangeRange(var,range);
-    else
-        SCIQLOP_ERROR(VariableController2, "Creating a variable with default constructed DateTimeRange is an error");
-    emit variableAdded(var);
-    return var;
+  auto var = impl->createVariable(name, metadata, provider);
+  var->setRange(range); // even with no data this is it's range
+  if(!DateTimeRangeHelper::hasnan(range))
+    impl->asyncChangeRange(var, range);
+  else
+    SCIQLOP_ERROR(VariableController2, "Creating a variable with default "
+                                       "constructed DateTimeRange is an error");
+  emit variableAdded(var);
+  return var;
 }
 
-std::shared_ptr<Variable> VariableController2::cloneVariable(const std::shared_ptr<Variable> &variable)
+std::shared_ptr<Variable>
+VariableController2::cloneVariable(const std::shared_ptr<Variable>& variable)
 {
-    return impl->cloneVariable(variable);
+  return impl->cloneVariable(variable);
 }
 
-void VariableController2::deleteVariable(const std::shared_ptr<Variable>& variable)
+void VariableController2::deleteVariable(
+    const std::shared_ptr<Variable>& variable)
 {
-    impl->deleteVariable(variable);
-    emit variableDeleted(variable);
+  impl->deleteVariable(variable);
+  emit variableDeleted(variable);
 }
 
-void VariableController2::changeRange(const std::shared_ptr<Variable>& variable, const DateTimeRange& r)
+void VariableController2::changeRange(const std::shared_ptr<Variable>& variable,
+                                      const DateTimeRange& r)
 {
-    impl->changeRange(variable, r);
+  impl->changeRange(variable, r);
 }
 
-void VariableController2::asyncChangeRange(const std::shared_ptr<Variable> &variable, const DateTimeRange &r)
+void VariableController2::asyncChangeRange(
+    const std::shared_ptr<Variable>& variable, const DateTimeRange& r)
 {
-    impl->asyncChangeRange(variable, r);
+  impl->asyncChangeRange(variable, r);
 }
 
-const std::vector<std::shared_ptr<Variable> > VariableController2::variables()
+const std::vector<std::shared_ptr<Variable>> VariableController2::variables()
 {
-    return impl->variables();
+  return impl->variables();
 }
 
-bool VariableController2::isReady(const std::shared_ptr<Variable> &variable)
+bool VariableController2::isReady(const std::shared_ptr<Variable>& variable)
 {
-    return !impl->hasPendingTransactions(variable);
+  return !impl->hasPendingTransactions(variable);
 }
 
-bool VariableController2::isReady()
-{
-    return !impl->hasPendingTransactions();
-}
+bool VariableController2::isReady() { return !impl->hasPendingTransactions(); }
 
-void VariableController2::synchronize(const std::shared_ptr<Variable> &var, const std::shared_ptr<Variable> &with)
+void VariableController2::synchronize(const std::shared_ptr<Variable>& var,
+                                      const std::shared_ptr<Variable>& with)
 {
-    impl->synchronize(var, with);
+  impl->synchronize(var, with);
 }
 
-const std::vector<std::shared_ptr<Variable>> VariableController2::variables(const std::vector<QUuid> &ids)
+const std::vector<std::shared_ptr<Variable>>
+VariableController2::variables(const std::vector<QUuid>& ids)
 {
-    std::vector<std::shared_ptr<Variable>> variables;
-    for (const auto& id : ids) {
-        variables.push_back(impl->variable(id));
-    }
-    return variables;
+  std::vector<std::shared_ptr<Variable>> variables;
+  std::transform(std::cbegin(ids), std::cend(ids),
+                 std::back_inserter(variables),
+                 [this](const auto& id) { return impl->variable(id); });
+  return variables;
 }
diff --git a/src/pybind11_wrappers/CoreWrappers.cpp b/src/pybind11_wrappers/CoreWrappers.cpp
index 3b3c2dd..6064161 100644
--- a/src/pybind11_wrappers/CoreWrappers.cpp
+++ b/src/pybind11_wrappers/CoreWrappers.cpp
@@ -1,157 +1,177 @@
-#include <pybind11/pybind11.h>
-#include <pybind11/operators.h>
-#include <pybind11/embed.h>
-#include <pybind11/numpy.h>
-#include <pybind11/chrono.h>
-#include <pybind11/functional.h>
-#include <pybind11/stl.h>
-
-
-#include <string>
-#include <sstream>
+#include "CoreWrappers.h"
 
 #include "pywrappers_common.h"
-#include "CoreWrappers.h"
 
 #include <Data/DataSeriesType.h>
+#include <Data/IDataProvider.h>
+#include <Data/OptionalAxis.h>
 #include <Data/ScalarSeries.h>
-#include <Data/VectorSeries.h>
 #include <Data/SpectrogramSeries.h>
 #include <Data/Unit.h>
-#include <Data/OptionalAxis.h>
-#include <Data/IDataProvider.h>
-
-#include <Variable/VariableController2.h>
-
-#include <Time/TimeController.h>
-
+#include <Data/VectorSeries.h>
 #include <Network/Downloader.h>
-
-
+#include <Time/TimeController.h>
+#include <Variable/VariableController2.h>
+#include <pybind11/chrono.h>
+#include <pybind11/embed.h>
+#include <pybind11/functional.h>
+#include <pybind11/numpy.h>
+#include <pybind11/operators.h>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <sstream>
+#include <string>
 
 namespace py = pybind11;
 using namespace std::chrono;
 
-PYBIND11_MODULE(pysciqlopcore,m){
-
-    py::enum_<DataSeriesType>(m, "DataSeriesType")
-            .value("SCALAR", DataSeriesType::SCALAR)
-            .value("SPECTROGRAM", DataSeriesType::SPECTROGRAM)
-            .value("VECTOR", DataSeriesType::VECTOR)
-            .value("UNKNOWN", DataSeriesType::UNKNOWN)
-            .export_values();
-
-    py::class_<Unit>(m, "Unit")
-            .def_readwrite("name", &Unit::m_Name)
-            .def_readwrite("time_unit", &Unit::m_TimeUnit)
-            .def(py::self == py::self)
-            .def(py::self != py::self)
-            .def("__repr__",__repr__<Unit>);
-
-    py::class_<Response>(m,"Response")
-            .def("status_code", &Response::status_code);
-
-    py::class_<Downloader>(m,"Downloader")
-            .def_static("get", Downloader::get)
-            .def_static("getAsync", Downloader::getAsync)
-            .def_static("downloadFinished", Downloader::downloadFinished);
-
-    py::class_<ArrayDataIteratorValue>(m, "ArrayDataIteratorValue")
-            .def_property_readonly("value", &ArrayDataIteratorValue::first);
-
-    py::class_<OptionalAxis>(m, "OptionalAxis")
-            .def("__len__", &OptionalAxis::size)
-            .def_property_readonly("size", &OptionalAxis::size)
-            .def("__getitem__", [](OptionalAxis& ax, int key) {
-                    return (*(ax.begin()+key)).first();
-                }, py::is_operator())
-            .def("__iter__", [](OptionalAxis& ax) {
-                    return py::make_iterator(ax.begin(), ax.end());
-                }, py::keep_alive<0, 1>());
-
-    py::class_<DataSeriesIteratorValue>(m,"DataSeriesIteratorValue")
-            .def_property_readonly("x", &DataSeriesIteratorValue::x)
-            .def_property_readonly("y", &DataSeriesIteratorValue::y)
-            .def("value", py::overload_cast<>(&DataSeriesIteratorValue::value, py::const_))
-            .def("value", py::overload_cast<int>(&DataSeriesIteratorValue::value, py::const_))
-            .def("values", &DataSeriesIteratorValue::values);
-
-    py::class_<IDataSeries, std::shared_ptr<IDataSeries>>(m, "IDataSeries")
-            .def("nbPoints", &IDataSeries::nbPoints)
-            .def_property_readonly("xAxisUnit", &IDataSeries::xAxisUnit)
-            .def_property_readonly("yAxisUnit", &IDataSeries::yAxisUnit)
-            .def_property_readonly("valuesUnit", &IDataSeries::valuesUnit)
-            .def("__getitem__", [](IDataSeries& serie, int key) {
-        return *(serie.begin()+key);
-    }, py::is_operator())
-            .def("__len__", &IDataSeries::nbPoints)
-            .def("__iter__", [](IDataSeries& serie) {
-        return py::make_iterator(serie.begin(), serie.end());
-    }, py::keep_alive<0, 1>())
-            .def("__repr__",__repr__<IDataSeries>);
-
-    py::class_<ArrayData<1>, std::shared_ptr<ArrayData<1>> >(m,"ArrayData1d")
-            .def("cdata", [](ArrayData<1>& array) {return array.cdata();});
-
-    py::class_<ScalarSeries, std::shared_ptr<ScalarSeries>, IDataSeries>(m, "ScalarSeries")
-            .def("nbPoints", &ScalarSeries::nbPoints);
-
-    py::class_<VectorSeries, std::shared_ptr<VectorSeries>, IDataSeries>(m, "VectorSeries")
-            .def("nbPoints", &VectorSeries::nbPoints);
-
-    py::class_<DataSeries<2>, std::shared_ptr<DataSeries<2>>, IDataSeries>(m,"DataSeries2d")
-            .def_property_readonly("xAxis", py::overload_cast<>(&DataSeries<2>::xAxisData, py::const_))
-            .def_property_readonly("yAxis", py::overload_cast<>(&DataSeries<2>::yAxis, py::const_));
-
-    py::class_<SpectrogramSeries, std::shared_ptr<SpectrogramSeries>, DataSeries<2>>(m, "SpectrogramSeries")
-            .def("nbPoints", &SpectrogramSeries::nbPoints)
-            .def("xRes", &SpectrogramSeries::xResolution);
-
-
-    py::class_<IDataProvider, std::shared_ptr<IDataProvider>>(m, "IDataProvider");
-
-
-    py::class_<Variable,std::shared_ptr<Variable>>(m, "Variable")
-            .def(py::init<const QString&>())
-            .def_property("name", &Variable::name, &Variable::setName)
-            .def_property("range", &Variable::range, &Variable::setRange)
-            .def_property("cacheRange", &Variable::cacheRange, &Variable::setCacheRange)
-            .def_property_readonly("nbPoints", &Variable::nbPoints)
-            .def_property_readonly("dataSeries", &Variable::dataSeries)
-            .def("__len__", [](Variable& variable) {
-        auto rng = variable.dataSeries()->xAxisRange(variable.range().m_TStart,variable.range().m_TEnd);
-        return std::distance(rng.first,rng.second);
-    })
-            .def("__iter__", [](Variable& variable) {
-        auto rng = variable.dataSeries()->xAxisRange(variable.range().m_TStart,variable.range().m_TEnd);
-        return py::make_iterator(rng.first, rng.second);
-    }, py::keep_alive<0, 1>())
-            .def("__getitem__", [](Variable& variable, int key) {
-        //insane and slow!
-        auto rng = variable.dataSeries()->xAxisRange(variable.range().m_TStart,variable.range().m_TEnd);
-        if(key<0)
-            return *(rng.second+key);
-        else
-            return *(rng.first+key);
-    })
-            .def("__repr__",__repr__<Variable>);
-
-
-    py::class_<DateTimeRange>(m,"SqpRange")
-            //.def("fromDateTime", &DateTimeRange::fromDateTime, py::return_value_policy::move)
-            .def(py::init([](double start, double stop){return DateTimeRange{start, stop};}))
-            .def(py::init([](system_clock::time_point start, system_clock::time_point stop)
-    {
-                     double start_ = 0.001 * duration_cast<milliseconds>(start.time_since_epoch()).count();
-                     double stop_ = 0.001 * duration_cast<milliseconds>(stop.time_since_epoch()).count();
-                     return DateTimeRange{start_, stop_};
-                 }))
-            .def_property_readonly("start", [](const DateTimeRange& range){
-        return  system_clock::from_time_t(range.m_TStart);
-    })
-            .def_property_readonly("stop", [](const DateTimeRange& range){
-        return  system_clock::from_time_t(range.m_TEnd);
-    })
-            .def("__repr__", __repr__<DateTimeRange>);
-
+PYBIND11_MODULE(pysciqlopcore, m)
+{
+  py::enum_<DataSeriesType>(m, "DataSeriesType")
+      .value("SCALAR", DataSeriesType::SCALAR)
+      .value("SPECTROGRAM", DataSeriesType::SPECTROGRAM)
+      .value("VECTOR", DataSeriesType::VECTOR)
+      .value("UNKNOWN", DataSeriesType::UNKNOWN)
+      .export_values();
+
+  py::class_<Unit>(m, "Unit")
+      .def_readwrite("name", &Unit::m_Name)
+      .def_readwrite("time_unit", &Unit::m_TimeUnit)
+      .def(py::self == py::self)
+      .def(py::self != py::self)
+      .def("__repr__", __repr__<Unit>);
+
+  py::class_<Response>(m, "Response")
+      .def("status_code", &Response::status_code);
+
+  py::class_<Downloader>(m, "Downloader")
+      .def_static("get", Downloader::get)
+      .def_static("getAsync", Downloader::getAsync)
+      .def_static("downloadFinished", Downloader::downloadFinished);
+
+  py::class_<ArrayDataIteratorValue>(m, "ArrayDataIteratorValue")
+      .def_property_readonly("value", &ArrayDataIteratorValue::first);
+
+  py::class_<OptionalAxis>(m, "OptionalAxis")
+      .def("__len__", &OptionalAxis::size)
+      .def_property_readonly("size", &OptionalAxis::size)
+      .def("__getitem__",
+           [](OptionalAxis& ax, int key) {
+             return (*(ax.begin() + key)).first();
+           },
+           py::is_operator())
+      .def("__iter__",
+           [](OptionalAxis& ax) {
+             return py::make_iterator(ax.begin(), ax.end());
+           },
+           py::keep_alive<0, 1>());
+
+  py::class_<DataSeriesIteratorValue>(m, "DataSeriesIteratorValue")
+      .def_property_readonly("x", &DataSeriesIteratorValue::x)
+      .def_property_readonly("y", &DataSeriesIteratorValue::y)
+      .def("value",
+           py::overload_cast<>(&DataSeriesIteratorValue::value, py::const_))
+      .def("value",
+           py::overload_cast<int>(&DataSeriesIteratorValue::value, py::const_))
+      .def("values", &DataSeriesIteratorValue::values);
+
+  py::class_<IDataSeries, std::shared_ptr<IDataSeries>>(m, "IDataSeries")
+      .def("nbPoints", &IDataSeries::nbPoints)
+      .def_property_readonly("xAxisUnit", &IDataSeries::xAxisUnit)
+      .def_property_readonly("yAxisUnit", &IDataSeries::yAxisUnit)
+      .def_property_readonly("valuesUnit", &IDataSeries::valuesUnit)
+      .def("__getitem__",
+           [](IDataSeries& serie, int key) { return *(serie.begin() + key); },
+           py::is_operator())
+      .def("__len__", &IDataSeries::nbPoints)
+      .def("__iter__",
+           [](IDataSeries& serie) {
+             return py::make_iterator(serie.begin(), serie.end());
+           },
+           py::keep_alive<0, 1>())
+      .def("__repr__", __repr__<IDataSeries>);
+
+  py::class_<ArrayData<1>, std::shared_ptr<ArrayData<1>>>(m, "ArrayData1d")
+      .def("cdata", [](ArrayData<1>& array) { return array.cdata(); });
+
+  py::class_<ScalarSeries, std::shared_ptr<ScalarSeries>, IDataSeries>(
+      m, "ScalarSeries")
+      .def("nbPoints", &ScalarSeries::nbPoints);
+
+  py::class_<VectorSeries, std::shared_ptr<VectorSeries>, IDataSeries>(
+      m, "VectorSeries")
+      .def("nbPoints", &VectorSeries::nbPoints);
+
+  py::class_<DataSeries<2>, std::shared_ptr<DataSeries<2>>, IDataSeries>(
+      m, "DataSeries2d")
+      .def_property_readonly(
+          "xAxis", py::overload_cast<>(&DataSeries<2>::xAxisData, py::const_))
+      .def_property_readonly(
+          "yAxis", py::overload_cast<>(&DataSeries<2>::yAxis, py::const_));
+
+  py::class_<SpectrogramSeries, std::shared_ptr<SpectrogramSeries>,
+             DataSeries<2>>(m, "SpectrogramSeries")
+      .def("nbPoints", &SpectrogramSeries::nbPoints)
+      .def("xRes", &SpectrogramSeries::xResolution);
+
+  py::class_<IDataProvider, std::shared_ptr<IDataProvider>>(m, "IDataProvider");
+
+  py::class_<Variable, std::shared_ptr<Variable>>(m, "Variable")
+      .def(py::init<const QString&>())
+      .def_property("name", &Variable::name, &Variable::setName)
+      .def_property("range", &Variable::range, &Variable::setRange)
+      .def_property("cacheRange", &Variable::cacheRange,
+                    &Variable::setCacheRange)
+      .def_property_readonly("nbPoints", &Variable::nbPoints)
+      .def_property_readonly("dataSeries", &Variable::dataSeries)
+      .def("__len__",
+           [](Variable& variable) {
+             auto rng = variable.dataSeries()->xAxisRange(
+                 variable.range().m_TStart, variable.range().m_TEnd);
+             return std::distance(rng.first, rng.second);
+           })
+      .def("__iter__",
+           [](Variable& variable) {
+             auto rng = variable.dataSeries()->xAxisRange(
+                 variable.range().m_TStart, variable.range().m_TEnd);
+             return py::make_iterator(rng.first, rng.second);
+           },
+           py::keep_alive<0, 1>())
+      .def("__getitem__",
+           [](Variable& variable, int key) {
+             // insane and slow!
+             auto rng = variable.dataSeries()->xAxisRange(
+                 variable.range().m_TStart, variable.range().m_TEnd);
+             if(key < 0)
+               return *(rng.second + key);
+             else
+               return *(rng.first + key);
+           })
+      .def("__repr__", __repr__<Variable>);
+
+  py::class_<DateTimeRange>(m, "SqpRange")
+      //.def("fromDateTime", &DateTimeRange::fromDateTime,
+      //py::return_value_policy::move)
+      .def(py::init([](double start, double stop) {
+        return DateTimeRange{start, stop};
+      }))
+      .def(py::init(
+          [](system_clock::time_point start, system_clock::time_point stop) {
+            double start_ =
+                0.001 *
+                duration_cast<milliseconds>(start.time_since_epoch()).count();
+            double stop_ =
+                0.001 *
+                duration_cast<milliseconds>(stop.time_since_epoch()).count();
+            return DateTimeRange{start_, stop_};
+          }))
+      .def_property_readonly("start",
+                             [](const DateTimeRange& range) {
+                               return system_clock::from_time_t(range.m_TStart);
+                             })
+      .def_property_readonly("stop",
+                             [](const DateTimeRange& range) {
+                               return system_clock::from_time_t(range.m_TEnd);
+                             })
+      .def("__repr__", __repr__<DateTimeRange>);
 }