diff --git a/src/libs/utils/debuggerlanguagechooser.cpp b/src/libs/utils/debuggerlanguagechooser.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..22d5d50603cd6c292c1b26df3fe855b8857d5a23
--- /dev/null
+++ b/src/libs/utils/debuggerlanguagechooser.cpp
@@ -0,0 +1,49 @@
+#include "debuggerlanguagechooser.h"
+
+#include <QHBoxLayout>
+#include <QCheckBox>
+
+namespace Utils {
+
+DebuggerLanguageChooser::DebuggerLanguageChooser(QWidget *parent) :
+    QWidget(parent)
+{
+    QHBoxLayout *layout = new QHBoxLayout(this);
+    setLayout(layout);
+    m_useCppDebugger = new QCheckBox(tr("C++"), this);
+    m_useQmlDebugger = new QCheckBox(tr("QML"), this);
+    layout->setMargin(0);
+    layout->addWidget(m_useCppDebugger);
+    layout->addWidget(m_useQmlDebugger);
+
+    connect(m_useCppDebugger, SIGNAL(toggled(bool)),
+            this, SLOT(useCppDebuggerToggled(bool)));
+    connect(m_useQmlDebugger, SIGNAL(toggled(bool)),
+            this, SLOT(useQmlDebuggerToggled(bool)));
+}
+
+void DebuggerLanguageChooser::setCppChecked(bool value)
+{
+    m_useCppDebugger->setChecked(value);
+}
+
+void DebuggerLanguageChooser::setQmlChecked(bool value)
+{
+    m_useQmlDebugger->setChecked(value);
+}
+
+void DebuggerLanguageChooser::useCppDebuggerToggled(bool toggled)
+{
+    emit cppLanguageToggled(toggled);
+    if (!toggled && !m_useQmlDebugger->isChecked())
+        m_useQmlDebugger->setChecked(true);
+}
+
+void DebuggerLanguageChooser::useQmlDebuggerToggled(bool toggled)
+{
+    emit qmlLanguageToggled(toggled);
+    if (!toggled && !m_useCppDebugger->isChecked())
+        m_useCppDebugger->setChecked(true);
+}
+
+} // namespace Utils
diff --git a/src/libs/utils/debuggerlanguagechooser.h b/src/libs/utils/debuggerlanguagechooser.h
new file mode 100644
index 0000000000000000000000000000000000000000..6e03d7aac2f54e793fadaf12f67b117c728bc519
--- /dev/null
+++ b/src/libs/utils/debuggerlanguagechooser.h
@@ -0,0 +1,35 @@
+#ifndef DEBUGGERLANGUAGECHOOSER_H
+#define DEBUGGERLANGUAGECHOOSER_H
+
+#include <QWidget>
+#include "utils_global.h"
+
+QT_FORWARD_DECLARE_CLASS(QCheckBox);
+
+namespace Utils {
+
+class QTCREATOR_UTILS_EXPORT DebuggerLanguageChooser : public QWidget
+{
+    Q_OBJECT
+public:
+    explicit DebuggerLanguageChooser(QWidget *parent = 0);
+
+    void setCppChecked(bool value);
+    void setQmlChecked(bool value);
+
+signals:
+    void cppLanguageToggled(bool value);
+    void qmlLanguageToggled(bool value);
+
+private slots:
+    void useCppDebuggerToggled(bool toggled);
+    void useQmlDebuggerToggled(bool toggled);
+
+private:
+    QCheckBox *m_useCppDebugger;
+    QCheckBox *m_useQmlDebugger;
+};
+
+} // namespace Utils
+
+#endif // DEBUGGERLANGUAGECHOOSER_H
diff --git a/src/libs/utils/utils-lib.pri b/src/libs/utils/utils-lib.pri
index 41b796c4a233391354ec18dbc70d34fb38720d36..f159d4d313ccd76c550a3f9fb1432661e6c3f1f8 100644
--- a/src/libs/utils/utils-lib.pri
+++ b/src/libs/utils/utils-lib.pri
@@ -45,7 +45,9 @@ SOURCES += $$PWD/reloadpromptutils.cpp \
     $$PWD/faketooltip.cpp \
     $$PWD/htmldocextractor.cpp \
     $$PWD/navigationtreeview.cpp \
