diff --git a/core/include/Variable/VariableCacheStrategy.h b/core/include/Variable/VariableCacheStrategy.h
index da94ff4..54d401a 100644
--- a/core/include/Variable/VariableCacheStrategy.h
+++ b/core/include/Variable/VariableCacheStrategy.h
@@ -18,23 +18,14 @@ Q_DECLARE_LOGGING_CATEGORY(LOG_VariableCacheStrategy)
 
 class Variable;
 
-/**
- * Possible types of zoom operation
- */
-enum class CacheStrategy { FixedTolerance, TwoThreashold };
-
 /// This class aims to hande the cache strategy.
-class SCIQLOP_CORE_EXPORT VariableCacheStrategy : public QObject {
-    Q_OBJECT
-public:
-    explicit VariableCacheStrategy(QObject *parent = 0);
-
-    std::pair<SqpRange, SqpRange> computeStrategyRanges(const SqpRange &vRange,
-                                                        const SqpRange &rangeRequested);
+class SCIQLOP_CORE_EXPORT VariableCacheStrategy {
 
-private:
-    class VariableCacheStrategyPrivate;
-    spimpl::unique_impl_ptr<VariableCacheStrategyPrivate> impl;
+public:
+    virtual std::pair<SqpRange, SqpRange> computeRange(const SqpRange &vRange,
+                                                       const SqpRange &rangeRequested)
+        = 0;
 };
 
+
 #endif // SCIQLOP_VARIABLECACHESTRATEGY_H
diff --git a/core/include/Variable/VariableCacheStrategyFactory.h b/core/include/Variable/VariableCacheStrategyFactory.h
new file mode 100644
index 0000000..a7ec00c
--- /dev/null
+++ b/core/include/Variable/VariableCacheStrategyFactory.h
@@ -0,0 +1,44 @@
+#ifndef SCIQLOP_VARIABLECACHESTRATEGYFACTORY_H
+#define SCIQLOP_VARIABLECACHESTRATEGYFACTORY_H
+
+
+#include <memory>
+#include <stdexcept>
+
+#include "VariableCacheStrategy.h"
+#include "VariableSingleThresholdCacheStrategy.h"
+
+#include <QLoggingCategory>
+#include <QString>
+
+Q_LOGGING_CATEGORY(LOG_VariableCacheStrategyFactory, "VariableCacheStrategyFactory")
+
+enum class CacheStrategy { SingleThreshold, TwoThreashold };
+
+class VariableCacheStrategyFactory {
+
+    using cacheStratPtr = std::unique_ptr<VariableCacheStrategy>;
+
+public:
+    static cacheStratPtr createCacheStrategy(CacheStrategy specificStrategy)
+    {
+        switch (specificStrategy) {
+            case CacheStrategy::SingleThreshold: {
+                return std::unique_ptr<VariableCacheStrategy>{
+                    new VariableSingleThresholdCacheStrategy{}};
+                break;
+            }
+            case CacheStrategy::TwoThreashold: {
+                qCCritical(LOG_VariableCacheStrategyFactory())
+                    << QObject::tr("cache strategy not implemented yet");
+                break;
+            }
+            default:
+                qCCritical(LOG_VariableCacheStrategyFactory())
+                    << QObject::tr("Unknown cache strategy");
+        }
+    }
+};
+
+
+#endif // VARIABLECACHESTRATEGYFACTORY_H
diff --git a/core/include/Variable/VariableSingleThresholdCacheStrategy.h b/core/include/Variable/VariableSingleThresholdCacheStrategy.h
new file mode 100644
index 0000000..66be152
--- /dev/null
+++ b/core/include/Variable/VariableSingleThresholdCacheStrategy.h
@@ -0,0 +1,32 @@
+#ifndef SCIQLOP_VARIABLESINGLETHRESHOLDCACHESTRATEGY_H
+#define SCIQLOP_VARIABLESINGLETHRESHOLDCACHESTRATEGY_H
+
+#include "Settings/SqpSettingsDefs.h"
+#include "VariableCacheStrategy.h"
+
+
+/// This class aims to hande the cache strategy.
+class SCIQLOP_CORE_EXPORT VariableSingleThresholdCacheStrategy : public VariableCacheStrategy {
+public:
+    VariableSingleThresholdCacheStrategy() = default;
+
+    std::pair<SqpRange, SqpRange> computeRange(const SqpRange &vRange,
+                                               const SqpRange &rangeRequested) override
+    {
+
+        auto varRanges = std::pair<SqpRange, SqpRange>{};
+
+        auto toleranceFactor = SqpSettings::toleranceValue(
+            GENERAL_TOLERANCE_AT_UPDATE_KEY, GENERAL_TOLERANCE_AT_UPDATE_DEFAULT_VALUE);
+        auto tolerance = toleranceFactor * (rangeRequested.m_TEnd - rangeRequested.m_TStart);
+
+        varRanges.first = rangeRequested;
+        varRanges.second
+            = SqpRange{rangeRequested.m_TStart - tolerance, rangeRequested.m_TEnd + tolerance};
+
+        return varRanges;
+    }
+};
+
+
+#endif // SCIQLOP_VARIABLESINGLETHRESHOLDCACHESTRATEGY_H
diff --git a/core/src/Data/VectorSeries.cpp b/core/src/Data/VectorSeries.cpp
index 3043f7c..ab86bad 100644
--- a/core/src/Data/VectorSeries.cpp
+++ b/core/src/Data/VectorSeries.cpp
@@ -33,7 +33,7 @@ std::vector<double> flatten(std::vector<double> xValues, std::vector<double> yVa
         result.push_back(xValues[i]);
         result.push_back(yValues[i]);
         result.push_back(zValues[i]);
-     }
+    }
 
     return result;
 }
