diff --git a/src/plugins/baremetal/baremetalrunconfigurationfactory.cpp b/src/plugins/baremetal/baremetalrunconfigurationfactory.cpp
index 5ef7836a002..90a2508fd17 100644
--- a/src/plugins/baremetal/baremetalrunconfigurationfactory.cpp
+++ b/src/plugins/baremetal/baremetalrunconfigurationfactory.cpp
@@ -45,48 +45,26 @@ BareMetalRunConfigurationFactory::BareMetalRunConfigurationFactory(QObject *pare
     IRunConfigurationFactory(parent)
 {
     setObjectName("BareMetalRunConfigurationFactory");
-    registerRunConfiguration<BareMetalRunConfiguration>();
+    registerRunConfiguration<BareMetalRunConfiguration>(BareMetalRunConfiguration::IdPrefix);
     setSupportedTargetDeviceTypes({BareMetal::Constants::BareMetalOsType});
 }
 
-bool BareMetalRunConfigurationFactory::canCreate(Target *parent, Core::Id id) const
+bool BareMetalRunConfigurationFactory::canCreateHelper(Target *parent, const QString &buildTarget) const
 {
-    if (!canHandle(parent))
-        return false;
-    const QString targetName = BareMetalRunConfiguration::targetNameFromId(id);
-    return !parent->applicationTargets().targetFilePath(targetName).isEmpty();
+    const QString targetName = QFileInfo(buildTarget).fileName();
+    return parent->applicationTargets().hasTarget(targetName);
 }
 
-bool BareMetalRunConfigurationFactory::canRestore(Target *parent, const QVariantMap &map) const
+QList<QString> BareMetalRunConfigurationFactory::availableBuildTargets(Target *parent, CreationMode) const
 {
-    if (!canHandle(parent))
-        return false;
-    return idFromMap(map).name().startsWith(BareMetalRunConfiguration::IdPrefix);
+    return Utils::transform(parent->applicationTargets().list, [](const BuildTargetInfo &bti) {
+        return QString(bti.projectFilePath.toString() + '/' + bti.targetName);
+    });
 }
 
-bool BareMetalRunConfigurationFactory::canClone(Target *parent, RunConfiguration *source) const
+QString BareMetalRunConfigurationFactory::displayNameForBuildTarget(const QString &buildTarget) const
 {
-    auto bmrc = qobject_cast<BareMetalRunConfiguration *>(source);
-    return bmrc && canCreate(parent, source->id());
-}
-
-QList<Core::Id> BareMetalRunConfigurationFactory::availableCreationIds(Target *parent, CreationMode mode) const
-{
-    Q_UNUSED(mode)
-    QList<Core::Id> result;
-    if (!canHandle(parent))
-        return result;
-
-    const Core::Id base = Core::Id(BareMetalRunConfiguration::IdPrefix);
-    foreach (const BuildTargetInfo &bti, parent->applicationTargets().list)
-        result << base.withSuffix(bti.projectFilePath.toString() + QLatin1Char('/') + bti.targetName);
-    return result;
-}
-
-QString BareMetalRunConfigurationFactory::displayNameForId(Core::Id id) const
-{
-    return tr("%1 (on GDB server or hardware debugger)")
-        .arg(BareMetalRunConfiguration::targetNameFromId(id));
+    return tr("%1 (on GDB server or hardware debugger)").arg(QFileInfo(buildTarget).fileName());
 }
 
 
@@ -96,43 +74,17 @@ BareMetalCustomRunConfigurationFactory::BareMetalCustomRunConfigurationFactory(Q
     IRunConfigurationFactory(parent)
 {
     setObjectName("BareMetalCustomRunConfigurationFactory");
-    registerRunConfiguration<BareMetalCustomRunConfiguration>();
+    registerRunConfiguration<BareMetalCustomRunConfiguration>
+            (BareMetalCustomRunConfiguration::runConfigId());
     setSupportedTargetDeviceTypes({BareMetal::Constants::BareMetalOsType});
 }
 
-bool BareMetalCustomRunConfigurationFactory::canCreate(Target *parent, Core::Id id) const
+QList<QString> BareMetalCustomRunConfigurationFactory::availableBuildTargets(Target *, CreationMode) const
 {
-    if (!canHandle(parent))
-        return false;
-    return id == BareMetalCustomRunConfiguration::runConfigId();
+    return {QString()};
 }
 
-bool BareMetalCustomRunConfigurationFactory::canRestore(Target *parent, const QVariantMap &map) const
-{
-    if (!canHandle(parent))
-        return false;
-    const Core::Id id = idFromMap(map);
-    return id == BareMetalCustomRunConfiguration::runConfigId();
-}
-
-bool BareMetalCustomRunConfigurationFactory::canClone(Target *parent, RunConfiguration *source) const
-{
-    auto bmrc = qobject_cast<BareMetalCustomRunConfiguration *>(source);
-    return bmrc && canCreate(parent, source->id());
-}
-
-QList<Core::Id> BareMetalCustomRunConfigurationFactory::availableCreationIds(Target *parent, CreationMode mode) const
-{
-    Q_UNUSED(mode)
-    QList<Core::Id> result;
-    if (!canHandle(parent))
-        return result;
-
-    result << BareMetalCustomRunConfiguration::runConfigId();
-    return result;
-}
-
-QString BareMetalCustomRunConfigurationFactory::displayNameForId(Core::Id) const
+QString BareMetalCustomRunConfigurationFactory::displayNameForBuildTarget(const QString &) const
 {
     return BareMetalCustomRunConfiguration::runConfigDefaultDisplayName();
 }
diff --git a/src/plugins/baremetal/baremetalrunconfigurationfactory.h b/src/plugins/baremetal/baremetalrunconfigurationfactory.h
index 92e439f1e5e..039ff3bc408 100644
--- a/src/plugins/baremetal/baremetalrunconfigurationfactory.h
+++ b/src/plugins/baremetal/baremetalrunconfigurationfactory.h
@@ -37,12 +37,10 @@ class BareMetalRunConfigurationFactory : public ProjectExplorer::IRunConfigurati
 public:
     explicit BareMetalRunConfigurationFactory(QObject *parent = 0);
 
-    QString displayNameForId(Core::Id id) const override;
-    QList<Core::Id> availableCreationIds(ProjectExplorer::Target *parent, CreationMode mode) const override;
+    QList<QString> availableBuildTargets(ProjectExplorer::Target *parent, CreationMode mode) const override;
+    QString displayNameForBuildTarget(const QString &buildTarget) const override;
 
-    bool canCreate(ProjectExplorer::Target *parent, Core::Id id) const override;
-    bool canRestore(ProjectExplorer::Target *parent, const QVariantMap &map) const override;
-    bool canClone(ProjectExplorer::Target *parent, ProjectExplorer::RunConfiguration *source) const override;
+    bool canCreateHelper(ProjectExplorer::Target *parent, const QString &suffix) const override;
 };
 
 class BareMetalCustomRunConfigurationFactory : public ProjectExplorer::IRunConfigurationFactory
@@ -52,12 +50,8 @@ class BareMetalCustomRunConfigurationFactory : public ProjectExplorer::IRunConfi
 public:
     explicit BareMetalCustomRunConfigurationFactory(QObject *parent = 0);
 
-    QString displayNameForId(Core::Id id) const override;
-    QList<Core::Id> availableCreationIds(ProjectExplorer::Target *parent, CreationMode mode) const override;
-
-    bool canCreate(ProjectExplorer::Target *parent, Core::Id id) const override;
-    bool canRestore(ProjectExplorer::Target *parent, const QVariantMap &map) const override;
-    bool canClone(ProjectExplorer::Target *parent, ProjectExplorer::RunConfiguration *source) const override;
+    QList<QString> availableBuildTargets(ProjectExplorer::Target *parent, CreationMode mode) const override;
+    QString displayNameForBuildTarget(const QString &buildTarget) const override;
 };
 
 } // namespace Internal
diff --git a/src/plugins/cmakeprojectmanager/cmakerunconfiguration.cpp b/src/plugins/cmakeprojectmanager/cmakerunconfiguration.cpp
index 0b63588972a..5272547da66 100644
--- a/src/plugins/cmakeprojectmanager/cmakerunconfiguration.cpp
+++ b/src/plugins/cmakeprojectmanager/cmakerunconfiguration.cpp
@@ -232,57 +232,18 @@ CMakeRunConfigurationFactory::CMakeRunConfigurationFactory(QObject *parent) :
     IRunConfigurationFactory(parent)
 {
     setObjectName("CMakeRunConfigurationFactory");
-    registerRunConfiguration<CMakeRunConfiguration>();
+    registerRunConfiguration<CMakeRunConfiguration>(CMAKE_RC_PREFIX);
     setSupportedProjectType<CMakeProject>();
 }
 
-// used to show the list of possible additons to a project, returns a list of ids
-QList<Core::Id> CMakeRunConfigurationFactory::availableCreationIds(Target *parent, CreationMode mode) const
+QList<QString> CMakeRunConfigurationFactory::availableBuildTargets(Target *parent, CreationMode) const
 {
-    Q_UNUSED(mode)
-    if (!canHandle(parent))
-        return QList<Core::Id>();
     CMakeProject *project = static_cast<CMakeProject *>(parent->project());
-    QList<Core::Id> allIds;
-    foreach (const QString &buildTarget, project->buildTargetTitles(true))
-        allIds << idFromBuildTarget(buildTarget);
-    return allIds;
+    return project->buildTargetTitles(true);
 }
 