-    $$PWD/crumblepath.cpp
+    $$PWD/crumblepath.cpp \
+    $$PWD/debuggerlanguagechooser.cpp
+
 win32 {
     SOURCES += $$PWD/abstractprocess_win.cpp \
         $$PWD/consoleprocess_win.cpp \
@@ -101,7 +103,9 @@ HEADERS += $$PWD/utils_global.h \
     $$PWD/faketooltip.h \
     $$PWD/htmldocextractor.h \
     $$PWD/navigationtreeview.h \
-    $$PWD/crumblepath.h
+    $$PWD/crumblepath.h \
+    $$PWD/debuggerlanguagechooser.h
+
 FORMS += $$PWD/filewizardpage.ui \
     $$PWD/projectintropage.ui \
     $$PWD/newclasswidget.ui \
diff --git a/src/plugins/cmakeprojectmanager/cmakerunconfiguration.cpp b/src/plugins/cmakeprojectmanager/cmakerunconfiguration.cpp
index dd9e5adb8ba83c4df7d76e048f5aa7cb0d087b7f..c73fd0b283f1f86b1322c7cae7739fc7aceaf346 100644
--- a/src/plugins/cmakeprojectmanager/cmakerunconfiguration.cpp
+++ b/src/plugins/cmakeprojectmanager/cmakerunconfiguration.cpp
@@ -38,6 +38,7 @@
 #include <projectexplorer/environment.h>
 #include <projectexplorer/debugginghelper.h>
 #include <utils/qtcassert.h>
+#include <utils/debuggerlanguagechooser.h>
 #include <QtGui/QFormLayout>
 #include <QtGui/QLineEdit>
 #include <QtGui/QGroupBox>
@@ -346,6 +347,13 @@ CMakeRunConfigurationWidget::CMakeRunConfigurationWidget(CMakeRunConfiguration *
 
     fl->addRow(tr("Working Directory:"), boxlayout);
 
+    QLabel *debuggerLabel = new QLabel(tr("Debugger:"), this);
+    m_debuggerLanguageChooser = new Utils::DebuggerLanguageChooser(this);
+    fl->addRow(debuggerLabel, m_debuggerLanguageChooser);
+
+    m_debuggerLanguageChooser->setCppChecked(m_cmakeRunConfiguration->useCppDebugger());
+    m_debuggerLanguageChooser->setQmlChecked(m_cmakeRunConfiguration->useQmlDebugger());
+
     m_detailsContainer = new Utils::DetailsWidget(this);
     m_detailsContainer->setState(Utils::DetailsWidget::NoSummary);
 
@@ -394,6 +402,11 @@ CMakeRunConfigurationWidget::CMakeRunConfigurationWidget(CMakeRunConfiguration *
     connect(resetButton, SIGNAL(clicked()),
             this, SLOT(resetWorkingDirectory()));
 
+    connect(m_debuggerLanguageChooser, SIGNAL(cppLanguageToggled(bool)),
+            this, SLOT(useCppDebuggerToggled(bool)));
+    connect(m_debuggerLanguageChooser, SIGNAL(qmlLanguageToggled(bool)),
+            this, SLOT(useQmlDebuggerToggled(bool)));
+
     connect(m_environmentWidget, SIGNAL(userChangesChanged()),
             this, SLOT(userChangesChanged()));
 
@@ -428,6 +441,16 @@ void CMakeRunConfigurationWidget::resetWorkingDirectory()
     m_cmakeRunConfiguration->setUserWorkingDirectory("");
 }
 
+void CMakeRunConfigurationWidget::useCppDebuggerToggled(bool toggled)
+{
+    m_cmakeRunConfiguration->setUseCppDebugger(toggled);
+}
+
+void CMakeRunConfigurationWidget::useQmlDebuggerToggled(bool toggled)
+{
+    m_cmakeRunConfiguration->setUseQmlDebugger(toggled);
+}
+
 void CMakeRunConfigurationWidget::userChangesChanged()
 {
     m_cmakeRunConfiguration->setUserEnvironmentChanges(m_environmentWidget->userChanges());
diff --git a/src/plugins/cmakeprojectmanager/cmakerunconfiguration.h b/src/plugins/cmakeprojectmanager/cmakerunconfiguration.h
index 6b46ef32d22e93ca2e9345a4651da835702fcabc..f8cb130763e75eb0b0c228f26668ceeefdfb952f 100644
--- a/src/plugins/cmakeprojectmanager/cmakerunconfiguration.h
+++ b/src/plugins/cmakeprojectmanager/cmakerunconfiguration.h
@@ -41,6 +41,10 @@ QT_BEGIN_NAMESPACE
 class QComboBox;
 QT_END_NAMESPACE
 
+namespace Utils {
+class DebuggerLanguageChooser;
+}
+
 namespace CMakeProjectManager {
 namespace Internal {
 
@@ -93,6 +97,8 @@ signals:
 
 private slots:
     void setArguments(const QString &newText);
+    void useCppDebuggerToggled(bool toggled);
+    void useQmlDebuggerToggled(bool toggled);
 
 protected:
     CMakeRunConfiguration(CMakeTarget *parent, CMakeRunConfiguration *source);
@@ -137,6 +143,8 @@ private slots:
     void userChangesChanged();
     void setWorkingDirectory();
     void resetWorkingDirectory();
+    void useCppDebuggerToggled(bool toggled);
+    void useQmlDebuggerToggled(bool toggled);
 
 private slots:
     void baseEnvironmentComboBoxChanged(int index);
@@ -148,6 +156,7 @@ private:
     CMakeRunConfiguration *m_cmakeRunConfiguration;
     Utils::PathChooser *m_workingDirectoryEdit;
     QComboBox *m_baseEnvironmentComboBox;
+    Utils::DebuggerLanguageChooser *m_debuggerLanguageChooser;
     ProjectExplorer::EnvironmentWidget *m_environmentWidget;
     Utils::DetailsWidget *m_detailsContainer;
 };
diff --git a/src/plugins/debugger/debuggeruiswitcher.cpp b/src/plugins/debugger/debuggeruiswitcher.cpp
index 9e27f92140e890a74181a4b43b341681b4b18616..3a4ddc33f8f73b7b33e2e94b72781c46962c23e8 100644
--- a/src/plugins/debugger/debuggeruiswitcher.cpp
+++ b/src/plugins/debugger/debuggeruiswitcher.cpp
@@ -134,6 +134,7 @@ struct DebuggerUISwitcherPrivate
 
     QWeakPointer<ProjectExplorer::Project> m_previousProject;
     QWeakPointer<ProjectExplorer::Target> m_previousTarget;
+    QWeakPointer<ProjectExplorer::RunConfiguration> m_previousRunConfiguration;
 
     bool m_initialized;
 
@@ -221,7 +222,8 @@ void DebuggerUISwitcher::updateUiForTarget(ProjectExplorer::Target *target)
         return;
 
     if (d->m_previousTarget) {
-        disconnect(target, SIGNAL(activeRunConfigurationChanged(ProjectExplorer::RunConfiguration*)),
+            disconnect(d->m_previousTarget.data(),
+                       SIGNAL(activeRunConfigurationChanged(ProjectExplorer::RunConfiguration*)),
             this, SLOT(updateUiForRunConfiguration(ProjectExplorer::RunConfiguration*)));
     }
     d->m_previousTarget = target;
@@ -230,33 +232,33 @@ void DebuggerUISwitcher::updateUiForTarget(ProjectExplorer::Target *target)
     updateUiForRunConfiguration(target->activeRunConfiguration());
 }
 
-static bool isQmlProjectType(ProjectExplorer::RunConfiguration *rc)
-{
-    if (rc && rc->target() && rc->target()->project()) {
-        return (rc->target()->project()->id() == QLatin1String("QmlProjectManager.QmlProject"));
-    }
-    return false;
-}
-
 // updates default debug language settings per run config.
 void DebuggerUISwitcher::updateUiForRunConfiguration(ProjectExplorer::RunConfiguration *rc)
 {
-    bool isDotQmlProjectType = isQmlProjectType(rc);
     if (rc) {
-        d->m_languageActionGroup->setDisabled(false);
-        if (d->m_qmlEnabled) {
-            d->m_activateCppAction->setChecked(!isDotQmlProjectType);
-            d->m_activateQmlAction->setChecked(isDotQmlProjectType);
-        } else {
-            if (d->m_activateQmlAction)
-                d->m_activateQmlAction->setChecked(false);
+        if (d->m_previousRunConfiguration) {
+            disconnect(d->m_previousRunConfiguration.data(),
+                       SIGNAL(debuggersChanged()),
+                       this, SLOT(updateUiForCurrentRunConfiguration()));
         }
-    } else {
+        d->m_previousRunConfiguration = rc;
+        connect(d->m_previousRunConfiguration.data(),
+                   SIGNAL(debuggersChanged()),
+                   this, SLOT(updateUiForCurrentRunConfiguration()));
+
+        updateUiForCurrentRunConfiguration();
+    }
+}
+
+void DebuggerUISwitcher::updateUiForCurrentRunConfiguration()
+{
+    if (d->m_previousRunConfiguration) {
+        ProjectExplorer::RunConfiguration *rc = d->m_previousRunConfiguration.data();
+
         if (d->m_activateCppAction)
-            d->m_activateCppAction->setChecked(true);
+            d->m_activateCppAction->setChecked(rc->useCppDebugger());
         if (d->m_activateQmlAction)
-            d->m_activateQmlAction->setChecked(false);
-        d->m_languageActionGroup->setDisabled(true);
+            d->m_activateQmlAction->setChecked(rc->useQmlDebugger());
     }
 
     updateActiveLanguages();
diff --git a/src/plugins/debugger/debuggeruiswitcher.h b/src/plugins/debugger/debuggeruiswitcher.h
index 49ad57aa655393f7ca88d06d29fbf72ea35745cc..377462251c5e26a6cd6c42db0eea834fa929dd90 100644
--- a/src/plugins/debugger/debuggeruiswitcher.h
+++ b/src/plugins/debugger/debuggeruiswitcher.h
@@ -132,6 +132,7 @@ private slots:
     void updateUiForProject(ProjectExplorer::Project *project);
     void updateUiForTarget(ProjectExplorer::Target *target);
     void updateUiForRunConfiguration(ProjectExplorer::RunConfiguration *rc);
+    void updateUiForCurrentRunConfiguration();
     void updateUiOnFileListChange();
 
     void updateActiveLanguages();
diff --git a/src/plugins/projectexplorer/customexecutablerunconfiguration.cpp b/src/plugins/projectexplorer/customexecutablerunconfiguration.cpp
index 08533f49aa34c2a8916c2de78237b7566b99e926..099100f7c9270081ae3819a8d97bf247c0f8bf5b 100644
--- a/src/plugins/projectexplorer/customexecutablerunconfiguration.cpp
+++ b/src/plugins/projectexplorer/customexecutablerunconfiguration.cpp
@@ -37,6 +37,7 @@
 #include <projectexplorer/target.h>
 #include <utils/detailswidget.h>
 #include <utils/pathchooser.h>
+#include <utils/debuggerlanguagechooser.h>
 
 #include <QtCore/QDir>
 #include <QtGui/QCheckBox>
@@ -102,6 +103,13 @@ CustomExecutableConfigurationWidget::CustomExecutableConfigurationWidget(CustomE
     m_useTerminalCheck = new QCheckBox(tr("Run in &Terminal"), this);
     layout->addRow(QString(), m_useTerminalCheck);
 
+    QLabel *debuggerLabel = new QLabel(tr("Debugger:"), this);
+    m_debuggerLanguageChooser = new Utils::DebuggerLanguageChooser(this);
+    layout->addRow(debuggerLabel, m_debuggerLanguageChooser);
+
+    m_debuggerLanguageChooser->setCppChecked(m_runConfiguration->useCppDebugger());
+    m_debuggerLanguageChooser->setQmlChecked(m_runConfiguration->useQmlDebugger());
+
     QVBoxLayout *vbox = new QVBoxLayout(this);
     vbox->setMargin(0);
 
@@ -154,6 +162,11 @@ CustomExecutableConfigurationWidget::CustomExecutableConfigurationWidget(CustomE
     connect(m_useTerminalCheck, SIGNAL(toggled(bool)),
             this, SLOT(termToggled(bool)));
 
+    connect(m_debuggerLanguageChooser, SIGNAL(cppLanguageToggled(bool)),
+            this, SLOT(useCppDebuggerToggled(bool)));
+    connect(m_debuggerLanguageChooser, SIGNAL(qmlLanguageToggled(bool)),
+            this, SLOT(useQmlDebuggerToggled(bool)));
+
     connect(m_runConfiguration, SIGNAL(changed()), this, SLOT(changed()));
 
     connect(m_environmentWidget, SIGNAL(userChangesChanged()),
@@ -180,6 +193,16 @@ void CustomExecutableConfigurationWidget::baseEnvironmentSelected(int index)
     m_ignoreChange = false;
 }
 
+void CustomExecutableConfigurationWidget::useCppDebuggerToggled(bool toggled)
+{
+    m_runConfiguration->setUseCppDebugger(toggled);
+}
+
+void CustomExecutableConfigurationWidget::useQmlDebuggerToggled(bool toggled)
+{
+    m_runConfiguration->setUseQmlDebugger(toggled);
+}
+
 void CustomExecutableConfigurationWidget::baseEnvironmentChanged()
 {
     if (m_ignoreChange)
@@ -279,6 +302,7 @@ CustomExecutableRunConfiguration::CustomExecutableRunConfiguration(Target *paren
     ctor();
 }
 
+// Note: Qt4Project deletes all empty customexecrunconfigs for which isConfigured() == false.
 CustomExecutableRunConfiguration::~CustomExecutableRunConfiguration()
 {
 }
@@ -466,7 +490,7 @@ bool CustomExecutableRunConfiguration::fromMap(const QVariantMap &map)
     m_baseEnvironmentBase = static_cast<BaseEnvironmentBase>(map.value(QLatin1String(BASE_ENVIRONMENT_BASE_KEY), static_cast<int>(CustomExecutableRunConfiguration::BuildEnvironmentBase)).toInt());
 
     setDefaultDisplayName(defaultDisplayName());
-    return RunConfiguration::fromMap(map);
+    return LocalApplicationRunConfiguration::fromMap(map);
 }
 
 void CustomExecutableRunConfiguration::setExecutable(const QString &executable)
diff --git a/src/plugins/projectexplorer/customexecutablerunconfiguration.h b/src/plugins/projectexplorer/customexecutablerunconfiguration.h
index c59645c1bafee1e361d45e126a0d74159c56466b..704b25516f1fd529e978c9d606275efb1476f64b 100644
--- a/src/plugins/projectexplorer/customexecutablerunconfiguration.h
+++ b/src/plugins/projectexplorer/customexecutablerunconfiguration.h
@@ -46,6 +46,7 @@ QT_END_NAMESPACE
 namespace Utils {
 class DetailsWidget;
 class PathChooser;
+class DebuggerLanguageChooser;
 }
 
 namespace ProjectExplorer {
@@ -184,6 +185,9 @@ private slots:
     void baseEnvironmentChanged();
     void userEnvironmentChangesChanged();
     void baseEnvironmentSelected(int index);
+    void useCppDebuggerToggled(bool toggled);
+    void useQmlDebuggerToggled(bool toggled);
+
 private:
     bool m_ignoreChange;
     CustomExecutableRunConfiguration *m_runConfiguration;
@@ -195,6 +199,7 @@ private:
     ProjectExplorer::EnvironmentWidget *m_environmentWidget;
     QComboBox *m_baseEnvironmentComboBox;
     Utils::DetailsWidget *m_detailsContainer;
+    Utils::DebuggerLanguageChooser *m_debuggerLanguageChooser;
 };
 
 } // namespace Internal
diff --git a/src/plugins/projectexplorer/runconfiguration.cpp b/src/plugins/projectexplorer/runconfiguration.cpp
index 16e4e9ed660e9bc676b2491008f58fa0a5b8a0d6..1e854ecfcca56ce5fd41c74d4a9b5a27b832a134 100644
--- a/src/plugins/projectexplorer/runconfiguration.cpp
+++ b/src/plugins/projectexplorer/runconfiguration.cpp
@@ -52,6 +52,9 @@ using namespace ProjectExplorer;
 namespace {
 // Function objects:
 
+const char * const USE_CPP_DEBUGGER_KEY("RunConfiguration.UseCppDebugger");
+const char * const USE_QML_DEBUGGER_KEY("RunConfiguration.UseQmlDebugger");
+
 class RunConfigurationFactoryMatcher
 {
 public:
@@ -141,7 +144,9 @@ IRunConfigurationFactory * findRunConfigurationFactory(RunConfigurationFactoryMa
 
 // RunConfiguration
 RunConfiguration::RunConfiguration(Target *target, const QString &id) :
-    ProjectConfiguration(target, id)
+    ProjectConfiguration(target, id),
+    m_useCppDebugger(true),
+    m_useQmlDebugger(false)
 {
     Q_ASSERT(target);
 }
@@ -182,6 +187,43 @@ Target *RunConfiguration::target() const
     return static_cast<Target *>(parent());
 }
 
+void RunConfiguration::setUseQmlDebugger(bool value)
+{
+    m_useQmlDebugger = value;
+    emit debuggersChanged();
+}
+
+void RunConfiguration::setUseCppDebugger(bool value)
+{
+    m_useCppDebugger = value;
+    emit debuggersChanged();
+}
+
+bool RunConfiguration::useCppDebugger() const
+{
+    return m_useCppDebugger;
+}
+
+bool RunConfiguration::useQmlDebugger() const
+{
+    return m_useQmlDebugger;
+}
+
+QVariantMap RunConfiguration::toMap() const
+{
+    QVariantMap map(ProjectConfiguration::toMap());
+    map.insert(QLatin1String(USE_CPP_DEBUGGER_KEY), m_useCppDebugger);
+    map.insert(QLatin1String(USE_QML_DEBUGGER_KEY), m_useQmlDebugger);
+    return map;
+}
+
+bool RunConfiguration::fromMap(const QVariantMap &map)
+{
+    m_useCppDebugger = map.value(QLatin1String(USE_CPP_DEBUGGER_KEY), true).toBool();
+    m_useQmlDebugger = map.value(QLatin1String(USE_QML_DEBUGGER_KEY), false).toBool();
+    return ProjectConfiguration::fromMap(map);
+}
+
 ProjectExplorer::OutputFormatter *RunConfiguration::createOutputFormatter() const
 {
     return new OutputFormatter();
diff --git a/src/plugins/projectexplorer/runconfiguration.h b/src/plugins/projectexplorer/runconfiguration.h
index 6dd881a9151142ab70d6ae678c1c2692a0a198a9..5cc172a20b72d40279c3086be42440b58cf99bbc 100644
--- a/src/plugins/projectexplorer/runconfiguration.h
+++ b/src/plugins/projectexplorer/runconfiguration.h
@@ -87,8 +87,15 @@ public:
 
     virtual ProjectExplorer::OutputFormatter *createOutputFormatter() const;
 
+    void setUseQmlDebugger(bool value);
+    void setUseCppDebugger(bool value);
+    bool useQmlDebugger() const;
+    bool useCppDebugger() const;
+    virtual QVariantMap toMap() const;
+
 signals:
     void isEnabledChanged(bool value);
+    void debuggersChanged();
 
 protected:
     RunConfiguration(Target *parent, const QString &id);
@@ -96,6 +103,12 @@ protected:
 
     /// convenience method to get current build configuration.
     BuildConfiguration *activeBuildConfiguration() const;
+
+    virtual bool fromMap(const QVariantMap &map);
+
+private:
+    bool m_useCppDebugger;
+    bool m_useQmlDebugger;
 };
 
 /**
diff --git a/src/plugins/qmlprojectmanager/qmlprojectrunconfiguration.cpp b/src/plugins/qmlprojectmanager/qmlprojectrunconfiguration.cpp
index 9814a7bff2a3fc017d4195687e8703b27aa34cd9..7d362325b26b1e12686b2acbdc805179760c4ed0 100644
--- a/src/plugins/qmlprojectmanager/qmlprojectrunconfiguration.cpp
+++ b/src/plugins/qmlprojectmanager/qmlprojectrunconfiguration.cpp
@@ -41,6 +41,7 @@
 #include <coreplugin/ifile.h>
 #include <utils/synchronousprocess.h>
 #include <utils/pathchooser.h>
+#include <utils/debuggerlanguagechooser.h>
 #include <qt4projectmanager/qtversionmanager.h>
 #include <qt4projectmanager/qt4projectmanagerconstants.h>
 
@@ -92,6 +93,10 @@ bool QmlProjectRunConfiguration::isEnabled(ProjectExplorer::BuildConfiguration *
 
 void QmlProjectRunConfiguration::ctor()
 {
+    // reset default settings in constructor
+    setUseCppDebugger(false);
+    setUseQmlDebugger(true);
+
     Core::EditorManager *em = Core::EditorManager::instance();
     connect(em, SIGNAL(currentEditorChanged(Core::IEditor*)),
             this, SLOT(changeCurrentFile(Core::IEditor*)));
@@ -202,7 +207,19 @@ QWidget *QmlProjectRunConfiguration::createConfigurationWidget()
     form->addRow(tr("Debugging Address:"), debugServer);
     form->addRow(tr("Debugging Port:"), debugPort);
 
+    QLabel *debuggerLabel = new QLabel(tr("Debugger:"), config);
+    Utils::DebuggerLanguageChooser *debuggerLanguageChooser = new Utils::DebuggerLanguageChooser(config);
+
     form->addRow(tr("Main QML File:"), m_fileListCombo.data());
+    form->addRow(debuggerLabel, debuggerLanguageChooser);
+
+    debuggerLanguageChooser->setCppChecked(useCppDebugger());
+    debuggerLanguageChooser->setQmlChecked(useQmlDebugger());
+
+    connect(debuggerLanguageChooser, SIGNAL(cppLanguageToggled(bool)),
+            this, SLOT(useCppDebuggerToggled(bool)));
+    connect(debuggerLanguageChooser, SIGNAL(qmlLanguageToggled(bool)),
+            this, SLOT(useQmlDebuggerToggled(bool)));
 
     return config;
 }
@@ -298,6 +315,17 @@ void QmlProjectRunConfiguration::onDebugServerPortChanged()
     }
 }
 
+void QmlProjectRunConfiguration::useCppDebuggerToggled(bool toggled)
+{
+    setUseCppDebugger(toggled);
+}
+
+void QmlProjectRunConfiguration::useQmlDebuggerToggled(bool toggled)
+{
+    setUseQmlDebugger(toggled);
+}
+
+
 QVariantMap QmlProjectRunConfiguration::toMap() const
 {
     QVariantMap map(ProjectExplorer::RunConfiguration::toMap());
diff --git a/src/plugins/qmlprojectmanager/qmlprojectrunconfiguration.h b/src/plugins/qmlprojectmanager/qmlprojectrunconfiguration.h
index 1c3f12cd6ed1e2ad04f0f870b0d0f432a858ec1d..f7f5c29b02b3388f0e77cdc6cc9549e17390f9b3 100644
--- a/src/plugins/qmlprojectmanager/qmlprojectrunconfiguration.h
+++ b/src/plugins/qmlprojectmanager/qmlprojectrunconfiguration.h
@@ -99,6 +99,8 @@ private slots:
     void onViewerArgsChanged();
     void onDebugServerAddressChanged();
     void onDebugServerPortChanged();
+    void useCppDebuggerToggled(bool toggled);
+    void useQmlDebuggerToggled(bool toggled);
 
 protected:
     QString viewerDefaultPath() const;
diff --git a/src/plugins/qt4projectmanager/qt4runconfiguration.cpp b/src/plugins/qt4projectmanager/qt4runconfiguration.cpp
index 4b4e445398b268ad20e253a12f2db1196bc93375..918881a31c46bbff20b7cf30c0a78d3a17b41db2 100644
--- a/src/plugins/qt4projectmanager/qt4runconfiguration.cpp
+++ b/src/plugins/qt4projectmanager/qt4runconfiguration.cpp
@@ -49,6 +49,7 @@
 #include <utils/qtcassert.h>
 #include <utils/pathchooser.h>
 #include <utils/detailswidget.h>
+#include <utils/debuggerlanguagechooser.h>
 
 #include <QtGui/QFormLayout>
 #include <QtGui/QInputDialog>
@@ -223,6 +224,13 @@ Qt4RunConfigurationWidget::Qt4RunConfigurationWidget(Qt4RunConfiguration *qt4Run
     m_useTerminalCheck->setChecked(m_qt4RunConfiguration->runMode() == ProjectExplorer::LocalApplicationRunConfiguration::Console);
     toplayout->addRow(QString(), m_useTerminalCheck);
 
+    QLabel *debuggerLabel = new QLabel(tr("Debugger:"), this);
+    m_debuggerLanguageChooser = new Utils::DebuggerLanguageChooser(this);
+    toplayout->addRow(debuggerLabel, m_debuggerLanguageChooser);
+
+    m_debuggerLanguageChooser->setCppChecked(m_qt4RunConfiguration->useCppDebugger());
+    m_debuggerLanguageChooser->setQmlChecked(m_qt4RunConfiguration->useQmlDebugger());
+
 #ifdef Q_OS_MAC
     m_usingDyldImageSuffix = new QCheckBox(tr("Use debug version of frameworks (DYLD_IMAGE_SUFFIX=_debug)"), this);
     m_usingDyldImageSuffix->setChecked(m_qt4RunConfiguration->isUsingDyldImageSuffix());
@@ -273,6 +281,11 @@ Qt4RunConfigurationWidget::Qt4RunConfigurationWidget(Qt4RunConfiguration *qt4Run
     connect(m_useTerminalCheck, SIGNAL(toggled(bool)),
             this, SLOT(termToggled(bool)));
 
+    connect(m_debuggerLanguageChooser, SIGNAL(cppLanguageToggled(bool)),
+            this, SLOT(useCppDebuggerToggled(bool)));
+    connect(m_debuggerLanguageChooser, SIGNAL(qmlLanguageToggled(bool)),
+            this, SLOT(useQmlDebuggerToggled(bool)));
+
     connect(m_environmentWidget, SIGNAL(userChangesChanged()),
             this, SLOT(userChangesEdited()));
 
@@ -299,6 +312,16 @@ Qt4RunConfigurationWidget::~Qt4RunConfigurationWidget()
 {
 }
 
+void Qt4RunConfigurationWidget::useCppDebuggerToggled(bool toggled)
+{
+    m_qt4RunConfiguration->setUseCppDebugger(toggled);
+}
+
+void Qt4RunConfigurationWidget::useQmlDebuggerToggled(bool toggled)
+{
+    m_qt4RunConfiguration->setUseQmlDebugger(toggled);
+}
+
 void Qt4RunConfigurationWidget::baseEnvironmentSelected(int index)
 {
     m_ignoreChange = true;
diff --git a/src/plugins/qt4projectmanager/qt4runconfiguration.h b/src/plugins/qt4projectmanager/qt4runconfiguration.h
index 99031e84958655020c0c675721ed34ed46057a40..82bd1aa93cb654b289b72e15560fcda7fd9939c7 100644
--- a/src/plugins/qt4projectmanager/qt4runconfiguration.h
+++ b/src/plugins/qt4projectmanager/qt4runconfiguration.h
@@ -43,6 +43,7 @@ QT_END_NAMESPACE
 
 namespace Utils {
 class PathChooser;
+class DebuggerLanguageChooser;
 class DetailsWidget;
 }
 
@@ -172,6 +173,8 @@ private slots:
     void usingDyldImageSuffixToggled(bool);
     void usingDyldImageSuffixChanged(bool);
     void baseEnvironmentSelected(int index);
+    void useCppDebuggerToggled(bool toggled);
+    void useQmlDebuggerToggled(bool toggled);
 
 private:
     Qt4RunConfiguration *m_qt4RunConfiguration;
@@ -184,7 +187,7 @@ private:
 
     QComboBox *m_baseEnvironmentComboBox;
     Utils::DetailsWidget *m_detailsContainer;
-
+    Utils::DebuggerLanguageChooser *m_debuggerLanguageChooser;
     ProjectExplorer::EnvironmentWidget *m_environmentWidget;
     bool m_isShown;
 };