diff --git a/core/src/Variable/VariableCacheStrategy.cpp b/core/src/Variable/VariableCacheStrategy.cpp
deleted file mode 100644
index 962c5b6..0000000
--- a/core/src/Variable/VariableCacheStrategy.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-#include "Variable/VariableCacheStrategy.h"
-
-#include "Settings/SqpSettingsDefs.h"
-
-#include "Variable/Variable.h"
-#include "Variable/VariableController.h"
-
-Q_LOGGING_CATEGORY(LOG_VariableCacheStrategy, "VariableCacheStrategy")
-
-struct VariableCacheStrategy::VariableCacheStrategyPrivate {
-    VariableCacheStrategyPrivate() : m_CacheStrategy{CacheStrategy::FixedTolerance} {}
-
-    CacheStrategy m_CacheStrategy;
-};
-
-
-VariableCacheStrategy::VariableCacheStrategy(QObject *parent)
-        : QObject{parent}, impl{spimpl::make_unique_impl<VariableCacheStrategyPrivate>()}
-{
-}
-
-std::pair<SqpRange, SqpRange>
-VariableCacheStrategy::computeStrategyRanges(const SqpRange &vRange, const SqpRange &rangeRequested)
-{
-
-    auto varRanges = std::pair<SqpRange, SqpRange>{};
-
-    auto toleranceFactor = SqpSettings::toleranceValue(GENERAL_TOLERANCE_AT_UPDATE_KEY,
-                                                       GENERAL_TOLERANCE_AT_UPDATE_DEFAULT_VALUE);
-    auto tolerance = toleranceFactor * (rangeRequested.m_TEnd - rangeRequested.m_TStart);
-
-    switch (impl->m_CacheStrategy) {
-        case CacheStrategy::FixedTolerance: {
-            varRanges.first = rangeRequested;
-            varRanges.second
-                = SqpRange{rangeRequested.m_TStart - tolerance, rangeRequested.m_TEnd + tolerance};
-            break;
-        }
-
-        case CacheStrategy::TwoThreashold: {
-            // TODO Implement
-            break;
-        }
-        default:
-            qCCritical(LOG_VariableCacheStrategy())
-                << tr("Impossible to use compute the cache range with an unknow cache strategy");
-            // No action
-            break;
-    }
-
-    return varRanges;
-}
diff --git a/core/src/Variable/VariableController.cpp b/core/src/Variable/VariableController.cpp
index 32a44b3..6fa1b1e 100644
--- a/core/src/Variable/VariableController.cpp
+++ b/core/src/Variable/VariableController.cpp
@@ -1,6 +1,7 @@
 #include <Variable/Variable.h>
 #include <Variable/VariableAcquisitionWorker.h>
 #include <Variable/VariableCacheStrategy.h>
+#include <Variable/VariableCacheStrategyFactory.h>
 #include <Variable/VariableController.h>
 #include <Variable/VariableModel.h>
 #include <Variable/VariableSynchronizationGroup.h>