-// used to translate the ids to names to display to the user
-QString CMakeRunConfigurationFactory::displayNameForId(Core::Id id) const
+bool CMakeRunConfigurationFactory::canCreateHelper(Target *parent, const QString &buildTarget) const
 {
-    return buildTargetFromId(id);
-}
-
-bool CMakeRunConfigurationFactory::canCreate(Target *parent, Core::Id id) const
-{
-    if (!canHandle(parent))
-        return false;
     CMakeProject *project = static_cast<CMakeProject *>(parent->project());
-    return project->hasBuildTarget(buildTargetFromId(id));
-}
-
-bool CMakeRunConfigurationFactory::canClone(Target *parent, RunConfiguration *source) const
-{
-    if (!canHandle(parent))
-        return false;
-    return source->id().name().startsWith(CMAKE_RC_PREFIX);
-}
-
-bool CMakeRunConfigurationFactory::canRestore(Target *parent, const QVariantMap &map) const
-{
-    if (!qobject_cast<CMakeProject *>(parent->project()))
-        return false;
-    return idFromMap(map).name().startsWith(CMAKE_RC_PREFIX);
-}
-
-QString CMakeRunConfigurationFactory::buildTargetFromId(Core::Id id)
-{
-    return id.suffixAfter(CMAKE_RC_PREFIX);
-}
-
-Core::Id CMakeRunConfigurationFactory::idFromBuildTarget(const QString &target)
-{
-    return Core::Id(CMAKE_RC_PREFIX).withSuffix(target);
+    return project->hasBuildTarget(buildTarget);
 }
diff --git a/src/plugins/cmakeprojectmanager/cmakerunconfiguration.h b/src/plugins/cmakeprojectmanager/cmakerunconfiguration.h
index 62c672e2773..7551f34f27e 100644
--- a/src/plugins/cmakeprojectmanager/cmakerunconfiguration.h
+++ b/src/plugins/cmakeprojectmanager/cmakerunconfiguration.h
@@ -85,15 +85,8 @@ class CMakeRunConfigurationFactory : public ProjectExplorer::IRunConfigurationFa
 public:
     explicit CMakeRunConfigurationFactory(QObject *parent = 0);
 
-    bool canCreate(ProjectExplorer::Target *parent, Core::Id id) const override;
-    bool canRestore(ProjectExplorer::Target *parent, const QVariantMap &map) const override;
-    bool canClone(ProjectExplorer::Target *parent, ProjectExplorer::RunConfiguration *product) const override;
-
-    QList<Core::Id> availableCreationIds(ProjectExplorer::Target *parent, CreationMode mode) const override;
-    QString displayNameForId(Core::Id id) const override;
-
-    static Core::Id idFromBuildTarget(const QString &target);
-    static QString buildTargetFromId(Core::Id id);
+    QList<QString> availableBuildTargets(ProjectExplorer::Target *parent, CreationMode mode) const override;
+    bool canCreateHelper(ProjectExplorer::Target *parent, const QString &suffix) const override;
 };
 
 } // namespace Internal
diff --git a/src/plugins/ios/iosrunfactories.cpp b/src/plugins/ios/iosrunfactories.cpp
index f37ffbecb18..8de2583e56f 100644
--- a/src/plugins/ios/iosrunfactories.cpp
+++ b/src/plugins/ios/iosrunfactories.cpp
@@ -47,44 +47,26 @@ IosRunConfigurationFactory::IosRunConfigurationFactory(QObject *parent)
     : QmakeRunConfigurationFactory(parent)
 {
     setObjectName("IosRunConfigurationFactory");
-    registerRunConfiguration<IosRunConfiguration>();
+    registerRunConfiguration<IosRunConfiguration>(Constants::IOS_RC_ID_PREFIX);
     setSupportedProjectType<QmakeProject>();
 }
 
-bool IosRunConfigurationFactory::canCreate(Target *parent, Core::Id id) const
+bool IosRunConfigurationFactory::canCreateHelper(Target *parent, const QString &buildTarget) const
 {
-    if (!canHandle(parent))
-        return false;
-    return availableCreationIds(parent).contains(id);
+    return availableBuildTargets(parent, UserCreate).contains(buildTarget);
 }
 
-bool IosRunConfigurationFactory::canRestore(Target *parent, const QVariantMap &map) const
+QList<QString> IosRunConfigurationFactory::availableBuildTargets(Target *parent, CreationMode mode) const
 {
-    if (!canHandle(parent))
-        return false;
-    QString id = ProjectExplorer::idFromMap(map).toString();
-    return id.startsWith(Ios::Constants::IOS_RC_ID_PREFIX);
-}
-
-bool IosRunConfigurationFactory::canClone(Target *parent, RunConfiguration *source) const
-{
-    return canCreate(parent, source->id());
-}
-
-QList<Core::Id> IosRunConfigurationFactory::availableCreationIds(Target *parent, CreationMode mode) const
-{
-    if (!IosManager::supportsIos(parent))
-        return QList<Core::Id>();
-
     auto project = static_cast<QmakeProject *>(parent->project());
-    return project->creationIds(Constants::IOS_RC_ID_PREFIX, mode, {ProjectType::ApplicationTemplate,
-                                                                    ProjectType::SharedLibraryTemplate,
-                                                                    ProjectType::AuxTemplate});
+    return project->buildTargets(mode, {ProjectType::ApplicationTemplate,
+                                        ProjectType::SharedLibraryTemplate,
+                                        ProjectType::AuxTemplate});
 }
 
-QString IosRunConfigurationFactory::displayNameForId(Core::Id id) const
+QString IosRunConfigurationFactory::displayNameForBuildTarget(const QString &buildTarget) const
 {
-    return IosRunConfiguration::pathFromId(id).toFileInfo().completeBaseName();
+    return QFileInfo(buildTarget).completeBaseName();
 }
 
 bool IosRunConfigurationFactory::canHandle(Target *t) const
diff --git a/src/plugins/ios/iosrunfactories.h b/src/plugins/ios/iosrunfactories.h
index 27fdc249f62..0b64e3a7eec 100644
--- a/src/plugins/ios/iosrunfactories.h
+++ b/src/plugins/ios/iosrunfactories.h
@@ -43,17 +43,12 @@ class IosRunConfigurationFactory : public QmakeProjectManager::QmakeRunConfigura
 public:
     explicit IosRunConfigurationFactory(QObject *parent = 0);
 
-    QString displayNameForId(Core::Id id) const override;
-    QList<Core::Id> availableCreationIds(ProjectExplorer::Target *parent, CreationMode mode = UserCreate) const override;
-
-    bool canCreate(ProjectExplorer::Target *parent, Core::Id id) const override;
-
-    bool canRestore(ProjectExplorer::Target *parent, const QVariantMap &map) const override;
-
-    bool canClone(ProjectExplorer::Target *parent,
-                                  ProjectExplorer::RunConfiguration *source) const override;
+    QList<QString> availableBuildTargets(ProjectExplorer::Target *parent, CreationMode mode) const override;
+    QString displayNameForBuildTarget(const QString &buildTarget) const override;
 
     bool canHandle(ProjectExplorer::Target *t) const override;
+    bool canCreateHelper(ProjectExplorer::Target *parent, const QString &suffix) const override;
+
     QList<ProjectExplorer::RunConfiguration *> runConfigurationsForNode(ProjectExplorer::Target *t,
                                                                         const ProjectExplorer::Node *n
                                                                         ) override;
diff --git a/src/plugins/nim/project/nimrunconfigurationfactory.cpp b/src/plugins/nim/project/nimrunconfigurationfactory.cpp
index 92afa82fee6..223807361d4 100644
--- a/src/plugins/nim/project/nimrunconfigurationfactory.cpp
+++ b/src/plugins/nim/project/nimrunconfigurationfactory.cpp
@@ -38,43 +38,18 @@ namespace Nim {
 
 NimRunConfigurationFactory::NimRunConfigurationFactory()
 {
-    registerRunConfiguration<NimRunConfiguration>();
+    registerRunConfiguration<NimRunConfiguration>(Constants::C_NIMRUNCONFIGURATION_ID);
     setSupportedProjectType<NimProject>();
 }
 
-QList<Core::Id> NimRunConfigurationFactory::availableCreationIds(Target *parent,
-                                                                 IRunConfigurationFactory::CreationMode mode) const
+QList<QString> NimRunConfigurationFactory::availableBuildTargets(Target *, CreationMode) const
 {
-    Q_UNUSED(mode);
-    QList<Core::Id> result;
-    if (canHandle(parent))
-        result.append(Constants::C_NIMRUNCONFIGURATION_ID);
-    return result;
+    return {QString()};
 }
 
-QString NimRunConfigurationFactory::displayNameForId(Core::Id id) const
+QString NimRunConfigurationFactory::displayNameForBuildTarget(const QString &buildTarget) const
 {
-    return id.toString() + QStringLiteral("-TempRunConf");
-}
-
-bool NimRunConfigurationFactory::canCreate(Target *parent, Core::Id id) const
-{
-    Q_UNUSED(id);
-    return canHandle(parent);
-}
-
-bool NimRunConfigurationFactory::canRestore(Target *parent, const QVariantMap &map) const
-{
-    Q_UNUSED(parent);
-    Q_UNUSED(map);
-    return canHandle(parent);
-}
-
-bool NimRunConfigurationFactory::canClone(Target *parent, RunConfiguration *product) const
-{
-    QTC_ASSERT(parent, return false);
-    QTC_ASSERT(product, return false);
-    return canHandle(parent);
+    return buildTarget + "-TempRunConf";
 }
 
 }
diff --git a/src/plugins/nim/project/nimrunconfigurationfactory.h b/src/plugins/nim/project/nimrunconfigurationfactory.h
index d0e22852080..c88c9fe21aa 100644
--- a/src/plugins/nim/project/nimrunconfigurationfactory.h
+++ b/src/plugins/nim/project/nimrunconfigurationfactory.h
@@ -34,13 +34,8 @@ class NimRunConfigurationFactory : public ProjectExplorer::IRunConfigurationFact
 public:
     NimRunConfigurationFactory();
 
