diff --git a/include/DataSource/DataSourceController.h b/include/DataSource/DataSourceController.h
index 209c0e2..b58c10f 100644
--- a/include/DataSource/DataSourceController.h
+++ b/include/DataSource/DataSourceController.h
@@ -92,7 +92,7 @@ signals:
      * @param variableProvider the provider that will be used to retrieve the data of the variable
      * (can be null)
      */
-    void variableCreationRequested(const QString &variableName,
+    void createVariable(const QString &variableName,
                                    const QVariantHash &variableMetadata,
                                    std::shared_ptr<IDataProvider> variableProvider);
 
diff --git a/include/Variable/Variable.h b/include/Variable/Variable.h
index 4a72a0d..293d1fc 100644
--- a/include/Variable/Variable.h
+++ b/include/Variable/Variable.h
@@ -7,6 +7,7 @@
 #include <QObject>
 #include <QUuid>
 #include <QReadWriteLock>
+#include <QDataStream>
 
 #include "CoreGlobal.h"
 #include <Data/DataSeriesIterator.h>
@@ -69,6 +70,30 @@ public:
                     const DateTimeRange& newRange, const DateTimeRange& newCacheRange,
                     bool notify=true);
 
+    static QByteArray mimeData(const std::vector<std::shared_ptr<Variable> > &variables)
+    {
+        auto encodedData = QByteArray{};
+        QDataStream stream{&encodedData, QIODevice::WriteOnly};
+        for (auto &var : variables) {
+            stream << var->ID().toByteArray();
+        }
+        return encodedData;
+    }
+
+    static std::vector<QUuid> variablesIDs(QByteArray mimeData)
+    {
+        std::vector<QUuid> variables;
+        QDataStream stream{mimeData};
+
+        QVariantList ids;
+        stream >> ids;
+
+        for (const auto& id : ids) {
+            variables.emplace_back (id.toByteArray());
+        }
+        return variables;
+    }
+
 DEPRECATE(
 
     bool contains(const DateTimeRange &range) const noexcept;
diff --git a/include/Variable/VariableController2.h b/include/Variable/VariableController2.h
index b0a2152..6ea9a1b 100644
--- a/include/Variable/VariableController2.h
+++ b/include/Variable/VariableController2.h
@@ -37,9 +37,7 @@ public:
 
     void synchronize(const std::shared_ptr<Variable>& var, const std::shared_ptr<Variable>& with);
 
-    //This should be somewhere else VC has nothing to do with MIMEData
-    QByteArray mimeData(const std::vector<std::shared_ptr<Variable>> &variables) const;
-    const std::vector<std::shared_ptr<Variable>> variables(QByteArray mimeData);
+    const std::vector<std::shared_ptr<Variable>> variables(const std::vector<QUuid>& ids);
 
     const std::shared_ptr<Variable>& operator[] (int index) const;
     std::shared_ptr<Variable> operator[] (int index);
diff --git a/include/Variable/VariableModel2.h b/include/Variable/VariableModel2.h
index 960aea6..b176a55 100644
--- a/include/Variable/VariableModel2.h
+++ b/include/Variable/VariableModel2.h
@@ -24,9 +24,10 @@ enum VariableRoles { ProgressRole = Qt::UserRole };
  */
 class SCIQLOP_CORE_EXPORT VariableModel2 : public QAbstractTableModel {
     Q_OBJECT
-    std::shared_ptr<VariableController2> _variableController;
+    // read only mirror of VariableController2 content
+    std::vector<std::shared_ptr<Variable>> _variables;
 public:
-    explicit VariableModel2(const std::shared_ptr<VariableController2>& variableController, QObject *parent = nullptr);
+    explicit VariableModel2(QObject *parent = nullptr);
 
     // /////////////////////////// //
     // QAbstractTableModel methods //
@@ -52,12 +53,14 @@ public:
     virtual bool dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column,
                               const QModelIndex &parent) override;
 
-
 signals:
-
-private slots:
+    void createVariable(const QVariantHash &productData);
+    void asyncChangeRange(const std::shared_ptr<Variable>& variable, const DateTimeRange& r);
+public slots:
     /// Slot called when data of a variable has been updated
     void variableUpdated() noexcept;
+    void variableAdded(const std::shared_ptr<Variable>&);
+    void variableDeleted(const std::shared_ptr<Variable>&);
 };
 
 #endif // SCIQLOP_VARIABLEMODEL2_H
