diff --git a/GUI/Model/Job/MinimizerItem.cpp b/GUI/Model/Job/MinimizerItem.cpp
index b9194a89165bdf5fd3c52dfcc11478cc73f3958a..b74a8f9da85457d8abae64ffa2da70e455aae9dd 100644
--- a/GUI/Model/Job/MinimizerItem.cpp
+++ b/GUI/Model/Job/MinimizerItem.cpp
@@ -33,51 +33,46 @@ const QMap<QString, QString> minimizer_names_map = {
 const QString default_minimizer = minimizer_names_map.key(MinuitMinimizerItem::M_TYPE);
 
 #ifdef ALGORITHM_LIST
-QString filler(qsizetype l)
-{
-    qsizetype length = 60 - l;
-    QString result = " ";
-    for (int i = 0; i < length / 2; i++)
-        result += " -";
-    result += "  ";
-    return result;
-}
-
 QMap<QString /*algorithm*/, QString /*minimizer*/> algorithm_minimizer_map;
 QStringList create_algorithm_minimizer_map()
 {
-    QString name, basename;
+    QString name, shift = "   ";
     QStringList common_algorithms_list;
 
+    common_algorithms_list.append("ROOT Minuit2");
+
     QStringList minuit2Algorithms =
         MinimizerItemCatalog::algorithmNames(MinuitMinimizerItem::M_TYPE);
     for (QString algorithm : minuit2Algorithms) {
-        name = algorithm + filler(algorithm.length()) + "(ROOT Minuit2)";
+        name = shift + algorithm;
         common_algorithms_list.append(name);
         algorithm_minimizer_map.insert(name, minimizer_names_map.key(MinuitMinimizerItem::M_TYPE));
     }
 
+    common_algorithms_list.append("ROOT TMVA");
+
+    name = shift + "Genetic";
+    common_algorithms_list.append(name);
+    algorithm_minimizer_map.insert(name, minimizer_names_map.key(GeneticMinimizerItem::M_TYPE));
+
+    common_algorithms_list.append("GSL Multimin");
+
     QStringList multiMinAlgorithms =
         MinimizerItemCatalog::algorithmNames(GSLMultiMinimizerItem::M_TYPE);
     for (QString algorithm : multiMinAlgorithms) {
-        name = algorithm + filler(algorithm.length()) + "(GSL)";
+        name = shift + algorithm;
         common_algorithms_list.append(name);
         algorithm_minimizer_map.insert(name,
                                        minimizer_names_map.key(GSLMultiMinimizerItem::M_TYPE));
     }
 
-    basename = "Genetic";
-    name = basename + filler(basename.length()) + "(ROOT TMVA)";
-    common_algorithms_list.append(name);
-    algorithm_minimizer_map.insert(name, minimizer_names_map.key(GeneticMinimizerItem::M_TYPE));
+    common_algorithms_list.append("GSL");
 
-    basename = "Simulated Annealing";
-    name = basename + filler(basename.length()) + "(GSL)";
+    name = shift + "Simulated Annealing";
     common_algorithms_list.append(name);
     algorithm_minimizer_map.insert(name, minimizer_names_map.key(SimAnMinimizerItem::M_TYPE));
 
-    basename = "Levenberg-Marquardt";
-    name = basename + filler(basename.length()) + "(GSL)";
+    name = shift + "Levenberg-Marquardt";
     common_algorithms_list.append(name);
     algorithm_minimizer_map.insert(name, minimizer_names_map.key(GSLLMAMinimizerItem::M_TYPE));
 
@@ -106,7 +101,7 @@ MinimizerContainerItem::MinimizerContainerItem()
 
 #ifdef ALGORITHM_LIST
     const QStringList common_algorithms_list = create_algorithm_minimizer_map();
-    const QString default_common_algorithm = common_algorithms_list.first();
+    const QString default_common_algorithm = common_algorithms_list[1];
     ComboProperty common_algorithm_combo =
         ComboProperty::fromList(common_algorithms_list, default_common_algorithm);
     addProperty(P_COMMON_ALGORITHMS, common_algorithm_combo.variant());
@@ -178,12 +173,18 @@ ComboProperty MinimizerContainerItem::minimizerCombo() const
     return getItemValue(P_MINIMIZERS).value<ComboProperty>();
 }
 #ifdef ALGORITHM_LIST
+bool MinimizerContainerItem::algorithmHasMinimizer(const QString &name)
+{
+    return algorithm_minimizer_map.contains(name);
+}
+
 void MinimizerContainerItem::setCurrentCommonAlgorithm(const QString& name)
 {
     ComboProperty combo = commonAlgorithmCombo();
     combo.setCurrentValue(name);
     setItemValue(P_COMMON_ALGORITHMS, combo.variant());
 
+    ASSERT(algorithmHasMinimizer(name));
     setCurrentMinimizer(algorithm_minimizer_map.value(name));
 }
 
diff --git a/GUI/Model/Job/MinimizerItem.h b/GUI/Model/Job/MinimizerItem.h
index a24da6649cb47585e789ec36294db6f83e657121..e3764fac84eee8670c6a0d1f91a47c1cd8f49de1 100644
--- a/GUI/Model/Job/MinimizerItem.h
+++ b/GUI/Model/Job/MinimizerItem.h
@@ -67,6 +67,7 @@ public:
     ComboProperty minimizerCombo() const;
 
 #ifdef ALGORITHM_LIST
+    bool algorithmHasMinimizer(const QString& name);
     void setCurrentCommonAlgorithm(const QString& name);
     ComboProperty commonAlgorithmCombo() const;
 #endif
diff --git a/GUI/View/Fit/MinimizerSettingsWidget.cpp b/GUI/View/Fit/MinimizerSettingsWidget.cpp
index 67245453b262ba063df80ad10ebbe1f8bdd9d11c..6ae66bbfd292d9f099bb3dbdaae14f238ff20dd0 100644
--- a/GUI/View/Fit/MinimizerSettingsWidget.cpp
+++ b/GUI/View/Fit/MinimizerSettingsWidget.cpp
@@ -24,6 +24,7 @@
 #include <QFormLayout>
 #include <QPushButton>
 #include <QVBoxLayout>
+#include <QStandardItemModel>
 
 MinimizerSettingsWidget::MinimizerSettingsWidget(QWidget* parent)
     : QWidget(parent)
@@ -56,13 +57,7 @@ void MinimizerSettingsWidget::setMinItem(MinimizerContainerItem* minimizerItem)
         return;
 
 #ifdef ALGORITHM_LIST
-    m_mainLayout->addRow("Algorithm:", GUI::Util::createComboBox(
-                                           [=] { return m_currentItem->commonAlgorithmCombo(); },
-                                           [=](const QString& t) {
-                                               m_currentItem->setCurrentCommonAlgorithm(t);
-                                               createMimimizerEdits();
-                                           },
-                                           &m_updaters));
+    createAlgorithmsCombo();
 #else
     m_mainLayout->addRow("Minimizer:",
                          GUI::Util::createComboBox([=] { return m_currentItem->minimizerCombo(); },
@@ -96,6 +91,65 @@ void MinimizerSettingsWidget::setMinItem(MinimizerContainerItem* minimizerItem)
     createMimimizerEdits();
     updateUIValues();
 }
+
+void MinimizerSettingsWidget::createAlgorithmsCombo()
+{
+    QComboBox* comboBox = new QComboBox;
+    QStringList list = m_currentItem->commonAlgorithmCombo().values();
+//    comboBox->addItems(list);
+
+    QList<qsizetype> header_indices;
+    for(QString algorithm : list) {
+        comboBox->addItem(algorithm);
+        if(!m_currentItem->algorithmHasMinimizer(algorithm)) {
+            qsizetype header_index = list.indexOf(algorithm);
+            header_indices.append(header_index);
+            comboBox->insertSeparator(comboBox->count()-1);
+
+            QFont font(comboBox->font());
+            font.setBold(true);
+
+            QStandardItemModel* model =	qobject_cast<QStandardItemModel*>(comboBox->model());
+            QStandardItem* firstItem = model->item(header_index);
+            firstItem->setSelectable(false);
+            firstItem->setFont(font);
+
+            comboBox->insertSeparator(comboBox->count());
+        }
+    }
+
+
+//    comboBox->setToolTip(tooltip);
+    comboBox->setCurrentText(m_currentItem->commonAlgorithmCombo().currentValue());
+
+//    if (comboFunction().toolTips().size() == combo->count())
+//        for (int index = 0; index < combo->count(); index++)
+//            combo->setItemData(index, comboFunction().toolTips().at(index), Qt::ToolTipRole);
+
+    comboBox->setProperty("previous", comboBox->currentIndex());
+
+    QObject::connect(comboBox, &QComboBox::currentTextChanged, [=] {
+        if(header_indices.contains(comboBox->currentIndex()))
+        {
+            int previous = comboBox->property("previous").toInt();
+            if(previous<comboBox->currentIndex() && comboBox->currentIndex()+2 < comboBox->count())
+                comboBox->setCurrentIndex(comboBox->currentIndex()+2);
+            else if(previous>comboBox->currentIndex() && comboBox->currentIndex()-3 >= 0)
+                comboBox->setCurrentIndex(comboBox->currentIndex()-3);
+            else
+                comboBox->setCurrentIndex(previous);
+        }
+        comboBox->setProperty("previous", comboBox->currentIndex());
+    });
+
+//    if (updaters)
+//        (*updaters) << [=]() {
+//            QSignalBlocker b(combo);
+//            combo->setCurrentText(comboFunction().currentValue());
+//        };
+
+    m_mainLayout->addRow("Algorithm:", comboBox);
+}
 void MinimizerSettingsWidget::createMimimizerEdits()
 {
     GUI::Util::Layout::clearLayout(m_minimizerLayout);
diff --git a/GUI/View/Fit/MinimizerSettingsWidget.h b/GUI/View/Fit/MinimizerSettingsWidget.h
index 6860d2ce1cee2d6606043b5484428bbc8d9fcea3..9a2342403aa06759656e8380d7665d2b82dc69da 100644
--- a/GUI/View/Fit/MinimizerSettingsWidget.h
+++ b/GUI/View/Fit/MinimizerSettingsWidget.h
@@ -38,6 +38,7 @@ public slots:
     void setMinItem(MinimizerContainerItem* minimizerItem);
 
 private:
+    void createAlgorithmsCombo();
     void createMimimizerEdits();
     void createMinuitEdits();
     void createGSLMultiMinEdits();
diff --git a/GUI/View/Job/JobView.cpp b/GUI/View/Job/JobView.cpp
index 9c97df232b424d9072737ca4d7591ec5edd74406..6cbaaf33ced22a3cef0cb61dd7fc1c78665e2eac 100644
--- a/GUI/View/Job/JobView.cpp
+++ b/GUI/View/Job/JobView.cpp
@@ -170,7 +170,8 @@ void JobView::setActivityAndPresentationForNewJob(JobItem* jobItem)
     if (!jobItem)
         return;
 
-    JobViewActivity newActivity = JobViewActivity::JobView;
+//    JobViewActivity newActivity = JobViewActivity::JobView;
+    JobViewActivity newActivity = JobViewActivity::Fitting;
 
     // save in current job
     jobItem->setActivity(JobViewActivities::nameFromActivity(newActivity));