-    QList<Core::Id> availableCreationIds(ProjectExplorer::Target *parent, CreationMode mode) const override;
-
-    QString displayNameForId(Core::Id id) const override;
-
-    bool canCreate(ProjectExplorer::Target *parent, Core::Id id) const override;
-    bool canRestore(ProjectExplorer::Target *parent, const QVariantMap &map) const override;
-    bool canClone(ProjectExplorer::Target *parent, ProjectExplorer::RunConfiguration *product) const override;
+    QList<QString> availableBuildTargets(ProjectExplorer::Target *parent, CreationMode mode) const override;
+    QString displayNameForBuildTarget(const QString &) const override;
 };
 
 }
diff --git a/src/plugins/projectexplorer/customexecutablerunconfiguration.cpp b/src/plugins/projectexplorer/customexecutablerunconfiguration.cpp
index a13e7b4e137..7f357fc774e 100644
--- a/src/plugins/projectexplorer/customexecutablerunconfiguration.cpp
+++ b/src/plugins/projectexplorer/customexecutablerunconfiguration.cpp
@@ -316,44 +316,17 @@ CustomExecutableRunConfigurationFactory::CustomExecutableRunConfigurationFactory
     IRunConfigurationFactory(parent)
 {
     setObjectName("CustomExecutableRunConfigurationFactory");
-    registerRunConfiguration<CustomExecutableRunConfiguration>();
+    registerRunConfiguration<CustomExecutableRunConfiguration>(CUSTOM_EXECUTABLE_ID);
 }
 
-bool CustomExecutableRunConfigurationFactory::canCreate(Target *parent, Core::Id id) const
+QList<QString> CustomExecutableRunConfigurationFactory::availableBuildTargets(Target *, CreationMode) const
 {
-    if (!canHandle(parent))
-        return false;
-    return id == CUSTOM_EXECUTABLE_ID;
+    return {QString()};
 }
 
-bool CustomExecutableRunConfigurationFactory::canRestore(Target *parent,
-                                                         const QVariantMap &map) const
+QString CustomExecutableRunConfigurationFactory::displayNameForBuildTarget(const QString &) const
 {
-    if (!canHandle(parent))
-        return false;
-    Core::Id id(idFromMap(map));
-    return canCreate(parent, id);
-}
-
-bool CustomExecutableRunConfigurationFactory::canClone(Target *parent,
-                                                       RunConfiguration *source) const
-{
-    return canCreate(parent, source->id());
-}
-
-QList<Core::Id> CustomExecutableRunConfigurationFactory::availableCreationIds(Target *parent, CreationMode mode) const
-{
-    Q_UNUSED(mode)
-    if (!canHandle(parent))
-        return QList<Core::Id>();
-    return QList<Core::Id>() << Core::Id(CUSTOM_EXECUTABLE_ID);
-}
-
-QString CustomExecutableRunConfigurationFactory::displayNameForId(Core::Id id) const
-{
-    if (id == CUSTOM_EXECUTABLE_ID)
-        return tr("Custom Executable");
-    return QString();
+    return tr("Custom Executable");
 }
 
 } // namespace ProjectExplorer
diff --git a/src/plugins/projectexplorer/customexecutablerunconfiguration.h b/src/plugins/projectexplorer/customexecutablerunconfiguration.h
index cfab1307af4..483954e7afa 100644
--- a/src/plugins/projectexplorer/customexecutablerunconfiguration.h
+++ b/src/plugins/projectexplorer/customexecutablerunconfiguration.h
@@ -95,12 +95,8 @@ class CustomExecutableRunConfigurationFactory : public IRunConfigurationFactory
 public:
     explicit CustomExecutableRunConfigurationFactory(QObject *parent = 0);
 
-    QList<Core::Id> availableCreationIds(Target *parent, CreationMode mode) const override;
-    QString displayNameForId(Core::Id id) const override;
-
-    bool canCreate(Target *parent, Core::Id id) const override;
-    bool canRestore(Target *parent, const QVariantMap &map) const override;
-    bool canClone(Target *parent, RunConfiguration *product) const override;
+    QList<QString> availableBuildTargets(Target *parent, CreationMode mode) const override;
+    QString displayNameForBuildTarget(const QString &) const override;
 };
 
 } // namespace ProjectExplorer
diff --git a/src/plugins/projectexplorer/runconfiguration.cpp b/src/plugins/projectexplorer/runconfiguration.cpp
index 9613768eaaf..512ae87491e 100644
--- a/src/plugins/projectexplorer/runconfiguration.cpp
+++ b/src/plugins/projectexplorer/runconfiguration.cpp
@@ -450,6 +450,25 @@ IRunConfigurationFactory::IRunConfigurationFactory(QObject *parent) :
 {
 }
 