diff --git a/src/DataSource/DataSourceController.cpp b/src/DataSource/DataSourceController.cpp
index 4b67a2b..d8af2a8 100644
--- a/src/DataSource/DataSourceController.cpp
+++ b/src/DataSource/DataSourceController.cpp
@@ -123,7 +123,7 @@ void DataSourceController::loadProductItem(const QUuid &dataSourceUid,
         auto it = impl->m_DataProviders.find(dataSourceUid);
         auto dataProvider = (it != impl->m_DataProviders.end()) ? it->second : nullptr;
 
-        emit variableCreationRequested(productItem.name(), productItem.data(), dataProvider);
+        emit createVariable(productItem.name(), productItem.data(), dataProvider);
     }
     else {
         qCWarning(LOG_DataSourceController()) << tr("Can't load an item that is not a product");
diff --git a/src/Variable/VariableController2.cpp b/src/Variable/VariableController2.cpp
index fbc0967..53b6c76 100644
--- a/src/Variable/VariableController2.cpp
+++ b/src/Variable/VariableController2.cpp
@@ -32,7 +32,7 @@ class VariableController2::VariableController2Private
         inline void removeVariable(const std::shared_ptr<Variable>& variable)
         {
             QWriteLocker lock{&_lock};
-            _variables.remove(*variable);
+            _variables.erase(*variable);
             _providers.remove(*variable);
             _synchronizationGroups.remove(*variable);
         }
@@ -55,10 +55,11 @@ class VariableController2::VariableController2Private
         inline std::shared_ptr<Variable> variable(QUuid variable)
         {
             QReadLocker lock{&_lock};
+            auto it = _variables.find(variable);
             [[unlikely]]
-            if(!_variables.contains(variable))
+            if(it==_variables.end())
                 SCIQLOP_ERROR(threadSafeVaraiblesMaps,"Unknown Variable");
-            return _variables[variable];
+            return (*it).second;
         }
 
         inline std::shared_ptr<Variable> variable(int index)
@@ -67,14 +68,19 @@ class VariableController2::VariableController2Private
             [[unlikely]]
             if(!_variables.size() > index)
                 SCIQLOP_ERROR(threadSafeVaraiblesMaps,"Index is out of bounds");
-            return _variables.values()[index];
+            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  &var:_variables)
+            for(const auto&[id, var]:_variables)
             {
                 vars.push_back(var);
             }
@@ -102,11 +108,11 @@ class VariableController2::VariableController2Private
         inline bool has(const std::shared_ptr<Variable>& variable)
         {
             QReadLocker lock{&_lock};
-            return _variables.contains(*variable);
+            return _variables.find(*variable)==_variables.end();
         }
 
     private:
-        QMap<QUuid,std::shared_ptr<Variable>> _variables;
+        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};
@@ -366,29 +372,12 @@ void VariableController2::synchronize(const std::shared_ptr<Variable> &var, cons
     impl->synchronize(var, with);
 }
 
-QByteArray VariableController2::mimeData(const std::vector<std::shared_ptr<Variable> > &variables) const
-{
-    auto encodedData = QByteArray{};
-    QDataStream stream{&encodedData, QIODevice::WriteOnly};
-    for (auto &var : variables) {
-        stream << var->ID().toByteArray();
-    }
-    return encodedData;
-}
-
-const std::vector<std::shared_ptr<Variable>> VariableController2::variables(QByteArray mimeData)
+const std::vector<std::shared_ptr<Variable>> VariableController2::variables(const std::vector<QUuid> &ids)
 {
     std::vector<std::shared_ptr<Variable>> variables;
-    QDataStream stream{mimeData};
-
-    QVariantList ids;
-    stream >> ids;
-
     for (const auto& id : ids) {
-        auto uuid = QUuid{id.toByteArray()};
-        variables.push_back (impl->variable(uuid));
+        variables.push_back(impl->variable(id));
     }
-
     return variables;
 }
 
diff --git a/src/Variable/VariableModel2.cpp b/src/Variable/VariableModel2.cpp
index 61f81ad..2d89231 100644
--- a/src/Variable/VariableModel2.cpp
+++ b/src/Variable/VariableModel2.cpp
@@ -1,3 +1,8 @@
+#include <QMimeData>
+#include <QSize>
+#include <QTimer>
+#include <unordered_map>
+
 #include <Variable/Variable.h>
 #include <Variable/VariableController2.h>
 #include <Variable/VariableModel2.h>
@@ -5,17 +10,13 @@
 #include <Common/DateUtils.h>
 #include <Common/MimeTypesDef.h>
 #include <Common/StringUtils.h>
+#include <Common/containers.h>
 
 #include <Data/IDataSeries.h>
 
 #include <DataSource/DataSourceController.h>
 #include <Time/TimeController.h>
 