@@ -79,7 +80,9 @@ struct VariableController::VariableControllerPrivate {
             : m_WorkingMutex{},
               m_VariableModel{new VariableModel{parent}},
               m_VariableSelectionModel{new QItemSelectionModel{m_VariableModel, parent}},
-              m_VariableCacheStrategy{std::make_unique<VariableCacheStrategy>()},
+              // m_VariableCacheStrategy{std::make_unique<VariableCacheStrategy>()},
+              m_VariableCacheStrategy{VariableCacheStrategyFactory::createCacheStrategy(
+                  CacheStrategy::SingleThreshold)},
               m_VariableAcquisitionWorker{std::make_unique<VariableAcquisitionWorker>()},
               q{parent}
     {
@@ -573,7 +576,7 @@ void VariableController::VariableControllerPrivate::processRequest(std::shared_p
     auto varId = m_VariableToIdentifierMap.at(var);
 
     auto varStrategyRangesRequested
-        = m_VariableCacheStrategy->computeStrategyRanges(var->range(), rangeRequested);
+        = m_VariableCacheStrategy->computeRange(var->range(), rangeRequested);
 
     auto notInCacheRangeList = QVector<SqpRange>{varStrategyRangesRequested.second};
     auto inCacheRangeList = QVector<SqpRange>{};
diff --git a/core/tests/Variable/TestVariableSync.cpp b/core/tests/Variable/TestVariableSync.cpp
new file mode 100644
index 0000000..61daa00
--- /dev/null
+++ b/core/tests/Variable/TestVariableSync.cpp
@@ -0,0 +1,310 @@
+#include <QObject>
+#include <QtTest>
+
+#include <memory>
+
+#include <Data/DataProviderParameters.h>
+#include <Data/IDataProvider.h>
+#include <Data/ScalarSeries.h>
+#include <Time/TimeController.h>
+#include <Variable/Variable.h>
+#include <Variable/VariableController.h>
+#include <Variable/VariableModel.h>
+
+namespace {
+
+/// Delay after each operation on the variable before validating it (in ms)
+const auto OPERATION_DELAY = 100;
+
+/**
+ * Generates values according to a range. The value generated for a time t is the number of seconds
+ * of difference between t and a reference value (which is midnight -> 00:00:00)
+ *
+ * Example: For a range between 00:00:10 and 00:00:20, the generated values are
+ * {10,11,12,13,14,15,16,17,18,19,20}
+ */
+std::vector<double> values(const SqpRange &range)
+{
+    QTime referenceTime{0, 0};
+
+    std::vector<double> result{};
+
+    for (auto i = range.m_TStart; i <= range.m_TEnd; ++i) {
+        auto time = DateUtils::dateTime(i).time();
+        result.push_back(referenceTime.secsTo(time));
+    }
+
+    return result;
+}
+
+/// Provider used for the tests
+class TestProvider : public IDataProvider {
+    std::shared_ptr<IDataProvider> clone() const { return std::make_shared<TestProvider>(); }
+
+    void requestDataLoading(QUuid acqIdentifier, const DataProviderParameters &parameters) override
+    {
+        const auto &ranges = parameters.m_Times;
+
+        for (const auto &range : ranges) {
+            // Generates data series
+            auto valuesData = values(range);
+
+            std::vector<double> xAxisData{};
+            for (auto i = range.m_TStart; i <= range.m_TEnd; ++i) {
+                xAxisData.push_back(i);
+            }
+
+            auto dataSeries = std::make_shared<ScalarSeries>(
+                std::move(xAxisData), std::move(valuesData), Unit{"t", true}, Unit{});
+
+            emit dataProvided(acqIdentifier, dataSeries, range);
+        }
+    }
+
+    void requestDataAborting(QUuid acqIdentifier) override
+    {
+        // Does nothing
+    }
+};
+
+/**
+ * Interface representing an operation performed on a variable controller.
+ * This interface is used in tests to apply a set of operations and check the status of the
+ * controller after each operation
+ */
+struct IOperation {
+    virtual ~IOperation() = default;
+    /// Executes the operation on the variable controller
+    virtual void exec(VariableController &variableController) const = 0;
+};
+
+/**
+ *Variable creation operation in the controller
+ */
+struct Create : public IOperation {
+    explicit Create(int index) : m_Index{index} {}
+
+    void exec(VariableController &variableController) const override
+    {
+        auto variable = variableController.createVariable(QString::number(m_Index), {},
+                                                          std::make_unique<TestProvider>());
+    }
+
+    int m_Index; ///< The index of the variable to create in the controller
+};
+
+/**
+ * Variable move/shift operation in the controller
+ */
+struct Move : public IOperation {
+    explicit Move(int index, const SqpRange &newRange, bool shift = false)
+            : m_Index{index}, m_NewRange{newRange}, m_Shift{shift}
+    {
+    }
+
+    void exec(VariableController &variableController) const override
+    {
+        if (auto variable = variableController.variableModel()->variable(m_Index)) {
+            variableController.onRequestDataLoading({variable}, m_NewRange, variable->range(),
+                                                    !m_Shift);
+        }
+    }
+
+    int m_Index;         ///< The index of the variable to move
+    SqpRange m_NewRange; ///< The new range of the variable
+    bool m_Shift;        ///< Performs a shift (
+};
+
+/**
+ * Variable synchronization/desynchronization operation in the controller
+ */
+struct Synchronize : public IOperation {
+    explicit Synchronize(int index, QUuid syncId, bool synchronize = true)
+            : m_Index{index}, m_SyncId{syncId}, m_Synchronize{synchronize}
+    {
+    }
+
+    void exec(VariableController &variableController) const override
+    {
+        if (auto variable = variableController.variableModel()->variable(m_Index)) {
+            if (m_Synchronize) {
+                variableController.onAddSynchronized(variable, m_SyncId);
+            }
+            else {
+                variableController.desynchronize(variable, m_SyncId);
+            }
+        }
+    }
+
+    int m_Index;        ///< The index of the variable to sync/desync
+    QUuid m_SyncId;     ///< The synchronization group of the variable
+    bool m_Synchronize; ///< Performs sync or desync operation
+};
+
+/**
+ * Test Iteration
+ *
+ * A test iteration includes an operation to be performed, and a set of expected ranges after each
+ * operation. Each range is tested after the operation to ensure that:
+ * - the range of the variable is the expected range
+ * - the data of the variable are those generated for the expected range
+ */
+struct Iteration {
+    std::shared_ptr<IOperation> m_Operation;  ///< Operation to perform
+    std::map<int, SqpRange> m_ExpectedRanges; ///< Expected ranges (by variable index)
+};
+
+using Iterations = std::vector<Iteration>;
+
+} // namespace
+
+Q_DECLARE_METATYPE(Iterations)
+
+class TestVariableSync : public QObject {
+    Q_OBJECT
+
+private slots:
+    /// Input data for @sa testSync()
+    void testSync_data();
+
+    /// Tests synchronization between variables through several operations
+    void testSync();
+};
+
+void TestVariableSync::testSync_data()
+{
+    // ////////////// //
+    // Test structure //
+    // ////////////// //
+
+    QTest::addColumn<QUuid>("syncId");
+    QTest::addColumn<SqpRange>("initialRange");
+    QTest::addColumn<Iterations>("iterations");
+
+    // ////////// //
+    // Test cases //
+    // ////////// //
+
+    // Id used to synchronize variables in the controller
+    auto syncId = QUuid::createUuid();
+
+    /// Generates a range according to a start time and a end time (the date is the same)
+    auto range = [](const QTime &startTime, const QTime &endTime) {
+        return SqpRange{DateUtils::secondsSinceEpoch(QDateTime{{2017, 1, 1}, startTime, Qt::UTC}),
+                        DateUtils::secondsSinceEpoch(QDateTime{{2017, 1, 1}, endTime, Qt::UTC})};
+    };
+
+    auto initialRange = range({12, 0}, {13, 0});
+
+    Iterations iterations{};
+    // Creates variables var0, var1 and var2
+    iterations.push_back({std::make_shared<Create>(0), {{0, initialRange}}});
+    iterations.push_back({std::make_shared<Create>(1), {{0, initialRange}, {1, initialRange}}});
+    iterations.push_back(
+        {std::make_shared<Create>(2), {{0, initialRange}, {1, initialRange}, {2, initialRange}}});
+
+    // Adds variables into the sync group (ranges don't need to be tested here)
+    iterations.push_back({std::make_shared<Synchronize>(0, syncId)});
+    iterations.push_back({std::make_shared<Synchronize>(1, syncId)});
+    iterations.push_back({std::make_shared<Synchronize>(2, syncId)});
+
+    // Moves var0: ranges of var0, var1 and var2 change
+    auto newRange = range({12, 30}, {13, 30});
+    iterations.push_back(
+        {std::make_shared<Move>(0, newRange), {{0, newRange}, {1, newRange}, {2, newRange}}});
+
+    // Moves var1: ranges of var0, var1 and var2 change
+    newRange = range({13, 0}, {14, 0});
+    iterations.push_back(
+        {std::make_shared<Move>(0, newRange), {{0, newRange}, {1, newRange}, {2, newRange}}});
+
+    // Moves var2: ranges of var0, var1 and var2 change
+    newRange = range({13, 30}, {14, 30});
+    iterations.push_back(
+        {std::make_shared<Move>(0, newRange), {{0, newRange}, {1, newRange}, {2, newRange}}});
+
+    // Desyncs var2 and moves var0:
+    // - ranges of var0 and var1 change
+    // - range of var2 doesn't change anymore
+    auto var2Range = newRange;
+    newRange = range({13, 45}, {14, 45});
+    iterations.push_back({std::make_shared<Synchronize>(2, syncId, false)});
+    iterations.push_back(
+        {std::make_shared<Move>(0, newRange), {{0, newRange}, {1, newRange}, {2, var2Range}}});
+
+    // Shifts var0: although var1 is synchronized with var0, its range doesn't change
+    auto var1Range = newRange;
+    newRange = range({14, 45}, {15, 45});
+    iterations.push_back({std::make_shared<Move>(0, newRange, true),
+                          {{0, newRange}, {1, var1Range}, {2, var2Range}}});
+
+    // Moves var0 through several operations:
+    // - range of var0 changes
+    // - range or var1 changes according to the previous shift (one hour)
+    auto moveVar0 = [&iterations](const auto &var0NewRange, const auto &var1ExpectedRange) {
+        iterations.push_back(
+            {std::make_shared<Move>(0, var0NewRange), {{0, var0NewRange}, {1, var1ExpectedRange}}});
+    };
+    // Pan left
+    moveVar0(range({14, 30}, {15, 30}), range({13, 30}, {14, 30}));
+    // Pan right
+    moveVar0(range({16, 0}, {17, 0}), range({15, 0}, {16, 0}));
+    // Zoom in
+    moveVar0(range({16, 30}, {16, 45}), range({15, 30}, {15, 45}));
+    // Zoom out
+    moveVar0(range({12, 0}, {18, 0}), range({11, 0}, {17, 0}));
+
+    QTest::newRow("sync1") << syncId << initialRange << std::move(iterations);
+}
+
+void TestVariableSync::testSync()
+{
+    // Inits controllers
+    TimeController timeController{};
+    VariableController variableController{};
+    variableController.setTimeController(&timeController);
+
+    QFETCH(QUuid, syncId);
+    QFETCH(SqpRange, initialRange);
+    timeController.onTimeToUpdate(initialRange);
+
+    // Synchronization group used
+    variableController.onAddSynchronizationGroupId(syncId);
+
+    // For each iteration:
+    // - execute operation
+    // - compare the variables' state to the expected states
+    QFETCH(Iterations, iterations);
+    for (const auto &iteration : iterations) {
+        iteration.m_Operation->exec(variableController);
+        QTest::qWait(OPERATION_DELAY);
+
+        for (const auto &expectedRangeEntry : iteration.m_ExpectedRanges) {
+            auto variableIndex = expectedRangeEntry.first;
+            auto expectedRange = expectedRangeEntry.second;
+
+            // Gets the variable in the controller
+            auto variable = variableController.variableModel()->variable(variableIndex);
+
+            // Compares variable's range to the expected range
+            QVERIFY(variable != nullptr);
+            auto range = variable->range();
+            QCOMPARE(range, expectedRange);
+
+            // Compares variable's data with values expected for its range
+            auto dataSeries = variable->dataSeries();
+            QVERIFY(dataSeries != nullptr);
+
+            auto it = dataSeries->xAxisRange(range.m_TStart, range.m_TEnd);
+            auto expectedValues = values(range);
+            QVERIFY(std::equal(it.first, it.second, expectedValues.cbegin(), expectedValues.cend(),
+                               [](const auto &dataSeriesIt, const auto &expectedValue) {
+                                   return dataSeriesIt.value() == expectedValue;
+                               }));
+        }
+    }
+}
+
+QTEST_MAIN(TestVariableSync)
+
+#include "TestVariableSync.moc"
diff --git a/core/tests/meson.build b/core/tests/meson.build
index 8932c31..5476049 100644
--- a/core/tests/meson.build
+++ b/core/tests/meson.build
@@ -7,8 +7,8 @@ tests = [
   [['Data/TestTwoDimArrayData.cpp'],'test_2d','Two Dim Array test'],
   [['DataSource/TestDataSourceController.cpp'],'test_data_source','DataSourceController test'],
   [['Variable/TestVariableCacheController.cpp'],'test_variable_cache','VariableCacheController test'],
-  [['Variable/TestVariableController.cpp'],'test_variable_controler','VariableController test'],
-  [['Variable/TestVariable.cpp'],'test_variable','Variable test']
+  [['Variable/TestVariable.cpp'],'test_variable','Variable test'],
+  [['Variable/TestVariableSync.cpp'],'test_variable_sync','Variable synchronization test']
 ]
 
 foreach unit_test : tests
diff --git a/gui/meson.build b/gui/meson.build
index 78789fa..2b1b4b2 100644
--- a/gui/meson.build
+++ b/gui/meson.build
@@ -22,8 +22,8 @@ gui_ui_files = [
   'ui/SidePane/SqpSidePane.ui',
   'ui/TimeWidget/TimeWidget.ui',
   'ui/Variable/VariableInspectorWidget.ui',
-  'ui/Variable/VariableMenuHeaderWidget.ui',
   'ui/Variable/RenameVariableDialog.ui',
+  'ui/Variable/VariableMenuHeaderWidget.ui',
   'ui/Visualization/VisualizationGraphWidget.ui',
   'ui/Visualization/VisualizationTabWidget.ui',
   'ui/Visualization/VisualizationWidget.ui',
diff --git a/gui/src/Variable/VariableInspectorWidget.cpp b/gui/src/Variable/VariableInspectorWidget.cpp
index 365b843..038bcdb 100644
--- a/gui/src/Variable/VariableInspectorWidget.cpp
+++ b/gui/src/Variable/VariableInspectorWidget.cpp
@@ -184,22 +184,29 @@ void VariableInspectorWidget::onTableMenuRequested(const QPoint &pos) noexcept
         if (selectedVariables.size() == 1) {
             auto selectedVariable = selectedVariables.front();
 
-            auto duplicateFun = [&selectedVariable]() {
-                sqpApp->variableController().cloneVariable(selectedVariable);
+            auto duplicateFun = [varW = std::weak_ptr<Variable>(selectedVariable)]()
+            {
+                if (auto var = varW.lock()) {
+                    sqpApp->variableController().cloneVariable(var);
+                }
             };
 
             tableMenu.addAction(tr("Duplicate"), duplicateFun);
 
-            auto renameFun = [&selectedVariable, &model, this]() {
-                // Generates forbidden names (names associated to existing variables)
-                auto allVariables = model->variables();
-                auto forbiddenNames = QVector<QString>(allVariables.size());
-                std::transform(allVariables.cbegin(), allVariables.cend(), forbiddenNames.begin(),
-                               [](const auto &variable) { return variable->name(); });
-
-                RenameVariableDialog dialog{selectedVariable->name(), forbiddenNames, this};
-                if (dialog.exec() == QDialog::Accepted) {
-                    selectedVariable->setName(dialog.name());
+            auto renameFun = [ varW = std::weak_ptr<Variable>(selectedVariable), &model, this ]()
+            {
+                if (auto var = varW.lock()) {
+                    // Generates forbidden names (names associated to existing variables)
+                    auto allVariables = model->variables();
+                    auto forbiddenNames = QVector<QString>(allVariables.size());
+                    std::transform(allVariables.cbegin(), allVariables.cend(),
+                                   forbiddenNames.begin(),
+                                   [](const auto &variable) { return variable->name(); });
+
+                    RenameVariableDialog dialog{var->name(), forbiddenNames, this};
+                    if (dialog.exec() == QDialog::Accepted) {
+                        var->setName(dialog.name());
+                    }
                 }
             };