+QList<Core::Id> IRunConfigurationFactory::availableCreationIds(Target *parent, CreationMode mode) const
+{
+    if (!canHandle(parent))
+        return {};
+    return Utils::transform(availableBuildTargets(parent, mode), [this](const QString &suffix) {
+        return m_runConfigBaseId.withSuffix(suffix);
+    });
+}
+
+QString IRunConfigurationFactory::displayNameForId(Core::Id id) const
+{
+    return displayNameForBuildTarget(id.suffixAfter(m_runConfigBaseId));
+}
+
+QString IRunConfigurationFactory::displayNameForBuildTarget(const QString &buildTarget) const
+{
+    return buildTarget;
+}
+
 /*!
     Specifies a list of device types for which this RunConfigurationFactory
     can create RunConfiguration.
@@ -477,6 +496,20 @@ bool IRunConfigurationFactory::canHandle(Target *target) const
     return true;
 }
 
+bool IRunConfigurationFactory::canCreateHelper(Target *, const QString &) const
+{
+    return true;
+}
+
+bool IRunConfigurationFactory::canCreate(Target *parent, Core::Id id) const
+{
+    if (!canHandle(parent))
+        return false;
+    if (!id.name().startsWith(m_runConfigBaseId.name()))
+        return false;
+    return canCreateHelper(parent, id.suffixAfter(m_runConfigBaseId));
+}
+
 RunConfiguration *IRunConfigurationFactory::create(Target *parent, Core::Id id)
 {
     if (!canCreate(parent, id))
@@ -489,6 +522,21 @@ RunConfiguration *IRunConfigurationFactory::create(Target *parent, Core::Id id)
     return rc;
 }
 
+bool IRunConfigurationFactory::canCloneHelper(Target *, RunConfiguration *) const
+{
+    return true;
+}
+
+bool IRunConfigurationFactory::canClone(Target *parent, RunConfiguration *product) const
+{
+    if (!canHandle(parent))
+        return false;
+    const Core::Id id = product->id();
+    if (!id.name().startsWith(m_runConfigBaseId.name()))
+        return false;
+    return canCloneHelper(parent, product);
+}
+
 RunConfiguration *IRunConfigurationFactory::restore(Target *parent, const QVariantMap &map)
 {
     if (!canRestore(parent, map))
@@ -504,6 +552,14 @@ RunConfiguration *IRunConfigurationFactory::restore(Target *parent, const QVaria
     return rc;
 }
 
+bool IRunConfigurationFactory::canRestore(Target *parent, const QVariantMap &map) const
+{
+    if (!canHandle(parent))
+        return false;
+    const Core::Id id = idFromMap(map);
+    return id.name().startsWith(m_runConfigBaseId.name());
+}
+
 RunConfiguration *IRunConfigurationFactory::clone(Target *parent, RunConfiguration *product)
 {
     QTC_ASSERT(m_creator, return nullptr);
diff --git a/src/plugins/projectexplorer/runconfiguration.h b/src/plugins/projectexplorer/runconfiguration.h
index 0bd1115bf53..f9166d83126 100644
--- a/src/plugins/projectexplorer/runconfiguration.h
+++ b/src/plugins/projectexplorer/runconfiguration.h
@@ -285,15 +285,16 @@ public:
     explicit IRunConfigurationFactory(QObject *parent = nullptr);
 
     enum CreationMode {UserCreate, AutoCreate};
-    virtual QList<Core::Id> availableCreationIds(Target *parent, CreationMode mode = UserCreate) const = 0;
-    virtual QString displayNameForId(Core::Id id) const = 0;
+    QList<Core::Id> availableCreationIds(Target *parent, CreationMode mode = UserCreate) const;
+    QString displayNameForId(Core::Id id) const;
 
     virtual bool canHandle(Target *target) const;
-    virtual bool canCreate(Target *parent, Core::Id id) const = 0;
+
+    bool canCreate(Target *parent, Core::Id id) const;
     RunConfiguration *create(Target *parent, Core::Id id);
-    virtual bool canRestore(Target *parent, const QVariantMap &map) const = 0;
+    bool canRestore(Target *parent, const QVariantMap &map) const;
     RunConfiguration *restore(Target *parent, const QVariantMap &map);
-    virtual bool canClone(Target *parent, RunConfiguration *product) const = 0;
+    bool canClone(Target *parent, RunConfiguration *product) const;
     RunConfiguration *clone(Target *parent, RunConfiguration *product);
 
     static IRunConfigurationFactory *find(Target *parent, const QVariantMap &map);
@@ -304,12 +305,19 @@ signals:
     void availableCreationIdsChanged();
 
 protected:
+    virtual QList<QString> availableBuildTargets(Target *parent, CreationMode mode = UserCreate) const = 0;
+    virtual QString displayNameForBuildTarget(const QString &buildTarget) const;
+
+    virtual bool canCreateHelper(Target *parent, const QString &buildTarget) const;
+    virtual bool canCloneHelper(Target *parent, RunConfiguration *product) const;
+
     using RunConfigurationCreator = std::function<RunConfiguration *(Target *)>;
 
     template <class RunConfig>
-    void registerRunConfiguration()
+    void registerRunConfiguration(Core::Id runConfigBaseId)
     {
         m_creator = [](Target *t) -> RunConfiguration * { return new RunConfig(t); };
+        m_runConfigBaseId = runConfigBaseId;
     }
 
     using ProjectTypeChecker = std::function<bool(Project *)>;
@@ -324,6 +332,7 @@ protected:
 
 private:
     RunConfigurationCreator m_creator;
+    Core::Id m_runConfigBaseId;
     ProjectTypeChecker m_projectTypeChecker;
     QList<Core::Id> m_supportedTargetDeviceTypes;
 };
diff --git a/src/plugins/pythoneditor/pythoneditorplugin.cpp b/src/plugins/pythoneditor/pythoneditorplugin.cpp
index ab99ca62637..27aacc35c9b 100644
--- a/src/plugins/pythoneditor/pythoneditorplugin.cpp
+++ b/src/plugins/pythoneditor/pythoneditorplugin.cpp
@@ -84,11 +84,6 @@ static QString scriptFromId(Core::Id id)
     return id.suffixAfter(PythonRunConfigurationPrefix);
 }
 
-static Core::Id idFromScript(const QString &target)
-{
-    return Core::Id(PythonRunConfigurationPrefix).withSuffix(target);
-}
-
 class PythonProject : public Project
 {
     Q_OBJECT
@@ -279,52 +274,26 @@ public:
     PythonRunConfigurationFactory()
     {
         setObjectName("PythonRunConfigurationFactory");
-        registerRunConfiguration<PythonRunConfiguration>();
+        registerRunConfiguration<PythonRunConfiguration>(PythonRunConfigurationPrefix);
         setSupportedProjectType<PythonProject>();
     }
 
-    QList<Core::Id> availableCreationIds(Target *parent, CreationMode mode) const override
+    QList<QString> availableBuildTargets(Target *parent, CreationMode mode) const override
     {
         Q_UNUSED(mode);
-        if (!canHandle(parent))
-            return {};
         //return { Core::Id(PythonExecutableId) };
-
         PythonProject *project = static_cast<PythonProject *>(parent->project());
-        QList<Core::Id> allIds;
-        foreach (const QString &file, project->files(ProjectExplorer::Project::AllFiles))
-            allIds.append(idFromScript(file));
-        return allIds;
+        return project->files(ProjectExplorer::Project::AllFiles);
     }
 
-    QString displayNameForId(Core::Id id) const override
+    bool canCreateHelper(Target *parent, const QString &buildTarget) const override
     {
-        return scriptFromId(id);
-    }
-
-    bool canCreate(Target *parent, Core::Id id) const override
-    {
-        if (!canHandle(parent))
-            return false;
         PythonProject *project = static_cast<PythonProject *>(parent->project());
-        const QString script = scriptFromId(id);
+        const QString script = buildTarget;
         if (script.endsWith(".pyqtc"))
             return false;
         return project->files(ProjectExplorer::Project::AllFiles).contains(script);
     }
-
-    bool canRestore(Target *parent, const QVariantMap &map) const override
-    {
-        Q_UNUSED(parent);
-        return idFromMap(map).name().startsWith(PythonRunConfigurationPrefix);
-    }
-
-    bool canClone(Target *parent, RunConfiguration *source) const override
-    {
-        if (!canHandle(parent))
-            return false;
-        return source->id().name().startsWith(PythonRunConfigurationPrefix);
-    }
 };
 
 PythonProject::PythonProject(const FileName &fileName) :
diff --git a/src/plugins/qbsprojectmanager/qbsrunconfiguration.cpp b/src/plugins/qbsprojectmanager/qbsrunconfiguration.cpp
index 49cbbac9fb7..25f83cfd829 100644
--- a/src/plugins/qbsprojectmanager/qbsrunconfiguration.cpp
+++ b/src/plugins/qbsprojectmanager/qbsrunconfiguration.cpp
@@ -72,14 +72,6 @@ const char QBS_RC_PREFIX[] = "Qbs.RunConfiguration:";
 
 static QString rcNameSeparator() { return QLatin1String("---Qbs.RC.NameSeparator---"); }
 
-static Core::Id idFromProduct(const QbsProject *project, const qbs::ProductData &product)
-{
-    QString id = QLatin1String(QBS_RC_PREFIX);
-    id.append(QbsProject::uniqueProductName(product)).append(rcNameSeparator())
-            .append(QbsProject::productDisplayName(project->qbsProject(), product));
-    return Core::Id::fromString(id);
-}
-
 static QString uniqueProductNameFromId(Core::Id id)
 {
     const QString suffix = id.suffixAfter(QBS_RC_PREFIX);
@@ -353,42 +345,25 @@ QbsRunConfigurationFactory::QbsRunConfigurationFactory(QObject *parent) :
     IRunConfigurationFactory(parent)
 {
     setObjectName("QbsRunConfigurationFactory");
-    registerRunConfiguration<QbsRunConfiguration>();
+    registerRunConfiguration<QbsRunConfiguration>(QBS_RC_PREFIX);
     setSupportedProjectType<QbsProject>();
     setSupportedTargetDeviceTypes({Constants::DESKTOP_DEVICE_TYPE});
 }
 
-bool QbsRunConfigurationFactory::canCreate(Target *parent, Core::Id id) const
+bool QbsRunConfigurationFactory::canCreateHelper(Target *parent, const QString &buildTarget) const
 {
-    if (!canHandle(parent))
-        return false;
-
     QbsProject *project = static_cast<QbsProject *>(parent->project());
-    return findProduct(project->qbsProjectData(), uniqueProductNameFromId(id)).isValid();
+    QString product = buildTarget.left(buildTarget.indexOf(rcNameSeparator()));
+    return findProduct(project->qbsProjectData(), product).isValid();
 }
 
-bool QbsRunConfigurationFactory::canRestore(Target *parent, const QVariantMap &map) const
-{
-    if (!canHandle(parent))
-        return false;
-    return idFromMap(map).toString().startsWith(QLatin1String(QBS_RC_PREFIX));
-}
-
-bool QbsRunConfigurationFactory::canClone(Target *parent, RunConfiguration *source) const
-{
-    return canCreate(parent, source->id());
-}
-
-QList<Core::Id> QbsRunConfigurationFactory::availableCreationIds(Target *parent, CreationMode mode) const
+QList<QString> QbsRunConfigurationFactory::availableBuildTargets(Target *parent, CreationMode mode) const
 {
     QList<qbs::ProductData> products;
 
-    if (!canHandle(parent))
-        return QList<Core::Id>();
-
     QbsProject *project = static_cast<QbsProject *>(parent->project());
     if (!project || !project->qbsProject().isValid())
-        return QList<Core::Id>();
+        return {};
 
     foreach (const qbs::ProductData &product, project->qbsProjectData().allProducts()) {
         if (product.isRunnable() && product.isEnabled())
@@ -405,13 +380,17 @@ QList<Core::Id> QbsRunConfigurationFactory::availableCreationIds(Target *parent,
     }
 
     return Utils::transform(products, [project](const qbs::ProductData &product) {
-        return idFromProduct(project, product);
+        return QString(QbsProject::uniqueProductName(product) + rcNameSeparator()
+                       + QbsProject::productDisplayName(project->qbsProject(), product));
     });
 }
 
-QString QbsRunConfigurationFactory::displayNameForId(Core::Id id) const
+QString QbsRunConfigurationFactory::displayNameForBuildTarget(const QString &buildTarget) const
 {
-    return productDisplayNameFromId(id);
+    const int sepPos = buildTarget.indexOf(rcNameSeparator());
+    if (sepPos == -1)
+        return buildTarget;
+    return buildTarget.mid(sepPos + rcNameSeparator().count());
 }
 
 } // namespace Internal
diff --git a/src/plugins/qbsprojectmanager/qbsrunconfiguration.h b/src/plugins/qbsprojectmanager/qbsrunconfiguration.h
index 6f190fdd182..2d5ac1d2636 100644
--- a/src/plugins/qbsprojectmanager/qbsrunconfiguration.h
+++ b/src/plugins/qbsprojectmanager/qbsrunconfiguration.h
@@ -108,12 +108,10 @@ class QbsRunConfigurationFactory : public ProjectExplorer::IRunConfigurationFact
 public:
     explicit QbsRunConfigurationFactory(QObject *parent = 0);
 
-    bool canCreate(ProjectExplorer::Target *parent, Core::Id id) const override;
-    bool canRestore(ProjectExplorer::Target *parent, const QVariantMap &map) const override;
-    bool canClone(ProjectExplorer::Target *parent, ProjectExplorer::RunConfiguration *source) const override;
+    bool canCreateHelper(ProjectExplorer::Target *parent, const QString &suffix) const override;
 
-    QList<Core::Id> availableCreationIds(ProjectExplorer::Target *parent, CreationMode mode) const override;
-    QString displayNameForId(Core::Id id) const override;
+    QList<QString> availableBuildTargets(ProjectExplorer::Target *parent, CreationMode mode) const override;
+    QString displayNameForBuildTarget(const QString &buildTarget) const override;
 };
 
 } // namespace Internal
diff --git a/src/plugins/qmakeandroidsupport/qmakeandroidrunconfiguration.cpp b/src/plugins/qmakeandroidsupport/qmakeandroidrunconfiguration.cpp
index 5d957b85978..aa6deea3851 100644
--- a/src/plugins/qmakeandroidsupport/qmakeandroidrunconfiguration.cpp
+++ b/src/plugins/qmakeandroidsupport/qmakeandroidrunconfiguration.cpp
@@ -97,7 +97,7 @@ QString QmakeAndroidRunConfiguration::defaultDisplayName()
             return node->displayName();
     }
 
-    return displayNameForId(id());
+    return QString();
 }
 
 QString QmakeAndroidRunConfiguration::disabledReason() const
@@ -116,11 +116,6 @@ QString QmakeAndroidRunConfiguration::buildSystemTarget() const
     return qmakeProject()->mapProFilePathToTarget(m_proFilePath);
 }
 
-QString QmakeAndroidRunConfiguration::displayNameForId(Core::Id id)
-{
-    return pathFromId(id).toFileInfo().completeBaseName();
-}
-
 QmakeProject *QmakeAndroidRunConfiguration::qmakeProject() const
 {
     Target *t = target();
diff --git a/src/plugins/qmakeandroidsupport/qmakeandroidrunconfiguration.h b/src/plugins/qmakeandroidsupport/qmakeandroidrunconfiguration.h
index 1c367287fef..7a85d5bbb4b 100644
--- a/src/plugins/qmakeandroidsupport/qmakeandroidrunconfiguration.h
+++ b/src/plugins/qmakeandroidsupport/qmakeandroidrunconfiguration.h
@@ -50,8 +50,6 @@ public:
 
     QString buildSystemTarget() const final;
 
-    static QString displayNameForId(Core::Id id);
-
 private:
     friend class ProjectExplorer::IRunConfigurationFactory;
     void initialize(Core::Id id) override;
diff --git a/src/plugins/qmakeandroidsupport/qmakeandroidrunfactories.cpp b/src/plugins/qmakeandroidsupport/qmakeandroidrunfactories.cpp
index 5271d599c81..ee5dff0a149 100644
--- a/src/plugins/qmakeandroidsupport/qmakeandroidrunfactories.cpp
+++ b/src/plugins/qmakeandroidsupport/qmakeandroidrunfactories.cpp
@@ -49,42 +49,24 @@ static const char ANDROID_RC_ID_PREFIX[] = "Qt4ProjectManager.AndroidRunConfigur
 QmakeAndroidRunConfigurationFactory::QmakeAndroidRunConfigurationFactory(QObject *parent)
     : IRunConfigurationFactory(parent)
 {
-    registerRunConfiguration<QmakeAndroidRunConfiguration>();
+    registerRunConfiguration<QmakeAndroidRunConfiguration>(ANDROID_RC_ID_PREFIX);
     setSupportedProjectType<QmakeProject>();
 }
 
-QString QmakeAndroidRunConfigurationFactory::displayNameForId(Core::Id id) const
+QString QmakeAndroidRunConfigurationFactory::displayNameForBuildTarget(const QString &buildTarget) const
 {
-    return QmakeAndroidRunConfiguration::displayNameForId(id);
+    return QFileInfo(buildTarget).completeBaseName();
 }
 
-bool QmakeAndroidRunConfigurationFactory::canCreate(Target *parent, Core::Id id) const
+bool QmakeAndroidRunConfigurationFactory::canCreateHelper(Target *parent, const QString &buildTarget) const
 {
-    if (!canHandle(parent))
-        return false;
-    return availableCreationIds(parent).contains(id);
+    return availableBuildTargets(parent, UserCreate).contains(buildTarget);
 }
 
-bool QmakeAndroidRunConfigurationFactory::canRestore(Target *parent, const QVariantMap &map) const
+QList<QString> QmakeAndroidRunConfigurationFactory::availableBuildTargets(Target *parent, CreationMode mode) const
 {
-    if (!canHandle(parent))
-        return false;
-    return ProjectExplorer::idFromMap(map).name().startsWith(ANDROID_RC_ID_PREFIX);
-}
-
-bool QmakeAndroidRunConfigurationFactory::canClone(Target *parent, RunConfiguration *source) const
-{
-    return canCreate(parent, source->id());
-}
-
-QList<Core::Id> QmakeAndroidRunConfigurationFactory::availableCreationIds(Target *parent, CreationMode mode) const
-{
-    if (!canHandle(parent))
-        return QList<Core::Id>();
-
     auto project = static_cast<QmakeProject *>(parent->project());
-    return project->creationIds(ANDROID_RC_ID_PREFIX, mode,
-                                {ProjectType::ApplicationTemplate, ProjectType::SharedLibraryTemplate});
+    return project->buildTargets(mode, {ProjectType::ApplicationTemplate, ProjectType::SharedLibraryTemplate});
 }
 
 bool QmakeAndroidRunConfigurationFactory::canHandle(Target *t) const
diff --git a/src/plugins/qmakeandroidsupport/qmakeandroidrunfactories.h b/src/plugins/qmakeandroidsupport/qmakeandroidrunfactories.h
index a84ca16937d..0d9d3202044 100644
--- a/src/plugins/qmakeandroidsupport/qmakeandroidrunfactories.h
+++ b/src/plugins/qmakeandroidsupport/qmakeandroidrunfactories.h
@@ -43,12 +43,10 @@ class QmakeAndroidRunConfigurationFactory : public ProjectExplorer::IRunConfigur
 public:
     explicit QmakeAndroidRunConfigurationFactory(QObject *parent = 0);
 
-    QString displayNameForId(Core::Id id) const override;
-    QList<Core::Id> availableCreationIds(ProjectExplorer::Target *parent, CreationMode mode = UserCreate) const override;
+    QList<QString> availableBuildTargets(ProjectExplorer::Target *parent, CreationMode mode) const override;
+    QString displayNameForBuildTarget(const QString &buildTarget) const override;
 
-    bool canCreate(ProjectExplorer::Target *parent, Core::Id id) const override;
-    bool canRestore(ProjectExplorer::Target *parent, const QVariantMap &map) const override;
-    bool canClone(ProjectExplorer::Target *parent, ProjectExplorer::RunConfiguration *source) const override;
+    bool canCreateHelper(ProjectExplorer::Target *parent, const QString &suffix) const override;
 
     QList<ProjectExplorer::RunConfiguration *> runConfigurationsForNode(ProjectExplorer::Target *t,
                                                                         ProjectExplorer::Node *n);
diff --git a/src/plugins/qmakeprojectmanager/desktopqmakerunconfiguration.cpp b/src/plugins/qmakeprojectmanager/desktopqmakerunconfiguration.cpp
index 0b2c311faa6..0fc94abbeaa 100644
--- a/src/plugins/qmakeprojectmanager/desktopqmakerunconfiguration.cpp
+++ b/src/plugins/qmakeprojectmanager/desktopqmakerunconfiguration.cpp
@@ -67,11 +67,6 @@ const char PRO_FILE_KEY[] = "Qt4ProjectManager.Qt4RunConfiguration.ProFile";
 const char USE_DYLD_IMAGE_SUFFIX_KEY[] = "Qt4ProjectManager.Qt4RunConfiguration.UseDyldImageSuffix";
 const char USE_LIBRARY_SEARCH_PATH[] = "QmakeProjectManager.QmakeRunConfiguration.UseLibrarySearchPath";
 
-static Utils::FileName pathFromId(Core::Id id)
-{
-    return Utils::FileName::fromString(id.suffixAfter(QMAKE_RC_PREFIX));
-}
-
 //
 // QmakeRunConfiguration
 //
@@ -96,7 +91,7 @@ DesktopQmakeRunConfiguration::DesktopQmakeRunConfiguration(Target *target)
 void DesktopQmakeRunConfiguration::initialize(Core::Id id)
 {
     RunConfiguration::initialize(id);
-    m_proFilePath = pathFromId(id);
+    m_proFilePath = FileName::fromString(id.suffixAfter(QMAKE_RC_PREFIX));
 
     updateTargetInformation();
 }
@@ -440,43 +435,26 @@ DesktopQmakeRunConfigurationFactory::DesktopQmakeRunConfigurationFactory(QObject
     QmakeRunConfigurationFactory(parent)
 {
     setObjectName("DesktopQmakeRunConfigurationFactory");
-    registerRunConfiguration<DesktopQmakeRunConfiguration>();
+    registerRunConfiguration<DesktopQmakeRunConfiguration>(QMAKE_RC_PREFIX);
     setSupportedProjectType<QmakeProject>();
     setSupportedTargetDeviceTypes({Constants::DESKTOP_DEVICE_TYPE});
 }
 
-bool DesktopQmakeRunConfigurationFactory::canCreate(Target *parent, Core::Id id) const
+bool DesktopQmakeRunConfigurationFactory::canCreateHelper(Target *parent, const QString &buildTarget) const
 {
-    if (!canHandle(parent))
-        return false;
     QmakeProject *project = static_cast<QmakeProject *>(parent->project());
-    return project->hasApplicationProFile(pathFromId(id));
+    return project->hasApplicationProFile(Utils::FileName::fromString(buildTarget));
 }
 
-bool DesktopQmakeRunConfigurationFactory::canRestore(Target *parent, const QVariantMap &map) const
+QList<QString> DesktopQmakeRunConfigurationFactory::availableBuildTargets(Target *parent, CreationMode mode) const
 {
-    if (!canHandle(parent))
-        return false;
-    return idFromMap(map).toString().startsWith(QLatin1String(QMAKE_RC_PREFIX));
-}
-
-bool DesktopQmakeRunConfigurationFactory::canClone(Target *parent, RunConfiguration *source) const
-{
-    return canCreate(parent, source->id());
-}
-
-QList<Core::Id> DesktopQmakeRunConfigurationFactory::availableCreationIds(Target *parent, CreationMode mode) const
-{
-    if (!canHandle(parent))
-        return QList<Core::Id>();
-
     QmakeProject *project = static_cast<QmakeProject *>(parent->project());
-    return project->creationIds(QMAKE_RC_PREFIX, mode);
+    return project->buildTargets(mode);
 }
 
-QString DesktopQmakeRunConfigurationFactory::displayNameForId(Core::Id id) const
+QString DesktopQmakeRunConfigurationFactory::displayNameForBuildTarget(const QString &buildTarget) const
 {
-    return pathFromId(id).toFileInfo().completeBaseName();
+    return QFileInfo(buildTarget).completeBaseName();
 }
 
 QList<RunConfiguration *> DesktopQmakeRunConfigurationFactory::runConfigurationsForNode(Target *t, const Node *n)
diff --git a/src/plugins/qmakeprojectmanager/desktopqmakerunconfiguration.h b/src/plugins/qmakeprojectmanager/desktopqmakerunconfiguration.h
index 4eda56fcde0..b59fa370bd5 100644
--- a/src/plugins/qmakeprojectmanager/desktopqmakerunconfiguration.h
+++ b/src/plugins/qmakeprojectmanager/desktopqmakerunconfiguration.h
@@ -140,12 +140,10 @@ class DesktopQmakeRunConfigurationFactory : public QmakeRunConfigurationFactory
 public:
     explicit DesktopQmakeRunConfigurationFactory(QObject *parent = 0);
 
-    bool canCreate(ProjectExplorer::Target *parent, Core::Id id) const override;
-    bool canRestore(ProjectExplorer::Target *parent, const QVariantMap &map) const override;
-    bool canClone(ProjectExplorer::Target *parent, ProjectExplorer::RunConfiguration *source) const override;
+    bool canCreateHelper(ProjectExplorer::Target *parent, const QString &suffix) const override;
 
-    QList<Core::Id> availableCreationIds(ProjectExplorer::Target *parent, CreationMode mode) const override;
-    QString displayNameForId(Core::Id id) const override;
+    QList<QString> availableBuildTargets(ProjectExplorer::Target *parent, CreationMode mode) const override;
+    QString displayNameForBuildTarget(const QString &buildTarget) const override;
 
     QList<ProjectExplorer::RunConfiguration *> runConfigurationsForNode(ProjectExplorer::Target *t,
                                                                         const ProjectExplorer::Node *n) override;
diff --git a/src/plugins/qmakeprojectmanager/qmakeproject.cpp b/src/plugins/qmakeprojectmanager/qmakeproject.cpp
index b8e9ffb77f9..bf0c16cba51 100644
--- a/src/plugins/qmakeprojectmanager/qmakeproject.cpp
+++ b/src/plugins/qmakeprojectmanager/qmakeproject.cpp
@@ -773,9 +773,8 @@ bool QmakeProject::hasApplicationProFile(const FileName &path) const
     return Utils::contains(list, Utils::equal(&QmakeProFile::filePath, path));
 }
 
-QList<Core::Id> QmakeProject::creationIds(Core::Id base,
-                                          IRunConfigurationFactory::CreationMode mode,
-                                          const QList<ProjectType> &projectTypes)
+QList<QString> QmakeProject::buildTargets(IRunConfigurationFactory::CreationMode mode,
+                                              const QList<ProjectType> &projectTypes)
 {
     QList<ProjectType> realTypes = projectTypes;
     if (realTypes.isEmpty())
@@ -790,9 +789,7 @@ QList<Core::Id> QmakeProject::creationIds(Core::Id base,
         temp = filtered.isEmpty() ? files : filtered;
     }
 
-    return Utils::transform(temp, [&base](QmakeProFile *f) {
-        return base.withSuffix(f->filePath().toString());
-    });
+    return Utils::transform(temp, [](QmakeProFile *f) { return f->filePath().toString(); });
 }
 
 void QmakeProject::activeTargetWasChanged()
diff --git a/src/plugins/qmakeprojectmanager/qmakeproject.h b/src/plugins/qmakeprojectmanager/qmakeproject.h
index 717c11951bf..8fa4ab5c97d 100644
--- a/src/plugins/qmakeprojectmanager/qmakeproject.h
+++ b/src/plugins/qmakeprojectmanager/qmakeproject.h
@@ -48,12 +48,8 @@ namespace ProjectExplorer { class DeploymentData; }
 namespace QtSupport { class ProFileReader; }
 
 namespace QmakeProjectManager {
-class QmakeBuildConfiguration;
 
-namespace Internal {
-class CentralizedFolderWatcher;
-class QmakeProjectFiles;
-}
+namespace Internal { class CentralizedFolderWatcher; }
 
 class  QMAKEPROJECTMANAGER_EXPORT QmakeProject : public ProjectExplorer::Project
 {
@@ -77,8 +73,7 @@ public:
     QList<QmakeProFile *> applicationProFiles(Parsing parse = ExactParse) const;
     bool hasApplicationProFile(const Utils::FileName &path) const;
 
-    QList<Core::Id> creationIds(Core::Id base,
-                                ProjectExplorer::IRunConfigurationFactory::CreationMode mode,
+    QList<QString> buildTargets(ProjectExplorer::IRunConfigurationFactory::CreationMode mode,
                                 const QList<ProjectType> &projectTypes = {});
 
     static void notifyChanged(const Utils::FileName &name);
diff --git a/src/plugins/qmlprojectmanager/qmlprojectmanagerconstants.h b/src/plugins/qmlprojectmanager/qmlprojectmanagerconstants.h
index 783a067b741..ff0b39b3b36 100644
--- a/src/plugins/qmlprojectmanager/qmlprojectmanagerconstants.h
+++ b/src/plugins/qmlprojectmanager/qmlprojectmanagerconstants.h
@@ -30,6 +30,8 @@
 namespace QmlProjectManager {
 namespace Constants {
 
+const char QML_RC_ID[] = "QmlProjectManager.QmlRunConfiguration";
+
 const char QML_VIEWER_RC_ID[] = "QmlProjectManager.QmlRunConfiguration";
 const char QML_SCENE_RC_ID[] = "QmlProjectManager.QmlRunConfiguration.QmlScene";
 const char QML_VIEWER_ARGUMENTS_KEY[] = "QmlProjectManager.QmlRunConfiguration.QDeclarativeViewerArguments";
diff --git a/src/plugins/qmlprojectmanager/qmlprojectrunconfigurationfactory.cpp b/src/plugins/qmlprojectmanager/qmlprojectrunconfigurationfactory.cpp
index 053b2fc98df..77bcc466175 100644
--- a/src/plugins/qmlprojectmanager/qmlprojectrunconfigurationfactory.cpp
+++ b/src/plugins/qmlprojectmanager/qmlprojectrunconfigurationfactory.cpp
@@ -36,67 +36,58 @@
 namespace QmlProjectManager {
 namespace Internal {
 
+const char QML_VIEWER_SUFFIX[] = "";
+const char QML_SCENE_SUFFIX[] = ".QmlScene";
+
 QmlProjectRunConfigurationFactory::QmlProjectRunConfigurationFactory(QObject *parent) :
     ProjectExplorer::IRunConfigurationFactory(parent)
 {
     setObjectName("QmlProjectRunConfigurationFactory");
-    registerRunConfiguration<QmlProjectRunConfiguration>();
+    registerRunConfiguration<QmlProjectRunConfiguration>(Constants::QML_RC_ID);
     setSupportedProjectType<QmlProject>();
     setSupportedTargetDeviceTypes({ProjectExplorer::Constants::DESKTOP_DEVICE_TYPE});
 }
 
-QList<Core::Id> QmlProjectRunConfigurationFactory::availableCreationIds(ProjectExplorer::Target *parent, CreationMode mode) const
+QList<QString> QmlProjectRunConfigurationFactory::availableBuildTargets(ProjectExplorer::Target *parent, CreationMode) const
 {
-    Q_UNUSED(mode)
-    if (!canHandle(parent))
-        return QList<Core::Id>();
-
     QtSupport::BaseQtVersion *version
             = QtSupport::QtKitInformation::qtVersion(parent->kit());
 
+    const QString viewer = QML_VIEWER_SUFFIX;
+    const QString scene = QML_SCENE_SUFFIX;
+
     // First id will be the default run configuration
-    QList<Core::Id> list;
     if (version && version->qtVersion() >= QtSupport::QtVersionNumber(5, 0, 0)) {
         QmlProject *project = static_cast<QmlProject*>(parent->project());
         switch (project->defaultImport()) {
         case QmlProject::QtQuick1Import:
-            list << Core::Id(Constants::QML_VIEWER_RC_ID);
-            break;
+            return {viewer};
         case QmlProject::QtQuick2Import:
-            list << Core::Id(Constants::QML_SCENE_RC_ID);
-            break;
+            return {scene};
         case QmlProject::UnknownImport:
         default:
-            list << Core::Id(Constants::QML_SCENE_RC_ID);
-            list << Core::Id(Constants::QML_VIEWER_RC_ID);
-            break;
+            return {scene, viewer};
         }
-    } else {
-        list << Core::Id(Constants::QML_VIEWER_RC_ID);
     }
-
-    return list;
+    return {viewer};
 }
 
-QString QmlProjectRunConfigurationFactory::displayNameForId(Core::Id id) const
+QString QmlProjectRunConfigurationFactory::displayNameForBuildTarget(const QString &buildTarget) const
 {
-    if (id == Constants::QML_VIEWER_RC_ID)
+    if (buildTarget == QML_VIEWER_SUFFIX)
         return tr("QML Viewer");
-    if (id == Constants::QML_SCENE_RC_ID)
+    if (buildTarget == QML_SCENE_SUFFIX)
         return tr("QML Scene");
     return QString();
 }
 
-bool QmlProjectRunConfigurationFactory::canCreate(ProjectExplorer::Target *parent,
-                                                  const Core::Id id) const
+bool QmlProjectRunConfigurationFactory::canCreateHelper(ProjectExplorer::Target *parent,
+                                                        const QString &buildTarget) const
 {
-    if (!canHandle(parent))
-        return false;
-
-    if (id == Constants::QML_VIEWER_RC_ID)
+    if (buildTarget == QML_VIEWER_SUFFIX)
         return true;
 
-    if (id == Constants::QML_SCENE_RC_ID) {
+    if (buildTarget == QML_SCENE_SUFFIX) {
         // only support qmlscene if it's Qt5
         QtSupport::BaseQtVersion *version
                 = QtSupport::QtKitInformation::qtVersion(parent->kit());
@@ -105,16 +96,6 @@ bool QmlProjectRunConfigurationFactory::canCreate(ProjectExplorer::Target *paren
     return false;
 }
 
-bool QmlProjectRunConfigurationFactory::canRestore(ProjectExplorer::Target *parent, const QVariantMap &map) const
-{
-    return parent && canCreate(parent, ProjectExplorer::idFromMap(map));
-}
-
-bool QmlProjectRunConfigurationFactory::canClone(ProjectExplorer::Target *parent, ProjectExplorer::RunConfiguration *source) const
-{
-    return canCreate(parent, source->id());
-}
-
 } // namespace Internal
 } // namespace QmlProjectManager
 
diff --git a/src/plugins/qmlprojectmanager/qmlprojectrunconfigurationfactory.h b/src/plugins/qmlprojectmanager/qmlprojectrunconfigurationfactory.h
index 8988e482e57..3dd422f00ad 100644
--- a/src/plugins/qmlprojectmanager/qmlprojectrunconfigurationfactory.h
+++ b/src/plugins/qmlprojectmanager/qmlprojectrunconfigurationfactory.h
@@ -37,12 +37,10 @@ class QmlProjectRunConfigurationFactory : public ProjectExplorer::IRunConfigurat
 public:
     explicit QmlProjectRunConfigurationFactory(QObject *parent = 0);
 
-    QList<Core::Id> availableCreationIds(ProjectExplorer::Target *parent, CreationMode mode) const override;
-    QString displayNameForId(Core::Id id) const override;
+    QList<QString> availableBuildTargets(ProjectExplorer::Target *parent, CreationMode mode) const override;
+    QString displayNameForBuildTarget(const QString &buildTarget) const override;
 
-    bool canCreate(ProjectExplorer::Target *parent, Core::Id id) const override;
-    bool canRestore(ProjectExplorer::Target *parent, const QVariantMap &map) const override;
-    bool canClone(ProjectExplorer::Target *parent, ProjectExplorer::RunConfiguration *source) const override;
+    bool canCreateHelper(ProjectExplorer::Target *parent, const QString &suffix) const override;
 };
 
 } // namespace Internal
diff --git a/src/plugins/qnx/qnxrunconfigurationfactory.cpp b/src/plugins/qnx/qnxrunconfigurationfactory.cpp
index 4ff952f79cb..e607615804a 100644
--- a/src/plugins/qnx/qnxrunconfigurationfactory.cpp
+++ b/src/plugins/qnx/qnxrunconfigurationfactory.cpp
@@ -36,64 +36,33 @@
 namespace Qnx {
 namespace Internal {
 
-static Utils::FileName pathFromId(Core::Id id)
-{
-    return Utils::FileName::fromString(id.suffixAfter(Constants::QNX_QNX_RUNCONFIGURATION_PREFIX));
-}
-
 QnxRunConfigurationFactory::QnxRunConfigurationFactory(QObject *parent) :
     ProjectExplorer::IRunConfigurationFactory(parent)
 {
-    registerRunConfiguration<QnxRunConfiguration>();
+    registerRunConfiguration<QnxRunConfiguration>(Constants::QNX_QNX_RUNCONFIGURATION_PREFIX);
     setSupportedTargetDeviceTypes({Constants::QNX_QNX_OS_TYPE});
 }
 
-QList<Core::Id> QnxRunConfigurationFactory::availableCreationIds(ProjectExplorer::Target *parent, CreationMode mode) const
+QList<QString> QnxRunConfigurationFactory::availableBuildTargets(ProjectExplorer::Target *parent, CreationMode mode) const
 {
-    using QmakeProjectManager::QmakeProject;
-    if (!canHandle(parent))
-        return QList<Core::Id>();
-
-    auto project = qobject_cast<QmakeProject *>(parent->project());
+    auto project = qobject_cast<QmakeProjectManager::QmakeProject *>(parent->project());
     if (!project)
-        return QList<Core::Id>();
-
-    return project->creationIds(Constants::QNX_QNX_RUNCONFIGURATION_PREFIX, mode);
+        return {};
+    return project->buildTargets(mode);
 }
 
-QString QnxRunConfigurationFactory::displayNameForId(Core::Id id) const
+QString QnxRunConfigurationFactory::displayNameForBuildTarget(const QString &buildTarget) const
 {
-    const Utils::FileName path = pathFromId(id);
-    if (path.isEmpty())
+    if (buildTarget.isEmpty())
         return QString();
-
-    if (id.name().startsWith(Constants::QNX_QNX_RUNCONFIGURATION_PREFIX))
-        return tr("%1 on QNX Device").arg(path.toFileInfo().completeBaseName());
-
-    return QString();
+    return tr("%1 on QNX Device").arg(QFileInfo(buildTarget).completeBaseName());
 }
 
-bool QnxRunConfigurationFactory::canCreate(ProjectExplorer::Target *parent, Core::Id id) const
+bool QnxRunConfigurationFactory::canCreateHelper(ProjectExplorer::Target *parent,
+                                                 const QString &buildTarget) const
 {
-    if (!canHandle(parent) || !id.name().startsWith(Constants::QNX_QNX_RUNCONFIGURATION_PREFIX))
-        return false;
-
-    QmakeProjectManager::QmakeProject *qt4Project = qobject_cast<QmakeProjectManager::QmakeProject *>(parent->project());
-    if (!qt4Project)
-        return false;
-
-    return qt4Project->hasApplicationProFile(pathFromId(id));
-}
-
-bool QnxRunConfigurationFactory::canRestore(ProjectExplorer::Target *parent, const QVariantMap &map) const
-{
-    return canHandle(parent)
-            && ProjectExplorer::idFromMap(map).name().startsWith(Constants::QNX_QNX_RUNCONFIGURATION_PREFIX);
-}
-
-bool QnxRunConfigurationFactory::canClone(ProjectExplorer::Target *parent, ProjectExplorer::RunConfiguration *source) const
-{
-    return canCreate(parent, source->id());
+    auto project = qobject_cast<QmakeProjectManager::QmakeProject *>(parent->project());
+    return project->hasApplicationProFile(Utils::FileName::fromString(buildTarget));
 }
 
 } // namespace Internal
diff --git a/src/plugins/qnx/qnxrunconfigurationfactory.h b/src/plugins/qnx/qnxrunconfigurationfactory.h
index 3076e793f7a..896c13a44b3 100644
--- a/src/plugins/qnx/qnxrunconfigurationfactory.h
+++ b/src/plugins/qnx/qnxrunconfigurationfactory.h
@@ -38,12 +38,10 @@ class QnxRunConfigurationFactory : public ProjectExplorer::IRunConfigurationFact
 public:
     explicit QnxRunConfigurationFactory(QObject *parent = 0);
 
-    QList<Core::Id> availableCreationIds(ProjectExplorer::Target *parent, CreationMode mode) const override;
-    QString displayNameForId(Core::Id id) const override;
+    QList<QString> availableBuildTargets(ProjectExplorer::Target *parent, CreationMode mode) const override;
+    QString displayNameForBuildTarget(const QString &buildTarget) const override;
 
-    bool canCreate(ProjectExplorer::Target *parent, Core::Id id) const override;
-    bool canRestore(ProjectExplorer::Target *parent, const QVariantMap &map) const override;
-    bool canClone(ProjectExplorer::Target *parent, ProjectExplorer::RunConfiguration *source) const override;
+    bool canCreateHelper(ProjectExplorer::Target *parent, const QString &suffix) const override;
 };
 
 } // namespace Internal
diff --git a/src/plugins/remotelinux/remotelinuxrunconfigurationfactory.cpp b/src/plugins/remotelinux/remotelinuxrunconfigurationfactory.cpp
index f6fcd0ed34f..b59ab965930 100644
--- a/src/plugins/remotelinux/remotelinuxrunconfigurationfactory.cpp
+++ b/src/plugins/remotelinux/remotelinuxrunconfigurationfactory.cpp
@@ -30,73 +30,40 @@
 #include "remotelinuxrunconfiguration.h"
 
 #include <projectexplorer/buildtargetinfo.h>
-#include <projectexplorer/kitinformation.h>
-#include <projectexplorer/project.h>
 #include <projectexplorer/target.h>
 #include <utils/qtcassert.h>
 
-#include <QString>
-
 using namespace ProjectExplorer;
 
 namespace RemoteLinux {
 namespace Internal {
 
-static QString stringFromId(Core::Id id)
-{
-    QByteArray idStr = id.name();
-    if (!idStr.startsWith(RemoteLinuxRunConfiguration::IdPrefix))
-        return QString();
-    return QString::fromUtf8(idStr.mid(int(strlen(RemoteLinuxRunConfiguration::IdPrefix))));
-}
-
 // RemoteLinuxRunConfigurationFactory
 
 RemoteLinuxRunConfigurationFactory::RemoteLinuxRunConfigurationFactory(QObject *parent)
     : IRunConfigurationFactory(parent)
 {
     setObjectName("RemoteLinuxRunConfigurationFactory");
-    registerRunConfiguration<RemoteLinuxRunConfiguration>();
+    registerRunConfiguration<RemoteLinuxRunConfiguration>(RemoteLinuxRunConfiguration::IdPrefix);
     setSupportedTargetDeviceTypes({RemoteLinux::Constants::GenericLinuxOsType});
 }
 
-bool RemoteLinuxRunConfigurationFactory::canCreate(Target *parent, Core::Id id) const
+bool RemoteLinuxRunConfigurationFactory::canCreateHelper(Target *parent, const QString &buildTarget) const
 {
-    if (!canHandle(parent))
-        return false;
-    return parent->applicationTargets().hasTarget(stringFromId(id));
+    return parent->applicationTargets().hasTarget(buildTarget);
 }
 
-bool RemoteLinuxRunConfigurationFactory::canRestore(Target *parent, const QVariantMap &map) const
+QList<QString>
+  RemoteLinuxRunConfigurationFactory::availableBuildTargets(Target *parent, CreationMode) const
 {
-    if (!canHandle(parent))
-        return false;
-    const Core::Id id = idFromMap(map);
-    return id.name().startsWith(RemoteLinuxRunConfiguration::IdPrefix);
+    return Utils::transform(parent->applicationTargets().list, [](const BuildTargetInfo &bti) {
+        return bti.targetName;
+    });
 }
 
-bool RemoteLinuxRunConfigurationFactory::canClone(Target *parent, RunConfiguration *source) const
+QString RemoteLinuxRunConfigurationFactory::displayNameForBuildTarget(const QString &buildTarget) const
 {
-    auto rlrc = qobject_cast<RemoteLinuxRunConfiguration *>(source);
-    return rlrc && canCreate(parent, source->id());
-}
-
-QList<Core::Id> RemoteLinuxRunConfigurationFactory::availableCreationIds(Target *parent, CreationMode mode) const
-{
-    Q_UNUSED(mode)
-    QList<Core::Id> result;
-    if (!canHandle(parent))
-        return result;
-
-    const Core::Id base = Core::Id(RemoteLinuxRunConfiguration::IdPrefix);
-    foreach (const BuildTargetInfo &bti, parent->applicationTargets().list)
-        result << base.withSuffix(bti.targetName);
-    return result;
-}
-
-QString RemoteLinuxRunConfigurationFactory::displayNameForId(Core::Id id) const
-{
-    return stringFromId(id) + QLatin1Char(' ') + tr("(on Remote Generic Linux Host)");
+    return buildTarget + ' ' + tr("(on Remote Generic Linux Host)");
 }
 
 // RemoteLinuxCustomRunConfigurationFactory
@@ -105,42 +72,17 @@ RemoteLinuxCustomRunConfigurationFactory::RemoteLinuxCustomRunConfigurationFacto
     : IRunConfigurationFactory(parent)
 {
     setObjectName("RemoteLinuxCustomRunConfiguration");
-    registerRunConfiguration<RemoteLinuxCustomRunConfiguration>();
+    registerRunConfiguration<RemoteLinuxCustomRunConfiguration>
+            (RemoteLinuxCustomRunConfiguration::runConfigId());
 }
 
-bool RemoteLinuxCustomRunConfigurationFactory::canCreate(Target *parent, Core::Id id) const
+QList<QString>
+  RemoteLinuxCustomRunConfigurationFactory::availableBuildTargets(Target *, CreationMode) const
 {
-    if (!canHandle(parent))
-        return false;
-    return id == RemoteLinuxCustomRunConfiguration::runConfigId();
+    return {QString()};
 }
 
-bool RemoteLinuxCustomRunConfigurationFactory::canRestore(Target *parent, const QVariantMap &map) const
-{
-    if (!canHandle(parent))
-        return false;
-    const Core::Id id = idFromMap(map);
-    return id == RemoteLinuxCustomRunConfiguration::runConfigId();
-}
-
-bool RemoteLinuxCustomRunConfigurationFactory::canClone(Target *parent, RunConfiguration *source) const
-{
-    auto rlrc = qobject_cast<RemoteLinuxCustomRunConfiguration *>(source);
-    return rlrc && canCreate(parent, source->id());
-}
-
-QList<Core::Id> RemoteLinuxCustomRunConfigurationFactory::availableCreationIds(Target *parent, CreationMode mode) const
-{
-    Q_UNUSED(mode)
-    QList<Core::Id> result;
-    if (!canHandle(parent))
-        return result;
-
-    result << RemoteLinuxCustomRunConfiguration::runConfigId();
-    return result;
-}
-
-QString RemoteLinuxCustomRunConfigurationFactory::displayNameForId(Core::Id) const
+QString RemoteLinuxCustomRunConfigurationFactory::displayNameForBuildTarget(const QString &) const
 {
     return RemoteLinuxCustomRunConfiguration::runConfigDefaultDisplayName();
 }
diff --git a/src/plugins/remotelinux/remotelinuxrunconfigurationfactory.h b/src/plugins/remotelinux/remotelinuxrunconfigurationfactory.h
index 9011f9c8b7a..d09497cf7c5 100644
--- a/src/plugins/remotelinux/remotelinuxrunconfigurationfactory.h
+++ b/src/plugins/remotelinux/remotelinuxrunconfigurationfactory.h
@@ -37,12 +37,10 @@ class RemoteLinuxRunConfigurationFactory : public ProjectExplorer::IRunConfigura
 public:
     explicit RemoteLinuxRunConfigurationFactory(QObject *parent = 0);
 
-    QString displayNameForId(Core::Id id) const override;
-    QList<Core::Id> availableCreationIds(ProjectExplorer::Target *parent, CreationMode mode) const override;
+    QList<QString> availableBuildTargets(ProjectExplorer::Target *parent, CreationMode mode) const override;
+    QString displayNameForBuildTarget(const QString &buildTarget) const override;
 
-    bool canCreate(ProjectExplorer::Target *parent, Core::Id id) const override;
-    bool canRestore(ProjectExplorer::Target *parent, const QVariantMap &map) const override;
-    bool canClone(ProjectExplorer::Target *parent, ProjectExplorer::RunConfiguration *source) const override;
+    bool canCreateHelper(ProjectExplorer::Target *parent, const QString &suffix) const override;
 };
 
 class RemoteLinuxCustomRunConfigurationFactory : public ProjectExplorer::IRunConfigurationFactory
@@ -52,12 +50,8 @@ class RemoteLinuxCustomRunConfigurationFactory : public ProjectExplorer::IRunCon
 public:
     explicit RemoteLinuxCustomRunConfigurationFactory(QObject *parent = 0);
 
-    QString displayNameForId(Core::Id id) const override;
-    QList<Core::Id> availableCreationIds(ProjectExplorer::Target *parent, CreationMode mode) const override;
-
-    bool canCreate(ProjectExplorer::Target *parent, Core::Id id) const override;
-    bool canRestore(ProjectExplorer::Target *parent, const QVariantMap &map) const override;
-    bool canClone(ProjectExplorer::Target *parent, ProjectExplorer::RunConfiguration *source) const override;
+    QList<QString> availableBuildTargets(ProjectExplorer::Target *parent, CreationMode mode) const override;
+    QString displayNameForBuildTarget(const QString &buildTarget) const override;
 };
 
 } // namespace Internal
diff --git a/src/plugins/winrt/winrtrunfactories.cpp b/src/plugins/winrt/winrtrunfactories.cpp
index f1601360368..0cf68b7df9c 100644
--- a/src/plugins/winrt/winrtrunfactories.cpp
+++ b/src/plugins/winrt/winrtrunfactories.cpp
@@ -43,48 +43,28 @@ namespace Internal {
 
 WinRtRunConfigurationFactory::WinRtRunConfigurationFactory()
 {
-    registerRunConfiguration<WinRtRunConfiguration>();
+    registerRunConfiguration<WinRtRunConfiguration>(Constants::WINRT_RC_PREFIX);
     setSupportedProjectType<QmakeProject>();
     setSupportedTargetDeviceTypes({Constants::WINRT_DEVICE_TYPE_LOCAL,
                                    Constants::WINRT_DEVICE_TYPE_PHONE,
                                    Constants::WINRT_DEVICE_TYPE_EMULATOR});
 }
 
-QList<Core::Id> WinRtRunConfigurationFactory::availableCreationIds(Target *parent,
+QList<QString> WinRtRunConfigurationFactory::availableBuildTargets(Target *parent,
                                                                    CreationMode mode) const
 {
-    if (!canHandle(parent))
-        return QList<Core::Id>();
-
     QmakeProject *project = static_cast<QmakeProject *>(parent->project());
-    return project->creationIds(Constants::WINRT_RC_PREFIX, mode);
+    return project->buildTargets(mode);
 }
 
-QString WinRtRunConfigurationFactory::displayNameForId(Core::Id id) const
+QString WinRtRunConfigurationFactory::displayNameForBuildTarget(const QString &) const
 {
-    Q_UNUSED(id);
     return tr("Run App Package");
 }
 
-bool WinRtRunConfigurationFactory::canCreate(Target *parent, Core::Id id) const
+bool WinRtRunConfigurationFactory::canCloneHelper(Target *, RunConfiguration *) const
 {
-    Q_UNUSED(id);
-    return canHandle(parent);
-}
-
-bool WinRtRunConfigurationFactory::canRestore(Target *parent, const QVariantMap &map) const
-{
-    if (!canHandle(parent))
-        return false;
-
-    return idFromMap(map).toString().startsWith(QLatin1String(Constants::WINRT_RC_PREFIX));
-}
-
-bool WinRtRunConfigurationFactory::canClone(Target *parent, RunConfiguration *product) const
-{
-    Q_UNUSED(parent);
-    Q_UNUSED(product);
-    return false;
+    return false; // FIXME: Are they really unclonable?
 }
 
 } // namespace Internal
diff --git a/src/plugins/winrt/winrtrunfactories.h b/src/plugins/winrt/winrtrunfactories.h
index 176f97fe605..999acba901c 100644
--- a/src/plugins/winrt/winrtrunfactories.h
+++ b/src/plugins/winrt/winrtrunfactories.h
@@ -38,11 +38,10 @@ class WinRtRunConfigurationFactory  : public ProjectExplorer::IRunConfigurationF
 public:
     WinRtRunConfigurationFactory();
 
-    QList<Core::Id> availableCreationIds(ProjectExplorer::Target *parent, CreationMode mode) const override;
-    QString displayNameForId(Core::Id id) const override;
-    bool canCreate(ProjectExplorer::Target *parent, Core::Id id) const override;
-    bool canRestore(ProjectExplorer::Target *parent, const QVariantMap &map) const override;
-    bool canClone(ProjectExplorer::Target *parent, ProjectExplorer::RunConfiguration *product) const override;
+    QList<QString> availableBuildTargets(ProjectExplorer::Target *parent, CreationMode mode) const override;
+    QString displayNameForBuildTarget(const QString &buildTarget) const override;
+
+    bool canCloneHelper(ProjectExplorer::Target *, ProjectExplorer::RunConfiguration *) const override;
 };
 
 } // namespace Internal