-#include <QMimeData>
-#include <QSize>
-#include <QTimer>
-#include <unordered_map>
-
 namespace {
 
 // Column indexes
@@ -66,8 +67,8 @@ QString uniqueName(const QString &defaultName,
 
 
 
-VariableModel2::VariableModel2(const std::shared_ptr<VariableController2> &variableController, QObject *parent)
-    : QAbstractTableModel{parent}, _variableController{variableController}
+VariableModel2::VariableModel2(QObject *parent)
+    : QAbstractTableModel{parent}
 {
 }
 
@@ -82,7 +83,7 @@ int VariableModel2::columnCount(const QModelIndex &parent) const
 int VariableModel2::rowCount(const QModelIndex &parent) const
 {
     Q_UNUSED(parent);
-    return static_cast<int>(_variableController->variables().size());
+    return _variables.size();
 }
 
 QVariant VariableModel2::data(const QModelIndex &index, int role) const
@@ -96,7 +97,7 @@ QVariant VariableModel2::data(const QModelIndex &index, int role) const
     }
 
     if (role == Qt::DisplayRole) {
-        if (auto variable = _variableController->variables()[index.row()]) {
+        if (auto variable = _variables[index.row()]) {
             switch (index.column()) {
                 case NAME_COLUMN:
                     return variable->name();
@@ -178,19 +179,19 @@ QMimeData *VariableModel2::mimeData(const QModelIndexList &indexes) const
     DateTimeRange firstTimeRange;
     for (const auto &index : indexes) {
         if (index.column() == 0) { // only the first column
-            auto variable = _variableController->variables()[index.row()];
+            auto variable = _variables[index.row()];
             if (variable.get() && index.isValid()) {
 
                 if (variables.size()==0) {
                     // Gets the range of the first variable
-                    firstTimeRange = std::move(variable->range());
+                    firstTimeRange = variable->range();
                 }
                 variables.push_back(variable);
             }
         }
     }
 
-    auto variablesEncodedData = _variableController->mimeData(variables);
+    auto variablesEncodedData = Variable::mimeData(variables);
     mimeData->setData(MIME_TYPE_VARIABLE_LIST, variablesEncodedData);
 
     if (variables.size() == 1) {
@@ -205,6 +206,7 @@ QMimeData *VariableModel2::mimeData(const QModelIndexList &indexes) const
 bool VariableModel2::canDropMimeData(const QMimeData *data, Qt::DropAction action, int row,
                                     int column, const QModelIndex &parent) const
 {
+    Q_UNUSED(column);
     // drop of a product
     return data->hasFormat(MIME_TYPE_PRODUCT_LIST)
            || (data->hasFormat(MIME_TYPE_TIME_RANGE) && parent.isValid()
@@ -221,17 +223,16 @@ bool VariableModel2::dropMimeData(const QMimeData *data, Qt::DropAction action, 
             = DataSourceController::productsDataForMimeData(data->data(MIME_TYPE_PRODUCT_LIST));
 
         for (auto metaData : productList) {
-            //emit requestVariable(metaData.toHash());
-            //@TODO No idea what this does
+            emit createVariable(metaData.toHash());
         }
 
         dropDone = true;
     }
     else if (data->hasFormat(MIME_TYPE_TIME_RANGE) && parent.isValid()) {
-        auto variable = _variableController->variables()[parent.row()];
+        auto variable = _variables[parent.row()];
         auto range = TimeController::timeRangeForMimeData(data->data(MIME_TYPE_TIME_RANGE));
 
-        _variableController->asyncChangeRange(variable, range);
+        emit asyncChangeRange(variable, range);
 
         dropDone = true;
     }
@@ -241,6 +242,29 @@ bool VariableModel2::dropMimeData(const QMimeData *data, Qt::DropAction action, 
 
 void VariableModel2::variableUpdated() noexcept
 {
+    emit dataChanged(QModelIndex(),QModelIndex());
+}
 
+void VariableModel2::variableAdded(const std::shared_ptr<Variable> & variable)
+{
+    if(!SciQLop::containers::contains(_variables,variable))
+    {
+        beginInsertRows(QModelIndex(), this->_variables.size(), this->_variables.size());
+        this->_variables.push_back(variable);
+        endInsertRows();
+        connect(variable.get(),&Variable::updated,this,&VariableModel2::variableUpdated);
+    }
+}
+
+void VariableModel2::variableDeleted(const std::shared_ptr<Variable> &variable)
+{
+    auto it = std::find(_variables.begin(), _variables.end(), variable);
+    if (it != _variables.end())
+    {
+      auto index = std::distance(_variables.begin(), it);
+      beginRemoveRows(QModelIndex(), index, index);
+      _variables.erase(it);
+      endRemoveRows();
+    }
 }