diff --git a/src/runner/CMakeLists.txt b/src/runner/CMakeLists.txt
index 060055b..8750dd7 100644
--- a/src/runner/CMakeLists.txt
+++ b/src/runner/CMakeLists.txt
@@ -34,6 +34,7 @@ SET(project_path "${default_project_path}" CACHE PATH "path to the other mo proj
 SET(lib_path "${project_path}/../../install/libs")
 
 INCLUDE_DIRECTORIES(${project_path}/uibase/src
+					${project_path}/game_features/src
 					${PYTHON_ROOT}/Include
 					${SIP_ROOT}
 					${PYTHON_ROOT}/PC)
diff --git a/src/runner/gamefeatureswrappers.cpp b/src/runner/gamefeatureswrappers.cpp
new file mode 100644
index 0000000..b887e02
--- /dev/null
+++ b/src/runner/gamefeatureswrappers.cpp
@@ -0,0 +1,391 @@
+#include "gamefeatureswrappers.h"
+
+#include <boost/any.hpp>
+
+#include <typeindex>
+
+#include <ipluginlist.h>
+#include <iprofile.h>
+#include <isavegame.h>
+#include <isavegameinfowidget.h>
+
+#include "gilock.h"
+#include "pycatch.h"
+
+/////////////////////////////
+/// BSAInvalidation Wrapper
+
+
+bool BSAInvalidationWrapper::isInvalidationBSA(const QString &bsaName)
+{
+  GILock lock;
+
+  try {
+    return this->get_override("isInvalidationBSA")(bsaName);
+  } PYCATCH;
+}
+
+void BSAInvalidationWrapper::deactivate(MOBase::IProfile *profile)
+{
+  GILock lock;
+
+  try {
+    this->get_override("deactivate")(boost::python::ptr(profile));
+  } PYCATCH;
+}
+
+void BSAInvalidationWrapper::activate(MOBase::IProfile *profile)
+{
+  GILock lock;
+
+  try {
+    this->get_override("activate")(boost::python::ptr(profile));
+  } PYCATCH;
+}
+/// end BSAInvalidation Wrapper
+/////////////////////////////
+/// DataArchives Wrapper
+
+
+QStringList DataArchivesWrapper::vanillaArchives() const
+{
+  GILock lock;
+
+  try {
+    return this->get_override("vanillaArchives")();
+  } PYCATCH;
+}
+
+QStringList DataArchivesWrapper::archives(const MOBase::IProfile *profile) const
+{
+  GILock lock;
+
+  try {
+    return this->get_override("archives")(boost::python::ptr(profile));
+  } PYCATCH;
+}
+
+void DataArchivesWrapper::addArchive(MOBase::IProfile *profile, int index, const QString &archiveName)
+{
+  GILock lock;
+
+  try {
+    this->get_override("addArchive")(boost::python::ptr(profile), index, archiveName);
+  } PYCATCH;
+}
+
+void DataArchivesWrapper::removeArchive(MOBase::IProfile * profile, const QString & archiveName)
+{
+  GILock lock;
+
+  try {
+    this->get_override("removeArchive")(boost::python::ptr(profile), archiveName);
+  } PYCATCH;
+}
+/// end DataArchives Wrapper
+/////////////////////////////
+/// GamePlugins Wrapper
+
+
+void GamePluginsWrapper::writePluginLists(const MOBase::IPluginList * pluginList)
+{
+  GILock lock;
+  
+  try {
+    this->get_override("writePluginLists")(boost::python::ptr(pluginList));
+  } PYCATCH;
+}
+
+void GamePluginsWrapper::readPluginLists(MOBase::IPluginList * pluginList)
+{
+  GILock lock;
+  
+  try {
+    this->get_override("readPluginLists")(boost::python::ptr(pluginList));
+  } PYCATCH;
+}
+/// end GamePlugins Wrapper
+/////////////////////////////
+/// LocalSavegames Wrapper
+
+
+MappingType LocalSavegamesWrapper::mappings(const QDir & profileSaveDir) const
+{
+  GILock lock;
+
+  try {
+    return this->get_override("mappings")(profileSaveDir);
+  } PYCATCH;
+}
+
+void LocalSavegamesWrapper::prepareProfile(MOBase::IProfile * profile)
+{
+  GILock lock;
+
+  try {
+    this->get_override("prepareProfile")(boost::python::ptr(profile));
+  } PYCATCH;
+}
+/// end LocalSavegames Wrapper
+/////////////////////////////
+/// SaveGameInfo Wrapper
+
+
+MOBase::ISaveGame const * SaveGameInfoWrapper::getSaveGameInfo(QString const & file) const
+{
+  GILock lock;
+
+  try {
+    return this->get_override("getSaveGameInfo")(file);
+  } PYCATCH;
+}
+
+SaveGameInfoWrapper::MissingAssets SaveGameInfoWrapper::getMissingAssets(QString const & file) const
+{
+  GILock lock;
+
+  try {
+    return this->get_override("getMissingAssets")(file);
+  } PYCATCH;
+}
+
+MOBase::ISaveGameInfoWidget * SaveGameInfoWrapper::getSaveGameWidget(QWidget * parent) const
+{
+  qCritical("Calling method with unimplemented from_python converter.");
+
+  GILock lock;
+
+  try {
+    return this->get_override("getSaveGameWidget")(boost::python::ptr(parent));
+  } PYCATCH;
+}
+
+bool SaveGameInfoWrapper::hasScriptExtenderSave(QString const & file) const
+{
+  GILock lock;
+
+  try {
+    return this->get_override("hasScriptExtenderSave")(file);
+  } PYCATCH;
+}
+/// end SaveGameInfo Wrapper
+/////////////////////////////
+/// ScriptExtender Wrapper
+
+QString ScriptExtenderWrapper::BinaryName() const
+{
+  GILock lock;
+
+  try {
+    return this->get_override("BinaryName")();
+  } PYCATCH;
+}
+
+QString ScriptExtenderWrapper::PluginPath() const
+{
+  GILock lock;
+
+  try {
+    return this->get_override("PluginPath")();
+  } PYCATCH;
+}
+
+QString ScriptExtenderWrapper::loaderName() const
+{
+  GILock lock;
+
+  try {
+    return this->get_override("loaderName")();
+  } PYCATCH;
+}
+
+QString ScriptExtenderWrapper::loaderPath() const
+{
+  GILock lock;
+
+  try {
+    return this->get_override("loaderPath")();
+  } PYCATCH;
+}
+
+QStringList ScriptExtenderWrapper::saveGameAttachmentExtensions() const
+{
+  GILock lock;
+
+  try {
+    return this->get_override("saveGameAttachmentExtensions")();
+  } PYCATCH;
+}
+
+bool ScriptExtenderWrapper::isInstalled() const
+{
+  GILock lock;
+
+  try {
+    return this->get_override("isInstalled")();
+  } PYCATCH;
+}
+
+QString ScriptExtenderWrapper::getExtenderVersion() const
+{
+  GILock lock;
+
+  try {
+    return this->get_override("getExtenderVersion")();
+  } PYCATCH;
+}
+
+WORD ScriptExtenderWrapper::getArch() const
+{
+  GILock lock;
+
+  try {
+    return this->get_override("getArch")();
+  } PYCATCH;
+}
+
+/// end ScriptExtender Wrapper
+/////////////////////////////
+/// UnmanagedMods Wrapper
+
+
+QStringList UnmanagedModsWrapper::mods(bool onlyOfficial) const
+{
+  GILock lock;
+
+  try {
+    return this->get_override("mods")(onlyOfficial);
+  } PYCATCH;
+}
+
+QString UnmanagedModsWrapper::displayName(const QString & modName) const
+{
+  GILock lock;
+
+  try {
+    return this->get_override("displayName")(modName);
+  } PYCATCH;
+}
+
+QFileInfo UnmanagedModsWrapper::referenceFile(const QString & modName) const
+{
+  GILock lock;
+
+  try {
+    return this->get_override("referenceFile")(modName);
+  } PYCATCH;
+}
+
+QStringList UnmanagedModsWrapper::secondaryFiles(const QString & modName) const
+{
+  GILock lock;
+
+  try {
+    return this->get_override("secondaryFiles")(modName);
+  } PYCATCH;
+}
+/// end UnmanagedMods Wrapper
+/////////////////////////////
+
+template<typename T>
+void insertGameFeature(std::map<std::type_index, boost::any> &map, const boost::python::object &pyObject)
+{
+  map[std::type_index(typeid(T))] = boost::python::extract<T*>(pyObject)();
+}
+
+game_features_map_from_python::game_features_map_from_python()
+{
+  boost::python::converter::registry::push_back(&convertible, &construct, boost::python::type_id<std::map<std::type_index, boost::any>>());
+}
+
+void * game_features_map_from_python::convertible(PyObject * objPtr)
+{
+  return PyDict_Check(objPtr) ? objPtr : nullptr;
+}
+
+void game_features_map_from_python::construct(PyObject * objPtr, boost::python::converter::rvalue_from_python_stage1_data * data)
+{
+  void *storage = ((boost::python::converter::rvalue_from_python_storage<std::map<std::type_index, boost::any>>*)data)->storage.bytes;
+  std::map<std::type_index, boost::any> *result = new (storage) std::map<std::type_index, boost::any>();
+  boost::python::dict source(boost::python::handle<>(boost::python::borrowed(objPtr)));
+  boost::python::list keys = source.keys();
+  int len = boost::python::len(keys);
+  for (int i = 0; i < len; ++i)
+  {
+    boost::python::object pyKey = keys[i];
+    // pyKey should be a Boost.Python.class corresponding to a game feature.
+    std::string className = boost::python::extract<std::string>(pyKey.attr("__name__"))();
+    if (className == "BSAInvalidation")
+      insertGameFeature<BSAInvalidation>(*result, source[pyKey]);
+    else if (className == "DataArchives")
+      insertGameFeature<DataArchives>(*result, source[pyKey]);
+    else if (className == "GamePlugins")
+      insertGameFeature<GamePlugins>(*result, source[pyKey]);
+    else if (className == "LocalSavegames")
+      insertGameFeature<LocalSavegames>(*result, source[pyKey]);
+    else if (className == "SaveGameInfo")
+      insertGameFeature<SaveGameInfo>(*result, source[pyKey]);
+    else if (className == "ScriptExtender")
+      insertGameFeature<ScriptExtender>(*result, source[pyKey]);
+    else if (className == "UnmanagedMods")
+      insertGameFeature<UnmanagedMods>(*result, source[pyKey]);
+  }
+
+  data->convertible = storage;
+}
+
+void registerGameFeaturesPythonConverters()
+{
+  namespace bpy = boost::python;
+
+  game_features_map_from_python();
+
+  // Features require defs for all methods as Python can access C++ features
+  bpy::class_<BSAInvalidationWrapper, boost::noncopyable>("BSAInvalidation")
+      .def("isInvalidationBSA", bpy::pure_virtual(&BSAInvalidation::isInvalidationBSA))
+      .def("deactivate", bpy::pure_virtual(&BSAInvalidation::deactivate))
+      .def("activate", bpy::pure_virtual(&BSAInvalidation::activate))
+      ;
+
+  bpy::class_<DataArchivesWrapper, boost::noncopyable>("DataArchives")
+      .def("vanillaArchives", bpy::pure_virtual(&DataArchives::vanillaArchives))
+      .def("archives", bpy::pure_virtual(&DataArchives::archives))
+      .def("addArchive", bpy::pure_virtual(&DataArchives::addArchive))
+      .def("removeArchive", bpy::pure_virtual(&DataArchives::removeArchive))
+      ;
+
+  bpy::class_<GamePluginsWrapper, boost::noncopyable>("GamePlugins")
+      .def("writePluginLists", bpy::pure_virtual(&GamePlugins::writePluginLists))
+      .def("readPluginLists", bpy::pure_virtual(&GamePlugins::readPluginLists))
+      ;
+
+  bpy::class_<LocalSavegamesWrapper, boost::noncopyable>("LocalSavegames")
+      .def("mappings", bpy::pure_virtual(&LocalSavegames::mappings))
+      .def("prepareProfile", bpy::pure_virtual(&LocalSavegames::prepareProfile))
+      ;
+
+  bpy::class_<SaveGameInfoWrapper, boost::noncopyable>("SaveGameInfo")
+      .def("getSaveGameInfo", bpy::pure_virtual(&SaveGameInfo::getSaveGameInfo), bpy::return_value_policy<bpy::manage_new_object>())
+      .def("getMissingAssets", bpy::pure_virtual(&SaveGameInfo::getMissingAssets))
+      .def("getSaveGameWidget", bpy::pure_virtual(&SaveGameInfo::getSaveGameWidget), bpy::return_value_policy<bpy::manage_new_object>())
+      .def("hasScriptExtenderSave", bpy::pure_virtual(&SaveGameInfo::hasScriptExtenderSave))
+      ;
+
+  bpy::class_<ScriptExtenderWrapper, boost::noncopyable>("ScriptExtender")
+      .def("BinaryName", bpy::pure_virtual(&ScriptExtender::BinaryName))
+      .def("PluginPath", bpy::pure_virtual(&ScriptExtender::PluginPath))
+      .def("loaderName", bpy::pure_virtual(&ScriptExtender::loaderName))
+      .def("loaderPath", bpy::pure_virtual(&ScriptExtender::loaderPath))
+      .def("saveGameAttachmentExtensions", bpy::pure_virtual(&ScriptExtender::saveGameAttachmentExtensions))
+      .def("isInstalled", bpy::pure_virtual(&ScriptExtender::isInstalled))
+      .def("getExtenderVersion", bpy::pure_virtual(&ScriptExtender::getExtenderVersion))
+      .def("getArch", bpy::pure_virtual(&ScriptExtender::getArch))
+      ;
+
+  bpy::class_<UnmanagedModsWrapper, boost::noncopyable>("UnmanagedMods")
+      .def("mods", bpy::pure_virtual(&UnmanagedMods::mods))
+      .def("displayName", bpy::pure_virtual(&UnmanagedMods::displayName))
+      .def("referenceFile", bpy::pure_virtual(&UnmanagedMods::referenceFile))
+      .def("secondaryFiles", bpy::pure_virtual(&UnmanagedMods::secondaryFiles))
+      ;
+}
diff --git a/src/runner/gamefeatureswrappers.h b/src/runner/gamefeatureswrappers.h
new file mode 100644
index 0000000..889889a
--- /dev/null
+++ b/src/runner/gamefeatureswrappers.h
@@ -0,0 +1,85 @@
+#ifndef GAMEFEATURESWRAPPERS_H
+#define GAMEFEATURESWRAPPERS_H
+
+#include <bsainvalidation.h>
+#include <dataarchives.h>
+#include <gameplugins.h>
+#include <localsavegames.h>
+#include <savegameinfo.h>
+#include <scriptextender.h>
+#include <unmanagedmods.h>
+
+// this might need turning off if Q_MOC_RUN is defined
+#include <boost/python.hpp>
+
+/////////////////////////////
+/// Wrapper declarations
+
+class BSAInvalidationWrapper : public BSAInvalidation, public boost::python::wrapper<BSAInvalidation>
+{
+  virtual bool isInvalidationBSA(const QString &bsaName) override;
+  virtual void deactivate(MOBase::IProfile *profile) override;
+  virtual void activate(MOBase::IProfile *profile) override;
+};
+
+class DataArchivesWrapper : public DataArchives, public boost::python::wrapper<DataArchives>
+{
+  virtual QStringList vanillaArchives() const override;
+  virtual QStringList archives(const MOBase::IProfile *profile) const override;
+  virtual void addArchive(MOBase::IProfile *profile, int index, const QString &archiveName) override;
+  virtual void removeArchive(MOBase::IProfile *profile, const QString &archiveName) override;
+};
+
+class GamePluginsWrapper : public GamePlugins, public boost::python::wrapper<GamePlugins>
+{
+  virtual void writePluginLists(const MOBase::IPluginList *pluginList) override;
+  virtual void readPluginLists(MOBase::IPluginList *pluginList) override;
+};
+
+class LocalSavegamesWrapper : public LocalSavegames, public boost::python::wrapper<LocalSavegames>
+{
+  virtual MappingType mappings(const QDir &profileSaveDir) const override;
+  virtual void prepareProfile(MOBase::IProfile *profile) override;
+};
+
+class SaveGameInfoWrapper : public SaveGameInfo, public boost::python::wrapper<SaveGameInfo>
+{
+  virtual MOBase::ISaveGame const *getSaveGameInfo(QString const &file) const override;
+  virtual MissingAssets getMissingAssets(QString const &file) const override;
+  virtual MOBase::ISaveGameInfoWidget *getSaveGameWidget(QWidget *parent = 0) const override;
+  virtual bool hasScriptExtenderSave(QString const &file) const override;
+};
+
+class ScriptExtenderWrapper : public ScriptExtender, public boost::python::wrapper<ScriptExtender>
+{
+  virtual QString BinaryName() const override;
+  virtual QString PluginPath() const override;
+  virtual QString loaderName() const override;
+  virtual QString loaderPath() const override;
+  virtual QStringList saveGameAttachmentExtensions() const override;
+  virtual bool isInstalled() const override;
+  virtual QString getExtenderVersion() const override;
+  virtual WORD getArch() const  override;
+};
+
+class UnmanagedModsWrapper : public UnmanagedMods, public boost::python::wrapper<UnmanagedMods>
+{
+  virtual QStringList mods(bool onlyOfficial) const override;
+  virtual QString displayName(const QString &modName) const override;
+  virtual QFileInfo referenceFile(const QString &modName) const override;
+  virtual QStringList secondaryFiles(const QString &modName) const override;
+};
+
+/// end Wrapper declarations
+/////////////////////////////
+
+struct game_features_map_from_python
+{
+  game_features_map_from_python();
+  static void *convertible(PyObject *objPtr);
+  static void construct(PyObject *objPtr, boost::python::converter::rvalue_from_python_stage1_data *data);
+};
+
+void registerGameFeaturesPythonConverters();
+
+#endif // GAMEFEATURESWRAPPERS_H
diff --git a/src/runner/proxypluginwrappers.cpp b/src/runner/proxypluginwrappers.cpp
index 104575b..da807aa 100644
--- a/src/runner/proxypluginwrappers.cpp
+++ b/src/runner/proxypluginwrappers.cpp
@@ -1,8 +1,10 @@
 #include "proxypluginwrappers.h"
-#include <utility.h>
-#include "error.h"
+
 #include "gilock.h"
+#include <QUrl>
 #include <QWidget>
+#include "pycatch.h"
+#include "sipApiAccess.h"
 
 namespace boost
 {
@@ -21,204 +23,386 @@ namespace boost
 
 using namespace MOBase;
 
-#define PYCATCH catch (const boost::python::error_already_set &) { reportPythonError(); throw MyException("unhandled exception"); }\
-                catch (...) { throw MyException("An unknown exception was thrown in python code"); }
 
+#define COMMON_I_PLUGIN_WRAPPER_DEFINITIONS(class_name) \
+bool class_name::init(MOBase::IOrganizer *moInfo) \
+{ \
+  try { \
+    return this->get_override("init")(boost::python::ptr(moInfo)); \
+  } PYCATCH; \
+} \
+ \
+QString class_name::name() const \
+{ \
+  try { \
+    return this->get_override("name")().as<QString>(); \
+  } PYCATCH; \
+} \
+ \
+QString class_name::author() const \
+{ \
+  try { \
+    return this->get_override("author")().as<QString>(); \
+  } PYCATCH; \
+} \
+ \
+QString class_name::description() const \
+{ \
+  try { \
+    return this->get_override("description")().as<QString>(); \
+  } PYCATCH; \
+} \
+ \
+MOBase::VersionInfo class_name::version() const \
+{ \
+  try { \
+    return this->get_override("version")().as<MOBase::VersionInfo>(); \
+  } PYCATCH; \
+} \
+ \
+bool class_name::isActive() const \
+{ \
+  try { \
+    return this->get_override("isActive")().as<bool>(); \
+  } PYCATCH; \
+} \
+ \
+QList<MOBase::PluginSetting> class_name::settings() const \
+{ \
+  try { \
+    return this->get_override("settings")().as<QList<MOBase::PluginSetting>>(); \
+  } PYCATCH; \
+}
 
+/// end COMMON_I_PLUGIN_WRAPPER_DEFINITIONS
 /////////////////////////////
 /// IPlugin Wrapper
-bool IPluginWrapper::init(MOBase::IOrganizer *moInfo)
-{
-  try {
-    return this->get_override("init")(boost::python::ptr(moInfo));
-  } PYCATCH;
-}
 
-QString IPluginWrapper::name() const
-{
-  try {
-    return this->get_override("name")().as<QString>();
-  } PYCATCH;
-}
 
-QString IPluginWrapper::author() const
-{
-  try {
-    return this->get_override("author")().as<QString>();
-  } PYCATCH;
-}
-
-QString IPluginWrapper::description() const
-{
-  try {
-    return this->get_override("description")().as<QString>();
-  } PYCATCH;
-}
-
-MOBase::VersionInfo IPluginWrapper::version() const
-{
-  try {
-    return this->get_override("version")().as<MOBase::VersionInfo>();
-  } PYCATCH;
-}
-
-bool IPluginWrapper::isActive() const
-{
-  try {
-    return this->get_override("isActive")().as<bool>();
-  } PYCATCH;
-}
-
-QList<MOBase::PluginSetting> IPluginWrapper::settings() const
-{
-  try {
-    return this->get_override("settings")().as<QList<MOBase::PluginSetting>>();
-  } PYCATCH;
-}
+COMMON_I_PLUGIN_WRAPPER_DEFINITIONS(IPluginWrapper)
 /// end IPlugin Wrapper
-/////////////////////////////
-/// IPluginTool Wrapper
+/////////////////////////////////////
+/// IPluginDiagnose Wrapper
 
 
-bool IPluginToolWrapper::init(MOBase::IOrganizer *moInfo)
-{
-  try {
-    return this->get_override("init")(boost::python::ptr(moInfo));
-  } PYCATCH;
-}
+COMMON_I_PLUGIN_WRAPPER_DEFINITIONS(IPluginDiagnoseWrapper)
 
-QString IPluginToolWrapper::name() const
-{
-  try {
-    return this->get_override("name")().as<QString>();
-  } PYCATCH;
-}
-
-QString IPluginToolWrapper::author() const
-{
-  try {
-    return this->get_override("author")().as<QString>();
-  } PYCATCH;
-}
-
-QString IPluginToolWrapper::description() const
-{
-  try {
-    return this->get_override("description")().as<QString>();
-  } PYCATCH;
-}
-
-MOBase::VersionInfo IPluginToolWrapper::version() const
-{
-  try {
-    return this->get_override("version")().as<MOBase::VersionInfo>();
-  } PYCATCH;
-}
-
-bool IPluginToolWrapper::isActive() const
-{
-  try {
-    return this->get_override("isActive")().as<bool>();
-  } PYCATCH;
-}
-
-QList<MOBase::PluginSetting> IPluginToolWrapper::settings() const
-{
-  try {
-    return this->get_override("settings")().as<QList<MOBase::PluginSetting>>();
-  } PYCATCH;
-}
-
-QString IPluginToolWrapper::displayName() const
-{
-  try {
-    return this->get_override("displayName")().as<QString>();
-  } PYCATCH;
-}
-
-QString IPluginToolWrapper::tooltip() const
-{
-  try {
-    return this->get_override("tooltip")().as<QString>();
-  } PYCATCH;
-}
-
-QIcon IPluginToolWrapper::icon() const
-{
-  try {
-    return this->get_override("icon")().as<QIcon>();
-  } PYCATCH;
-}
-
-void IPluginToolWrapper::setParentWidget(QWidget *parent)
-{
-  try {
-    this->get_override("setParentWidget")(parent);
-  } PYCATCH;
-}
-
-void IPluginToolWrapper::display() const
+std::vector<unsigned int> IPluginDiagnoseWrapper::activeProblems() const
 {
   try {
     GILock lock;
 
-    this->get_override("display")();
+    return this->get_override("activeProblems")();
   } PYCATCH;
 }
 
-/// end IPluginTool Wrapper
+QString IPluginDiagnoseWrapper::shortDescription(unsigned int key) const
+{
+  try {
+    return this->get_override("shortDescription")(key);
+  } PYCATCH;
+}
+
+QString IPluginDiagnoseWrapper::fullDescription(unsigned int key) const
+{
+  try {
+    return this->get_override("fullDescription")(key);
+  } PYCATCH;
+}
+
+bool IPluginDiagnoseWrapper::hasGuidedFix(unsigned int key) const
+{
+  try {
+    return this->get_override("hasGuidedFix")(key);
+  } PYCATCH;
+}
+
+void IPluginDiagnoseWrapper::startGuidedFix(unsigned int key) const
+{
+  try {
+    GILock lock;
+
+    this->get_override("startGuidedFix")(key);
+  } PYCATCH;
+}
+
+void IPluginDiagnoseWrapper::invalidate()
+{
+  IPluginDiagnose::invalidate();
+}
+/// end IPluginDiagnose Wrapper
+/////////////////////////////////////
+/// IPluginFileMapper Wrapper
+
+
+COMMON_I_PLUGIN_WRAPPER_DEFINITIONS(IPluginFileMapperWrapper)
+
+MappingType IPluginFileMapperWrapper::mappings() const
+{
+  try {
+    return this->get_override("mappings")();
+  } PYCATCH;
+}
+/// end IPluginFileMapper Wrapper
+/////////////////////////////////////
+/// IPluginGame Wrapper
+
+
+QString IPluginGameWrapper::gameName() const
+{
+  GILock lock;
+  try {
+    return this->get_override("gameName")();
+  } PYCATCH;
+}
+
+void IPluginGameWrapper::initializeProfile(const QDir & directory, ProfileSettings settings) const
+{
+  GILock lock;
+  try {
+    this->get_override("initializeProfile")(directory, settings);
+  } PYCATCH;
+}
+
+QString IPluginGameWrapper::savegameExtension() const
+{
+  GILock lock;
+  try {
+    return this->get_override("savegameExtension")();
+  } PYCATCH;
+}
+
+QString IPluginGameWrapper::savegameSEExtension() const
+{
+  GILock lock;
+  try {
+    return this->get_override("savegameSEExtension")();
+  } PYCATCH;
+}
+
+bool IPluginGameWrapper::isInstalled() const
+{
+  GILock lock;
+  try {
+    return this->get_override("isInstalled")();
+  } PYCATCH;
+}
+
+QIcon IPluginGameWrapper::gameIcon() const
+{
+  GILock lock;
+  try {
+    return this->get_override("gameIcon")();
+  } PYCATCH;
+}
+
+QDir IPluginGameWrapper::gameDirectory() const
+{
+  GILock lock;
+  try {
+    return this->get_override("gameDirectory")();
+  } PYCATCH;
+}
+
+QDir IPluginGameWrapper::dataDirectory() const
+{
+  GILock lock;
+  try {
+    return this->get_override("dataDirectory")();
+  } PYCATCH;
+}
+
+void IPluginGameWrapper::setGamePath(const QString & path)
+{
+  GILock lock;
+  try {
+    this->get_override("setGamePath")(path);
+  } PYCATCH;
+}
+
+QDir IPluginGameWrapper::documentsDirectory() const
+{
+  GILock lock;
+  try {
+    return this->get_override("documentsDirectory")();
+  } PYCATCH;
+}
+
+QDir IPluginGameWrapper::savesDirectory() const
+{
+  GILock lock;
+  try {
+    return this->get_override("savesDirectory")();
+  } PYCATCH;
+}
+
+QList<MOBase::ExecutableInfo> IPluginGameWrapper::executables() const
+{
+  GILock lock;
+  try {
+    return this->get_override("executables")();
+  } PYCATCH;
+}
+
+QString IPluginGameWrapper::steamAPPId() const
+{
+  GILock lock;
+  try {
+    return this->get_override("steamAPPId")();
+  } PYCATCH;
+}
+
+QStringList IPluginGameWrapper::primaryPlugins() const
+{
+  GILock lock;
+  try {
+    return this->get_override("primaryPlugins")();
+  } PYCATCH;
+}
+
+QStringList IPluginGameWrapper::gameVariants() const
+{
+  GILock lock;
+  try {
+    return this->get_override("gameVariants")();
+  } PYCATCH;
+}
+
+void IPluginGameWrapper::setGameVariant(const QString & variant)
+{
+  GILock lock;
+  try {
+    this->get_override("setGameVariant")(variant);
+  } PYCATCH;
+}
+
+QString IPluginGameWrapper::binaryName() const
+{
+  GILock lock;
+  try {
+    return this->get_override("binaryName")();
+  } PYCATCH;
+}
+
+QString IPluginGameWrapper::gameShortName() const
+{
+  GILock lock;
+  try {
+    return this->get_override("gameShortName")();
+  } PYCATCH;
+}
+
+QStringList IPluginGameWrapper::validShortNames() const
+{
+  GILock lock;
+  try {
+    return this->get_override("validShortNames")();
+  } PYCATCH;
+}
+
+QString IPluginGameWrapper::gameNexusName() const
+{
+  GILock lock;
+  try {
+    return this->get_override("gameNexusName")();
+  } PYCATCH;
+}
+
+QStringList IPluginGameWrapper::iniFiles() const
+{
+  GILock lock;
+  try {
+    return this->get_override("iniFiles")();
+  } PYCATCH;
+}
+
+QStringList IPluginGameWrapper::DLCPlugins() const
+{
+  GILock lock;
+  try {
+    return this->get_override("DLCPlugins")();
+  } PYCATCH;
+}
+
+QStringList IPluginGameWrapper::CCPlugins() const
+{
+  GILock lock;
+  try {
+    return this->get_override("CCPlugins")();
+  } PYCATCH;
+}
+
+IPluginGame::LoadOrderMechanism IPluginGameWrapper::loadOrderMechanism() const
+{
+  GILock lock;
+  try {
+    return this->get_override("loadOrderMechanism")();
+  } PYCATCH;
+}
+
+IPluginGame::SortMechanism IPluginGameWrapper::sortMechanism() const
+{
+  GILock lock;
+  try {
+    return this->get_override("sortMechanism")();
+  } PYCATCH;
+}
+
+int IPluginGameWrapper::nexusModOrganizerID() const
+{
+  GILock lock;
+  try {
+    return this->get_override("nexusModOrganizerID")();
+  } PYCATCH;
+}
+
+int IPluginGameWrapper::nexusGameID() const
+{
+  GILock lock;
+  try {
+    return this->get_override("nexusGameID")();
+  } PYCATCH;
+}
+
+bool IPluginGameWrapper::looksValid(QDir const & dir) const
+{
+  GILock lock;
+  try {
+    return this->get_override("looksValid")(dir);
+  } PYCATCH;
+}
+
+QString IPluginGameWrapper::gameVersion() const
+{
+  GILock lock;
+  try {
+    return this->get_override("gameVersion")();
+  } PYCATCH;
+}
+
+QString IPluginGameWrapper::getLauncherName() const
+{
+  GILock lock;
+  try {
+    return this->get_override("getLauncherName")();
+  } PYCATCH;
+}
+
+COMMON_I_PLUGIN_WRAPPER_DEFINITIONS(IPluginGameWrapper)
+
+std::map<std::type_index, boost::any> IPluginGameWrapper::featureList() const
+{
+  GILock lock;
+  try {
+    return this->get_override("_featureList")();
+  } PYCATCH;
+}
+/// end IPluginGame Wrapper
 /////////////////////////////////////
 /// IPluginInstallerCustom Wrapper
 
 
-bool IPluginInstallerCustomWrapper::init(MOBase::IOrganizer *moInfo)
-{
-  try {
-    return this->get_override("init")(boost::python::ptr(moInfo));
-  } PYCATCH;
-}
-
-QString IPluginInstallerCustomWrapper::name() const
-{
-  try {
-    return this->get_override("name")().as<QString>();
-  } PYCATCH;
-}
-
-QString IPluginInstallerCustomWrapper::author() const
-{
-  try {
-    return this->get_override("author")().as<QString>();
-  } PYCATCH;
-}
-
-QString IPluginInstallerCustomWrapper::description() const
-{
-  try {
-    return this->get_override("description")().as<QString>();
-  } PYCATCH;
-}
-
-MOBase::VersionInfo IPluginInstallerCustomWrapper::version() const
-{
-  try {
-    return this->get_override("version")();
-  } PYCATCH;
-}
-
-bool IPluginInstallerCustomWrapper::isActive() const
-{
-  try {
-    return this->get_override("isActive")();
-  } PYCATCH;
-}
-
-QList<MOBase::PluginSetting> IPluginInstallerCustomWrapper::settings() const
-{
-  try {
-    return this->get_override("settings")().as<QList<MOBase::PluginSetting>>();
-  } PYCATCH;
-}
+COMMON_I_PLUGIN_WRAPPER_DEFINITIONS(IPluginInstallerCustomWrapper)
 
 unsigned int IPluginInstallerCustomWrapper::priority() const
 {
@@ -272,5 +456,119 @@ void IPluginInstallerCustomWrapper::setParentWidget(QWidget *parent)
     this->get_override("setParentWidget")(parent);
   } PYCATCH;
 }
+/// end IPluginInstallerCustom Wrapper
+/////////////////////////////
+/// IPluginModPage Wrapper
 
 
+COMMON_I_PLUGIN_WRAPPER_DEFINITIONS(IPluginModPageWrapper)
+
+QString IPluginModPageWrapper::displayName() const
+{
+  try {
+    return this->get_override("displayName")();
+  } PYCATCH;
+}
+
+QIcon IPluginModPageWrapper::icon() const
+{
+  try {
+    return this->get_override("icon")();
+  } PYCATCH;
+}
+
+QUrl IPluginModPageWrapper::pageURL() const
+{
+  try {
+    return this->get_override("pageURL")();
+  } PYCATCH;
+}
+
+bool IPluginModPageWrapper::useIntegratedBrowser() const
+{
+  try {
+    return this->get_override("useIntegratedBrowser")();
+  } PYCATCH;
+}
+
+bool IPluginModPageWrapper::handlesDownload(const QUrl & pageURL, const QUrl & downloadURL, MOBase::ModRepositoryFileInfo & fileInfo) const
+{
+  try {
+    return this->get_override("handlesDownload")(pageURL, downloadURL, fileInfo);
+  } PYCATCH;
+}
+
+void IPluginModPageWrapper::setParentWidget(QWidget * widget)
+{
+  try {
+    this->get_override("setParentWidget")(widget);
+  } PYCATCH;
+}
+/// end IPluginModPage Wrapper
+/////////////////////////////
+/// IPluginPreview Wrapper
+
+
+COMMON_I_PLUGIN_WRAPPER_DEFINITIONS(IPluginPreviewWrapper)
+
+std::set<QString> IPluginPreviewWrapper::supportedExtensions() const
+{
+  try {
+    return this->get_override("supportedExtensions")();
+  } PYCATCH;
+}
+
+QWidget *IPluginPreviewWrapper::genFilePreview(const QString &fileName, const QSize &maxSize) const
+{
+  try {
+    boost::python::object pyVersion = this->get_override("genFilePreview")(fileName, maxSize);
+    // We need responsibility for deleting the QWidget to be transferred to C++
+    sipAPI()->api_transfer_to(pyVersion.ptr(), 0);
+    return boost::python::extract<QWidget *>(pyVersion)();
+  } PYCATCH;
+}
+/// end IPluginPreview Wrapper
+/////////////////////////////
+/// IPluginTool Wrapper
+
+
+COMMON_I_PLUGIN_WRAPPER_DEFINITIONS(IPluginToolWrapper)
+
+QString IPluginToolWrapper::displayName() const
+{
+  try {
+    return this->get_override("displayName")().as<QString>();
+  } PYCATCH;
+}
+
+QString IPluginToolWrapper::tooltip() const
+{
+  try {
+    return this->get_override("tooltip")().as<QString>();
+  } PYCATCH;
+}
+
+QIcon IPluginToolWrapper::icon() const
+{
+  try {
+    return this->get_override("icon")().as<QIcon>();
+  } PYCATCH;
+}
+
+void IPluginToolWrapper::setParentWidget(QWidget *parent)
+{
+  try {
+    this->get_override("setParentWidget")(parent);
+  } PYCATCH;
+}
+
+void IPluginToolWrapper::display() const
+{
+  try {
+    GILock lock;
+
+    this->get_override("display")();
+  } PYCATCH;
+}
+
+/// end IPluginTool Wrapper
diff --git a/src/runner/proxypluginwrappers.h b/src/runner/proxypluginwrappers.h
index 6131a24..12e6829 100644
--- a/src/runner/proxypluginwrappers.h
+++ b/src/runner/proxypluginwrappers.h
@@ -2,68 +2,126 @@
 #define PROXYPLUGINWRAPPERS_H
 
 
-#include <iplugintool.h>
+#include <iplugindiagnose.h>
+#include <ipluginfilemapper.h>
+#include <iplugingame.h>
 #include <iplugininstallersimple.h>
 #include <iplugininstallercustom.h>
+#include <ipluginmodpage.h>
+#include <ipluginpreview.h>
+#include <iplugintool.h>
 
 #ifndef Q_MOC_RUN
 #include <boost/python.hpp>
 #endif
 
 
+#define COMMON_I_PLUGIN_WRAPPER_DECLARATIONS public: \
+virtual bool init(MOBase::IOrganizer *moInfo) override; \
+virtual QString name() const override; \
+virtual QString author() const override; \
+virtual QString description() const override; \
+virtual MOBase::VersionInfo version() const override; \
+virtual bool isActive() const override; \
+virtual QList<MOBase::PluginSetting> settings() const override;
+
+
 class IPluginWrapper : public MOBase::IPlugin, public boost::python::wrapper<MOBase::IPlugin>
 {
   Q_INTERFACES(MOBase::IPlugin)
 
-public:
-  virtual bool init(MOBase::IOrganizer *moInfo);
-  virtual QString name() const;
-  virtual QString author() const;
-  virtual QString description() const;
-  virtual MOBase::VersionInfo version() const;
-  virtual bool isActive() const;
-  virtual QList<MOBase::PluginSetting> settings() const;
+  COMMON_I_PLUGIN_WRAPPER_DECLARATIONS
 };
 
 
-class IPluginToolWrapper: public MOBase::IPluginTool, public boost::python::wrapper<MOBase::IPluginTool>
+// Even though the base interface is not an IPlugin or QObject, this has to be because we have no way to pass Mod Organizer a plugin that implements multiple interfaces.
+// QObject must be the first base class because moc assumes the first base class is a QObject
+class IPluginDiagnoseWrapper : public QObject, public MOBase::IPluginDiagnose, public MOBase::IPlugin, public boost::python::wrapper<MOBase::IPluginDiagnose>
 {
   Q_OBJECT
-  Q_INTERFACES(MOBase::IPlugin MOBase::IPluginTool)
+  Q_INTERFACES(MOBase::IPlugin MOBase::IPluginDiagnose)
 
 public:
-  virtual bool init(MOBase::IOrganizer *moInfo);
-  virtual QString name() const;
-  virtual QString author() const;
-  virtual QString description() const;
-  virtual MOBase::VersionInfo version() const;
-  virtual bool isActive() const;
-  virtual QList<MOBase::PluginSetting> settings() const;
+  virtual std::vector<unsigned int> activeProblems() const override;
+  virtual QString shortDescription(unsigned int key) const override;
+  virtual QString fullDescription(unsigned int key) const override;
+  virtual bool hasGuidedFix(unsigned int key) const override;
+  virtual void startGuidedFix(unsigned int key) const override;
+  // Other functions exist, but shouldn't need wrapping as a default implementation exists
+  // This was protected, but Python doesn't have that, so it needs making public
+  virtual void invalidate();
 
-  virtual QString displayName() const;
-  virtual QString tooltip() const;
-  virtual QIcon icon() const;
-  virtual void setParentWidget(QWidget *parent);
-
-public slots:
-  virtual void display() const;
+  COMMON_I_PLUGIN_WRAPPER_DECLARATIONS
 };
 
 
-class IPluginInstallerCustomWrapper: public MOBase::IPluginInstallerCustom, public boost::python::wrapper<MOBase::IPluginInstallerCustom>
+// Even though the base interface is not an IPlugin or QObject, this has to be because we have no way to pass Mod Organizer a plugin that implements multiple interfaces.
+// QObject must be the first base class because moc assumes the first base class is a QObject
+class IPluginFileMapperWrapper : public QObject, public MOBase::IPluginFileMapper, public MOBase::IPlugin, public boost::python::wrapper<MOBase::IPluginFileMapper>
+{
+  Q_OBJECT
+  Q_INTERFACES(MOBase::IPlugin MOBase::IPluginFileMapper)
+
+public:
+  virtual MappingType mappings() const override;
+
+  COMMON_I_PLUGIN_WRAPPER_DECLARATIONS
+};
+
+
+class IPluginGameWrapper : public MOBase::IPluginGame, public boost::python::wrapper<MOBase::IPluginGame> {
+  Q_OBJECT
+  Q_INTERFACES(MOBase::IPlugin MOBase::IPluginGame)
+
+public:
+  virtual QString gameName() const override;
+  virtual void initializeProfile(const QDir &directory, ProfileSettings settings) const override;
+  virtual QString savegameExtension() const override;
+  virtual QString savegameSEExtension() const override;
+  virtual bool isInstalled() const override;
+  virtual QIcon gameIcon() const override;
+  virtual QDir gameDirectory() const override;
+  virtual QDir dataDirectory() const override;
+  virtual void setGamePath(const QString &path) override;
+  virtual QDir documentsDirectory() const override;
+  virtual QDir savesDirectory() const override;
+  virtual QList<MOBase::ExecutableInfo> executables() const override;
+  virtual QString steamAPPId() const override;
+  virtual QStringList primaryPlugins() const override;
+  virtual QStringList gameVariants() const override;
+  virtual void setGameVariant(const QString &variant) override;
+  virtual QString binaryName() const override;
+  virtual QString gameShortName() const override;
+  virtual QStringList validShortNames() const override;
+  virtual QString gameNexusName() const override;
+  virtual QStringList iniFiles() const override;
+  virtual QStringList DLCPlugins() const override;
+  virtual QStringList CCPlugins() const override;
+  virtual LoadOrderMechanism loadOrderMechanism() const override;
+  virtual SortMechanism sortMechanism() const override;
+  virtual int nexusModOrganizerID() const override;
+  virtual int nexusGameID() const override;
+  virtual bool looksValid(QDir const &dir) const override;
+  virtual QString gameVersion() const override;
+  virtual QString getLauncherName() const override;
+
+  COMMON_I_PLUGIN_WRAPPER_DECLARATIONS
+
+protected:
+  // Apparently, Python developers interpret an underscore in a function name as it being protected
+  virtual std::map<std::type_index, boost::any> featureList() const override;
+
+  // Thankfully, the default implementation of the templated 'T *feature()' function should allow us to get away without overriding it.
+};
+
+
+class IPluginInstallerCustomWrapper : public MOBase::IPluginInstallerCustom, public boost::python::wrapper<MOBase::IPluginInstallerCustom>
 {
   Q_OBJECT
   Q_INTERFACES(MOBase::IPlugin MOBase::IPluginInstaller MOBase::IPluginInstallerCustom)
 
+  COMMON_I_PLUGIN_WRAPPER_DECLARATIONS
 public:
-  virtual bool init(MOBase::IOrganizer *moInfo);
-  virtual QString name() const;
-  virtual QString author() const;
-  virtual QString description() const;
-  virtual MOBase::VersionInfo version() const;
-  virtual bool isActive() const;
-  virtual QList<MOBase::PluginSetting> settings() const;
-
   virtual unsigned int priority() const;
   virtual bool isManualInstaller() const;
   virtual bool isArchiveSupported(const MOBase::DirectoryTree &tree) const;
@@ -76,6 +134,51 @@ public:
 };
 
 
+class IPluginModPageWrapper : public MOBase::IPluginModPage, public boost::python::wrapper<MOBase::IPluginModPage>
+{
+  Q_OBJECT
+  Q_INTERFACES(MOBase::IPlugin MOBase::IPluginModPage)
+
+  COMMON_I_PLUGIN_WRAPPER_DECLARATIONS
+public:
+  virtual QString displayName() const override;
+  virtual QIcon icon() const override;
+  virtual QUrl pageURL() const override;
+  virtual bool useIntegratedBrowser() const override;
+  virtual bool handlesDownload(const QUrl &pageURL, const QUrl &downloadURL, MOBase::ModRepositoryFileInfo &fileInfo) const override;
+  virtual void setParentWidget(QWidget *widget) override;
+};
+
+
+class IPluginPreviewWrapper : public MOBase::IPluginPreview, public boost::python::wrapper<MOBase::IPluginPreview>
+{
+  Q_OBJECT
+  Q_INTERFACES(MOBase::IPlugin MOBase::IPluginPreview)
+
+  COMMON_I_PLUGIN_WRAPPER_DECLARATIONS
+public:
+  virtual std::set<QString> supportedExtensions() const override;
+  virtual QWidget *genFilePreview(const QString &fileName, const QSize &maxSize) const override;
+};
+
+
+class IPluginToolWrapper: public MOBase::IPluginTool, public boost::python::wrapper<MOBase::IPluginTool>
+{
+  Q_OBJECT
+  Q_INTERFACES(MOBase::IPlugin MOBase::IPluginTool)
+
+  COMMON_I_PLUGIN_WRAPPER_DECLARATIONS
+public:
+  virtual QString displayName() const;
+  virtual QString tooltip() const;
+  virtual QIcon icon() const;
+  virtual void setParentWidget(QWidget *parent);
+
+public slots:
+  virtual void display() const;
+};
+
+
 
 
 #endif // PROXYPLUGINWRAPPERS_H
diff --git a/src/runner/pycatch.h b/src/runner/pycatch.h
new file mode 100644
index 0000000..e74ce4d
--- /dev/null
+++ b/src/runner/pycatch.h
@@ -0,0 +1,11 @@
+#ifndef PYCATCH_H
+#define PYCATCH_H
+
+#include <utility.h>
+
+#include "error.h"
+
+#define PYCATCH catch (const boost::python::error_already_set &) { reportPythonError(); throw MOBase::MyException("unhandled exception"); }\
+                catch (...) { throw MOBase::MyException("An unknown exception was thrown in python code"); }
+
+#endif // PYCATCH_H
diff --git a/src/runner/pythonrunner.cpp b/src/runner/pythonrunner.cpp
index 79ad1c7..7578949 100644
--- a/src/runner/pythonrunner.cpp
+++ b/src/runner/pythonrunner.cpp
@@ -3,13 +3,14 @@
 #pragma warning( disable : 4100 )
 #pragma warning( disable : 4996 )
 
-#include "iplugingame.h"
+#include <iplugin.h>
+#include <iplugingame.h>
 #include <iplugininstaller.h>
 #include <iplugintool.h>
-#include <iplugingame.h>
-#include <iplugin.h>
 #include "uibasewrappers.h"
 #include "proxypluginwrappers.h"
+#include "gamefeatureswrappers.h"
+#include "sipApiAccess.h"
 
 #include <Windows.h>
 #include <utility.h>
@@ -68,26 +69,15 @@ using namespace MOBase;
 
 namespace bpy = boost::python;
 
-struct ModRepositoryFileInfo_to_python_dict
-{
-  static PyObject *convert(const ModRepositoryFileInfo &info) {
-    PyObject *res = PyDict_New();
-    PyDict_SetItemString(res, "uri", bpy::incref(bpy::object(info.uri).ptr()));
-    PyDict_SetItemString(res, "name", bpy::incref(bpy::object(info.name).ptr()));
-    PyDict_SetItemString(res, "description", bpy::incref(bpy::object(info.description.toUtf8().constData()).ptr()));
-    PyDict_SetItemString(res, "categoryID", PyLong_FromLong(info.categoryID));
-    PyDict_SetItemString(res, "fileID", PyLong_FromLong(info.fileID));
-    PyDict_SetItemString(res, "fileSize", PyLong_FromLong(static_cast<long>(info.fileSize)));
-    PyDict_SetItemString(res, "version", bpy::incref(bpy::object(info.version).ptr()));
-    return bpy::incref(res);
-  }
-};
-
 
 struct QString_to_python_str
 {
   static PyObject *convert(const QString &str) {
-    return bpy::incref(bpy::object(str.toUtf8().constData()).ptr());
+    // It's safer to explicitly convert to unicode as if we don't, this can return either str or unicode without it being easy to know which to expect
+    bpy::object pyStr = bpy::object(str.toUtf8().constData());
+    if (PyString_Check(pyStr.ptr()))
+      pyStr = pyStr.attr("decode")("utf-8");
+    return bpy::incref(pyStr.ptr());
   }
 };
 
@@ -182,6 +172,55 @@ struct GuessedValue_converters
 };
 
 
+template<typename key_type, typename value_type>
+struct QMap_converters
+{
+  struct QMap_to_python
+  {
+    static PyObject *convert(const QMap<key_type, value_type> &map) {
+      bpy::dict result;
+      QMapIterator<key_type, value_type> iter(map);
+      while (iter.hasNext()) {
+        iter.next();
+        result[bpy::object(iter.key())] = bpy::object(iter.value());
+      }
+      return bpy::incref(result.ptr());
+    }
+  };
+
+  struct QMap_from_python
+  {
+    QMap_from_python() {
+      bpy::converter::registry::push_back(&convertible, &construct, bpy::type_id<QMap<key_type, value_type>>());
+    }
+
+    static void *convertible(PyObject *objPtr) {
+      return PyDict_Check(objPtr) ? objPtr : nullptr;
+    }
+
+    static void construct(PyObject *objPtr, bpy::converter::rvalue_from_python_stage1_data *data) {
+      void *storage = ((bpy::converter::rvalue_from_python_storage<QMap<key_type, value_type>>*)data)->storage.bytes;
+      QMap<key_type, value_type> *result = new (storage) QMap<key_type, value_type>();
+      bpy::dict source(bpy::handle<>(bpy::borrowed(objPtr)));
+      bpy::list keys = source.keys();
+      int len = bpy::len(keys);
+      for (int i = 0; i < len; ++i) {
+        bpy::object pyKey = keys[i];
+        (*result)[bpy::extract<key_type>(pyKey)] = bpy::extract<value_type>(source[pyKey]);
+      }
+
+      data->convertible = storage;
+    }
+  };
+
+  QMap_converters()
+  {
+    QMap_from_python();
+    bpy::to_python_converter<QMap<key_type, value_type>, QMap_to_python >();
+  }
+};
+
+
 struct QVariant_to_python_obj
 {
   static PyObject *convert(const QVariant &var) {
@@ -189,24 +228,12 @@ struct QVariant_to_python_obj
       case QVariant::Int: return PyLong_FromLong(var.toInt());
       case QVariant::UInt: return PyLong_FromUnsignedLong(var.toUInt());
       case QVariant::Bool: return PyBool_FromLong(var.toBool());
-      case QVariant::String: return bpy::incref(bpy::object(var.toString().toUtf8().constData()).ptr());
+      case QVariant::String: return bpy::incref(bpy::object(var.toString()).ptr());
       case QVariant::List: {
-        QVariantList list = var.toList();
-        PyObject *result = PyList_New(list.count());
-        for (QVariant var : list) {
-          PyList_Append(result, convert(var));
-        }
-        return result;
+        return bpy::incref(bpy::object(var.toList()).ptr());
       } break;
       case QVariant::Map: {
-        QVariantMap map = var.toMap();
-        PyObject *result = PyDict_New();
-        QMapIterator<QString, QVariant> iter(map);
-        while (iter.hasNext()) {
-          iter.next();
-          PyDict_SetItem(result, convert(iter.key()), convert(iter.value()));
-        }
-        return result;
+        return bpy::incref(bpy::object(var.toMap()).ptr());
       } break;
       default: {
         PyErr_Format(PyExc_TypeError, "type unsupported: %d", var.type());
@@ -240,49 +267,21 @@ struct QVariant_from_python_obj
     data->convertible = storage;
   }
 
-  static QVariant variantFromPyObject(PyObject *objPtr) {
-    QVariant result;
-    if (PyList_Check(objPtr)) {
-      QVariantList resultList;
-      for (int i = 0; i < PyList_Size(objPtr); ++i) {
-        resultList.append(variantFromPyObject(PyList_GetItem(objPtr, i)));
-      }
-      result = resultList;
-    } else if (PyString_Check(objPtr)) {
-      result = PyString_AsString(objPtr);
-    } else if (PyBool_Check(objPtr)) {
-      result = (objPtr == Py_True);
-    } else if (PyInt_Check(objPtr)) {
-      //QVariant doesn't have long. It has int or long long. Given that on m/s,
-      //long is 32 bits for 32- and 64- bit code...
-      result = static_cast<int>(PyInt_AsLong(objPtr));
-    } else {
-      PyErr_SetString(PyExc_TypeError, "type unsupported");
-      throw bpy::error_already_set();
-    }
-    return result;
-  }
-
   static void construct(PyObject *objPtr, bpy::converter::rvalue_from_python_stage1_data *data) {
     // PyBools will also return true for PyInt_Check but not the other way around, so the order
     // here is relevant
     if (PyList_Check(objPtr)) {
-      QVariantList result;
-      for (int i = 0; i < PyList_Size(objPtr); ++i) {
-        result.append(variantFromPyObject(PyList_GetItem(objPtr, i)));
-      }
-      constructVariant(result, data);
-    } else if (PyString_Check(objPtr)) {
-      const char *value = PyString_AsString(objPtr);
-      constructVariant(value, data);
+      constructVariant(bpy::extract<QVariantList>(objPtr)(), data);
+    } else if (PyDict_Check(objPtr)) {
+      constructVariant(bpy::extract<QVariantMap>(objPtr)(), data);
+    } else if (PyString_Check(objPtr) || PyUnicode_Check(objPtr)) {
+      constructVariant(bpy::extract<QString>(objPtr)(), data);
     } else if (PyBool_Check(objPtr)) {
-      bool value = (objPtr == Py_True);
-      constructVariant(value, data);
+      constructVariant(bpy::extract<bool>(objPtr)(), data);
     } else if (PyInt_Check(objPtr)) {
       //QVariant doesn't have long. It has int or long long. Given that on m/s,
       //long is 32 bits for 32- and 64- bit code...
-      int value = static_cast<int>(PyInt_AsLong(objPtr));
-      constructVariant(value, data);
+      constructVariant(bpy::extract<int>(objPtr)(), data);
     } else {
       PyErr_SetString(PyExc_TypeError, "type unsupported");
       throw bpy::error_already_set();
@@ -340,6 +339,55 @@ struct QList_from_python_obj
 };
 
 
+template <typename T>
+struct std_vector_to_python_list
+{
+  static PyObject *convert(const std::vector<T> &vector)
+  {
+    bpy::list pyList;
+
+    try {
+      for (const T &item : vector)
+        pyList.append(item);
+    }
+    catch (const bpy::error_already_set&) {
+      reportPythonError();
+    }
+
+    return bpy::incref(pyList.ptr());
+  }
+};
+
+
+template <typename T>
+struct std_vector_from_python_obj
+{
+  std_vector_from_python_obj() {
+    bpy::converter::registry::push_back(
+      &convertible,
+      &construct,
+      bpy::type_id<std::vector<T> >());
+  }
+
+  static void* convertible(PyObject *objPtr) {
+    if (PyList_Check(objPtr)) return objPtr;
+    return nullptr;
+  }
+
+  static void construct(PyObject *objPtr, bpy::converter::rvalue_from_python_stage1_data *data) {
+    void *storage = ((bpy::converter::rvalue_from_python_storage<std::vector<T> >*)data)->storage.bytes;
+    std::vector<T> *result = new (storage) std::vector<T>();
+    bpy::list source(bpy::handle<>(bpy::borrowed(objPtr)));
+    int length = bpy::len(source);
+    for (int i = 0; i < length; ++i) {
+      result->push_back(bpy::extract<T>(source[i]));
+    }
+
+    data->convertible = storage;
+  }
+};
+
+
 template <typename T>
 struct QFlags_from_python_obj
 {
@@ -395,17 +443,6 @@ struct stdset_from_python_list
 };
 
 
-static const sipAPIDef *sipAPI()
-{
-  static const sipAPIDef *sipApi = nullptr;
-  if (sipApi == nullptr) {
-    sipApi = (const sipAPIDef *)PyCapsule_Import("sip._C_API", 0);
-  }
-
-  return sipApi;
-}
-
-
 struct IModRepositoryBridge_to_python
 {
   static PyObject *convert(IModRepositoryBridge *bridge)
@@ -424,8 +461,13 @@ template <> struct MetaData<IModRepositoryBridge> { static const char *className
 template <> struct MetaData<IDownloadManager> { static const char *className() { return "QObject"; } };
 template <> struct MetaData<QObject> { static const char *className() { return "QObject"; } };
 template <> struct MetaData<QWidget> { static const char *className() { return "QWidget"; } };
+template <> struct MetaData<QDateTime> { static const char *className() { return "QDateTime"; } };
+template <> struct MetaData<QDir> { static const char *className() { return "QDir"; } };
+template <> struct MetaData<QFileInfo> { static const char *className() { return "QFileInfo"; } };
 template <> struct MetaData<QIcon> { static const char *className() { return "QIcon"; } };
+template <> struct MetaData<QSize> { static const char *className() { return "QSize"; } };
 template <> struct MetaData<QStringList> { static const char *className() { return "QStringList"; } };
+template <> struct MetaData<QUrl> { static const char *className() { return "QUrl"; } };
 template <> struct MetaData<QVariant> { static const char *className() { return "QVariant"; } };
 
 
@@ -457,17 +499,33 @@ struct QClass_converters
 {
   struct QClass_to_PyQt
   {
+    template <typename Q>
+    static typename std::enable_if_t<std::is_copy_constructible_v<Q>, T*> getSafeCopy(T *qClass)
+    {
+      return new T(*qClass);
+    }
+
+    template <typename Q>
+    static typename std::enable_if_t<!std::is_copy_constructible_v<Q>, T*> getSafeCopy(T *qClass)
+    {
+      return qClass;
+    }
+
     static PyObject *convert(const T &object) {
       const sipTypeDef *type = sipAPI()->api_find_type(MetaData<T>::className());
       if (type == nullptr) {
         return bpy::incref(Py_None);
       }
 
-      PyObject *sipObj = sipAPI()->api_convert_from_type((void*)(&object), type, 0);
+      PyObject *sipObj = sipAPI()->api_convert_from_type((void*)getSafeCopy<T>((T*)&object), type, 0);
       if (sipObj == nullptr) {
         return bpy::incref(Py_None);
       }
 
+      if (std::is_copy_constructible_v<T>)
+        // Ensure Python deletes the C++ component
+        sipAPI()->api_transfer_back(sipObj);
+
       return bpy::incref(sipObj);
     }
 
@@ -481,11 +539,15 @@ struct QClass_converters
         return bpy::incref(Py_None);
       }
 
-      PyObject *sipObj = sipAPI()->api_convert_from_type(object, type, 0);
+      PyObject *sipObj = sipAPI()->api_convert_from_type(getSafeCopy<T>(object), type, 0);
       if (sipObj == nullptr) {
         return bpy::incref(Py_None);
       }
 
+      if (std::is_copy_constructible_v<T>)
+        // Ensure Python deletes the C++ component
+        sipAPI()->api_transfer_back(sipObj);
+
       return bpy::incref(sipObj);
     }
 
@@ -496,12 +558,21 @@ struct QClass_converters
 
   static void *QClass_from_PyQt(PyObject *objPtr)
   {
-    if (!PyObject_TypeCheck(objPtr, sipAPI()->api_wrapper_type)) {
+    if (!PyObject_TypeCheck(objPtr, sipAPI()->api_simplewrapper_type)) {
+      if (std::is_same_v<T, QStringList>)
+      {
+        // QStringLists aren't wrapped by PyQt - regular Python string/unicode lists are used instead
+        bpy::extract<QList<QString>> extractor(objPtr);
+        if (extractor.check())
+          return new QStringList(extractor());
+      }
       PyErr_SetString(PyExc_TypeError, "type not wrapped");
       bpy::throw_error_already_set();
     }
 
-    sipAPI()->api_transfer_to(objPtr, 0);
+    // This would transfer responsibility for deconstructing the object to C++, but Boost assumes l-value converters (such as this) don't do that
+    // Instead, this should be called within the wrappers for functions which return deletable pointers.
+    //sipAPI()->api_transfer_to(objPtr, 0);
 
     sipSimpleWrapper *wrapper = reinterpret_cast<sipSimpleWrapper*>(objPtr);
     return wrapper->data;
@@ -564,7 +635,9 @@ struct QInterface_converters
       bpy::throw_error_already_set();
     }
 
-    sipAPI()->api_transfer_to(objPtr, 0);
+    // This would transfer responsibility for deconstructing the object to C++, but Boost assumes l-value converters (such as this) don't do that
+    // Instead, this should be called within the wrappers for functions which return deletable pointers.
+    //sipAPI()->api_transfer_to(objPtr, 0);
 
     sipSimpleWrapper *wrapper = reinterpret_cast<sipSimpleWrapper*>(objPtr);
     return wrapper->data;
@@ -593,6 +666,7 @@ int getArgCount(PyObject *object) {
   return result;
 }
 
+template <typename RET>
 struct Functor0_converter
 {
 
@@ -601,9 +675,9 @@ struct Functor0_converter
     FunctorWrapper(boost::python::object callable) : m_Callable(callable) {
     }
 
-    void operator()() {
+    RET operator()() {
       GILock lock;
-      m_Callable();
+      return (RET) m_Callable();
     }
 
     boost::python::object m_Callable;
@@ -611,7 +685,7 @@ struct Functor0_converter
 
   Functor0_converter()
   {
-    bpy::converter::registry::push_back(&convertible, &construct, bpy::type_id<std::function<void()>>());
+    bpy::converter::registry::push_back(&convertible, &construct, bpy::type_id<std::function<RET()>>());
   }
 
   static void *convertible(PyObject *object)
@@ -626,14 +700,55 @@ struct Functor0_converter
   static void construct(PyObject *object, bpy::converter::rvalue_from_python_stage1_data *data)
   {
     bpy::object callable(bpy::handle<>(bpy::borrowed(object)));
-    void *storage = ((bpy::converter::rvalue_from_python_storage<std::function<void()>>*)data)->storage.bytes;
-    new (storage) std::function<void()>(FunctorWrapper(callable));
+    void *storage = ((bpy::converter::rvalue_from_python_storage<std::function<RET()>>*)data)->storage.bytes;
+    new (storage) std::function<RET()>(FunctorWrapper(callable));
     data->convertible = storage;
   }
 };
 
 
-template <typename PAR1, typename PAR2>
+template <typename RET, typename PAR1>
+struct Functor1_converter
+{
+
+  struct FunctorWrapper
+  {
+    FunctorWrapper(boost::python::object callable) : m_Callable(callable) {
+    }
+
+    RET operator()(const PAR1 &param1) {
+      GILock lock;
+      return (RET) m_Callable(param1);
+    }
+
+    boost::python::object m_Callable;
+  };
+
+  Functor1_converter()
+  {
+    bpy::converter::registry::push_back(&convertible, &construct, bpy::type_id<std::function<RET(PAR1)>>());
+  }
+
+  static void *convertible(PyObject *object)
+  {
+    if (!PyCallable_Check(object)
+        || (getArgCount(object) != 1)) {
+      return nullptr;
+    }
+    return object;
+  }
+
+  static void construct(PyObject *object, bpy::converter::rvalue_from_python_stage1_data *data)
+  {
+    bpy::object callable(bpy::handle<>(bpy::borrowed(object)));
+    void *storage = ((bpy::converter::rvalue_from_python_storage<std::function<RET(PAR1)>>*)data)->storage.bytes;
+    new (storage) std::function<RET(PAR1)>(FunctorWrapper(callable));
+    data->convertible = storage;
+  }
+};
+
+
+template <typename RET, typename PAR1, typename PAR2>
 struct Functor2_converter
 {
 
@@ -642,9 +757,9 @@ struct Functor2_converter
     FunctorWrapper(boost::python::object callable) : m_Callable(callable) {
     }
 
-    void operator()(const PAR1 &param1, const PAR2 &param2) {
+    RET operator()(const PAR1 &param1, const PAR2 &param2) {
       GILock lock;
-      m_Callable(param1, param2);
+      return (RET) m_Callable(param1, param2);
     }
 
     boost::python::object m_Callable;
@@ -652,7 +767,7 @@ struct Functor2_converter
 
   Functor2_converter()
   {
-    bpy::converter::registry::push_back(&convertible, &construct, bpy::type_id<std::function<void(PAR1, PAR2)>>());
+    bpy::converter::registry::push_back(&convertible, &construct, bpy::type_id<std::function<RET(PAR1, PAR2)>>());
   }
 
   static void *convertible(PyObject *object)
@@ -667,8 +782,8 @@ struct Functor2_converter
   static void construct(PyObject *object, bpy::converter::rvalue_from_python_stage1_data *data)
   {
     bpy::object callable(bpy::handle<>(bpy::borrowed(object)));
-    void *storage = ((bpy::converter::rvalue_from_python_storage<std::function<void(PAR1, PAR2)>>*)data)->storage.bytes;
-    new (storage) std::function<void(PAR1, PAR2)>(FunctorWrapper(callable));
+    void *storage = ((bpy::converter::rvalue_from_python_storage<std::function<RET(PAR1, PAR2)>>*)data)->storage.bytes;
+    new (storage) std::function<RET(PAR1, PAR2)>(FunctorWrapper(callable));
     data->convertible = storage;
   }
 };
@@ -687,9 +802,14 @@ BOOST_PYTHON_MODULE(mobase)
   QString_from_python_str();
 
   //QClass_converters<QObject>();
+  QClass_converters<QDateTime>();
+  QClass_converters<QDir>();
+  QClass_converters<QFileInfo>();
   QClass_converters<QWidget>();
   QClass_converters<QIcon>();
+  QClass_converters<QSize>();
   QClass_converters<QStringList>();
+  QClass_converters<QUrl>();
   QInterface_converters<IDownloadManager>();
 
 
@@ -713,14 +833,6 @@ BOOST_PYTHON_MODULE(mobase)
       .value("literal", MOBase::VersionInfo::SCHEME_LITERAL)
       ;
 
-  bpy::enum_<MOBase::IPluginInstaller::EInstallResult>("InstallResult")
-      .value("success", MOBase::IPluginInstaller::RESULT_SUCCESS)
-      .value("failed", MOBase::IPluginInstaller::RESULT_FAILED)
-      .value("canceled", MOBase::IPluginInstaller::RESULT_CANCELED)
-      .value("manualRequested", MOBase::IPluginInstaller::RESULT_MANUALREQUESTED)
-      .value("notAttempted", MOBase::IPluginInstaller::RESULT_NOTATTEMPTED)
-      ;
-
   bpy::class_<VersionInfo>("VersionInfo")
       .def(bpy::init<QString>())
       .def(bpy::init<QString, VersionInfo::VersionScheme>())
@@ -744,12 +856,42 @@ BOOST_PYTHON_MODULE(mobase)
 
   bpy::class_<PluginSetting>("PluginSetting", bpy::init<const QString&, const QString&, const QVariant&>());
 
+  bpy::class_<ExecutableInfo>("ExecutableInfo", bpy::init<const QString&, const QFileInfo&>())
+      .def("withArgument", &ExecutableInfo::withArgument, bpy::return_value_policy<bpy::reference_existing_object>())
+      .def("withWorkingDirectory", &ExecutableInfo::withWorkingDirectory, bpy::return_value_policy<bpy::reference_existing_object>())
+      .def("withSteamAppId", &ExecutableInfo::withSteamAppId, bpy::return_value_policy<bpy::reference_existing_object>())
+      .def("asCustom", &ExecutableInfo::asCustom, bpy::return_value_policy<bpy::reference_existing_object>())
+      .def("isValid", &ExecutableInfo::isValid)
+      .def("title", &ExecutableInfo::title)
+      .def("binary", &ExecutableInfo::binary)
+      .def("arguments", &ExecutableInfo::arguments)
+      .def("workingDirectory", &ExecutableInfo::workingDirectory)
+      .def("steamAppID", &ExecutableInfo::steamAppID)
+      .def("isCustom", &ExecutableInfo::isCustom)
+      ;
+
+  bpy::class_<ISaveGameWrapper, boost::noncopyable>("ISaveGame")
+      .def("getFilename", bpy::pure_virtual(&ISaveGame::getFilename))
+      .def("getCreationTime", bpy::pure_virtual(&ISaveGame::getCreationTime))
+      .def("getSaveGroupIdentifier", bpy::pure_virtual(&ISaveGame::getSaveGroupIdentifier))
+      .def("allFiles", bpy::pure_virtual(&ISaveGame::allFiles))
+      .def("hasScriptExtenderFile", bpy::pure_virtual(&ISaveGame::hasScriptExtenderFile))
+      ;
+
+  // TODO: ISaveGameInfoWidget bindings
+
+  Functor1_converter<bool, const IOrganizer::FileInfo&>();
+  Functor1_converter<void, const QString&>();
+  Functor1_converter<bool, const QString&>();
+  Functor2_converter<void, const QString&, unsigned int>();
 
   bpy::class_<IOrganizerWrapper, boost::noncopyable>("IOrganizer")
       .def("createNexusBridge", bpy::pure_virtual(&IOrganizer::createNexusBridge), bpy::return_value_policy<bpy::reference_existing_object>())
       .def("profileName", bpy::pure_virtual(&IOrganizer::profileName))
       .def("profilePath", bpy::pure_virtual(&IOrganizer::profilePath))
       .def("downloadsPath", bpy::pure_virtual(&IOrganizer::downloadsPath))
+      .def("overwritePath", bpy::pure_virtual(&IOrganizer::overwritePath))
+      .def("basePath", bpy::pure_virtual(&IOrganizer::basePath))
       .def("appVersion", bpy::pure_virtual(&IOrganizer::appVersion))
       .def("getMod", bpy::pure_virtual(&IOrganizer::getMod), bpy::return_value_policy<bpy::reference_existing_object>())
       .def("createMod", bpy::pure_virtual(&IOrganizer::createMod), bpy::return_value_policy<bpy::reference_existing_object>())
@@ -761,16 +903,21 @@ BOOST_PYTHON_MODULE(mobase)
       .def("setPersistent", bpy::pure_virtual(&IOrganizer::setPersistent))
       .def("pluginDataPath", bpy::pure_virtual(&IOrganizer::pluginDataPath))
       .def("installMod", bpy::pure_virtual(&IOrganizer::installMod),(bpy::arg("nameSuggestion")=""), bpy::return_value_policy<bpy::reference_existing_object>())
+      .def("resolvePath", bpy::pure_virtual(&IOrganizer::resolvePath))
+      .def("listDirectories", bpy::pure_virtual(&IOrganizer::listDirectories))
+      .def("findFiles", bpy::pure_virtual(&IOrganizer::findFiles))
+      .def("getFileOrigins", bpy::pure_virtual(&IOrganizer::getFileOrigins))
+      .def("findFileInfos", bpy::pure_virtual(&IOrganizer::findFileInfos))
       .def("downloadManager", bpy::pure_virtual(&IOrganizer::downloadManager), bpy::return_value_policy<bpy::reference_existing_object>())
       .def("pluginList", bpy::pure_virtual(&IOrganizer::pluginList), bpy::return_value_policy<bpy::reference_existing_object>())
       .def("modList", bpy::pure_virtual(&IOrganizer::modList), bpy::return_value_policy<bpy::reference_existing_object>())
-      .def("startApplication", bpy::pure_virtual(&IOrganizer::startApplication), bpy::return_value_policy<bpy::return_by_value>())
+      .def("profile", bpy::pure_virtual(&IOrganizer::profile), bpy::return_value_policy<bpy::reference_existing_object>())
+      .def("startApplication", bpy::pure_virtual(&IOrganizer::startApplication), ((bpy::arg("args")=QStringList()), (bpy::arg("cwd")=""), (bpy::arg("profile")="")), bpy::return_value_policy<bpy::return_by_value>())
       //.def("waitForApplication", bpy::pure_virtual(&IOrganizer::waitForApplication), (bpy::arg("exitCode")=nullptr), bpy::return_value_policy<bpy::return_by_value>())
+      .def("onModInstalled", bpy::pure_virtual(&IOrganizer::onModInstalled))
       .def("onAboutToRun", bpy::pure_virtual(&IOrganizer::onAboutToRun))
       .def("onFinishedRun", bpy::pure_virtual(&IOrganizer::onFinishedRun))
-      .def("onModInstalled", bpy::pure_virtual(&IOrganizer::onModInstalled))
-      .def("refreshModList", bpy::pure_virtual(&IOrganizer::refreshModList))
-      .def("profile", bpy::pure_virtual(&IOrganizer::profile), bpy::return_value_policy<bpy::reference_existing_object>())
+      .def("refreshModList", bpy::pure_virtual(&IOrganizer::refreshModList), (bpy::arg("saveChanges")=true))
       .def("managedGame", bpy::pure_virtual(&IOrganizer::managedGame), bpy::return_value_policy<bpy::reference_existing_object>())
       .def("modsSortedByProfilePriority", bpy::pure_virtual(&IOrganizer::modsSortedByProfilePriority))
       ;
@@ -803,6 +950,29 @@ BOOST_PYTHON_MODULE(mobase)
       .def("requestToggleEndorsement", bpy::pure_virtual(&IModRepositoryBridge::requestToggleEndorsement))
       ;
 
+  bpy::class_<ModRepositoryFileInfo>("ModRepositoryFileInfo")
+      .def(bpy::init<const ModRepositoryFileInfo &>())
+      .def(bpy::init<bpy::optional<QString, int, int>>())
+      .def("toString", &ModRepositoryFileInfo::toString)
+      .def("createFromJson", &ModRepositoryFileInfo::createFromJson).staticmethod("createFromJson")
+      .def_readwrite("name", &ModRepositoryFileInfo::name)
+      .def_readwrite("uri", &ModRepositoryFileInfo::uri)
+      .def_readwrite("description", &ModRepositoryFileInfo::description)
+      .def_readwrite("version", &ModRepositoryFileInfo::version)
+      .def_readwrite("newestVersion", &ModRepositoryFileInfo::newestVersion)
+      .def_readwrite("categoryID", &ModRepositoryFileInfo::categoryID)
+      .def_readwrite("modName", &ModRepositoryFileInfo::modName)
+      .def_readwrite("gameName", &ModRepositoryFileInfo::gameName)
+      .def_readwrite("modID", &ModRepositoryFileInfo::modID)
+      .def_readwrite("fileID", &ModRepositoryFileInfo::fileID)
+      .def_readwrite("fileSize", &ModRepositoryFileInfo::fileSize)
+      .def_readwrite("fileName", &ModRepositoryFileInfo::fileName)
+      .def_readwrite("fileCategory", &ModRepositoryFileInfo::fileCategory)
+      .def_readwrite("fileTime", &ModRepositoryFileInfo::fileTime)
+      .def_readwrite("repository", &ModRepositoryFileInfo::repository)
+      .def_readwrite("userData", &ModRepositoryFileInfo::userData)
+      ;
+
   bpy::class_<IDownloadManagerWrapper, boost::noncopyable>("IDownloadManager")
       .def("startDownloadURLs", bpy::pure_virtual(&IDownloadManager::startDownloadURLs))
       .def("startDownloadNexusFile", bpy::pure_virtual(&IDownloadManager::startDownloadNexusFile))
@@ -847,19 +1017,9 @@ BOOST_PYTHON_MODULE(mobase)
       .def("variants", &MOBase::GuessedValue<QString>::variants, bpy::return_value_policy<bpy::copy_const_reference>())
       ;
 
-  bpy::class_<IPluginWrapper, boost::noncopyable>("IPlugin");
-
-  bpy::class_<IPluginToolWrapper, bpy::bases<IPlugin>, boost::noncopyable>("IPluginTool")
-      .def("setParentWidget", bpy::pure_virtual(&MOBase::IPluginTool::setParentWidget))
-      ;
-
-  bpy::class_<IPluginInstallerCustomWrapper, boost::noncopyable>("IPluginInstallerCustom")
-      .def("setParentWidget", bpy::pure_virtual(&MOBase::IPluginInstallerCustom::setParentWidget))
-      ;
-
   bpy::to_python_converter<IPluginList::PluginStates, QFlags_to_int<IPluginList::PluginState>>();
   QFlags_from_python_obj<IPluginList::PluginState>();
-  Functor0_converter(); // converter for the onRefreshed-callback
+  Functor0_converter<void>(); // converter for the onRefreshed-callback
 
   bpy::class_<IPluginListWrapper, boost::noncopyable>("IPluginList")
       .def("state", bpy::pure_virtual(&MOBase::IPluginList::state))
@@ -877,7 +1037,7 @@ BOOST_PYTHON_MODULE(mobase)
 
   bpy::to_python_converter<IModList::ModStates, QFlags_to_int<IModList::ModState>>();
   QFlags_from_python_obj<IModList::ModState>();
-  Functor2_converter<const QString&, IModList::ModStates>(); // converter for the onModStateChanged-callback
+  Functor2_converter<void, const QString&, IModList::ModStates>(); // converter for the onModStateChanged-callback
 
   bpy::class_<IModListWrapper, boost::noncopyable>("IModList")
       .def("displayName", bpy::pure_virtual(&MOBase::IModList::displayName))
@@ -890,6 +1050,28 @@ BOOST_PYTHON_MODULE(mobase)
       .def("onModMoved", bpy::pure_virtual(&MOBase::IModList::onModMoved))
       ;
 
+  bpy::class_<IPluginWrapper, boost::noncopyable>("IPlugin");
+
+  bpy::class_<IPluginDiagnoseWrapper, boost::noncopyable>("IPluginDiagnose")
+      .def("activeProblems", bpy::pure_virtual(&MOBase::IPluginDiagnose::activeProblems))
+      .def("shortDescription", bpy::pure_virtual(&MOBase::IPluginDiagnose::shortDescription))
+      .def("fullDescription", bpy::pure_virtual(&MOBase::IPluginDiagnose::fullDescription))
+      .def("hasGuidedFix", bpy::pure_virtual(&MOBase::IPluginDiagnose::hasGuidedFix))
+      .def("startGuidedFix", bpy::pure_virtual(&MOBase::IPluginDiagnose::startGuidedFix))
+      .def("_invalidate", &IPluginDiagnoseWrapper::invalidate)
+      ;
+
+  bpy::class_<Mapping>("Mapping")
+      .def_readwrite("source", &Mapping::source)
+      .def_readwrite("destination", &Mapping::destination)
+      .def_readwrite("isDirectory", &Mapping::isDirectory)
+      .def_readwrite("createTarget", &Mapping::createTarget)
+      ;
+
+  bpy::class_<IPluginFileMapperWrapper, boost::noncopyable>("IPluginFileMapper")
+      .def("mappings", bpy::pure_virtual(&MOBase::IPluginFileMapper::mappings))
+      ;
+
   bpy::enum_<MOBase::IPluginGame::LoadOrderMechanism>("LoadOrderMechanism")
       .value("FileTime", MOBase::IPluginGame::LoadOrderMechanism::FileTime)
       .value("PluginsTxt", MOBase::IPluginGame::LoadOrderMechanism::PluginsTxt)
@@ -954,21 +1136,65 @@ BOOST_PYTHON_MODULE(mobase)
       .def("isActive", bpy::pure_virtual(&MOBase::IPluginGame::isActive))
       .def("settings", bpy::pure_virtual(&MOBase::IPluginGame::settings))
 
+      // The syntax has to differ slightly from C++ because these are templated
+      .def("featureBSAInvalidation", &MOBase::IPluginGame::feature<BSAInvalidation>, bpy::return_value_policy<bpy::reference_existing_object>())
+      .def("featureDataArchives", &MOBase::IPluginGame::feature<DataArchives>, bpy::return_value_policy<bpy::reference_existing_object>())
+      .def("featureGamePlugins", &MOBase::IPluginGame::feature<GamePlugins>, bpy::return_value_policy<bpy::reference_existing_object>())
+      .def("featureLocalSavegames", &MOBase::IPluginGame::feature<LocalSavegames>, bpy::return_value_policy<bpy::reference_existing_object>())
+      .def("featureSaveGameInfo", &MOBase::IPluginGame::feature<SaveGameInfo>, bpy::return_value_policy<bpy::reference_existing_object>())
+      .def("featureScriptExtender", &MOBase::IPluginGame::feature<ScriptExtender>, bpy::return_value_policy<bpy::reference_existing_object>())
+      .def("featureUnmanagedMods", &MOBase::IPluginGame::feature<UnmanagedMods>, bpy::return_value_policy<bpy::reference_existing_object>())
       ;
 
-    bpy::class_<QDir>("QDir")
-      .def("absolutePath", &QDir::absolutePath)
-    ;
+  bpy::enum_<MOBase::IPluginInstaller::EInstallResult>("InstallResult")
+      .value("success", MOBase::IPluginInstaller::RESULT_SUCCESS)
+      .value("failed", MOBase::IPluginInstaller::RESULT_FAILED)
+      .value("canceled", MOBase::IPluginInstaller::RESULT_CANCELED)
+      .value("manualRequested", MOBase::IPluginInstaller::RESULT_MANUALREQUESTED)
+      .value("notAttempted", MOBase::IPluginInstaller::RESULT_NOTATTEMPTED)
+      ;
+
+  bpy::class_<IPluginInstallerCustomWrapper, boost::noncopyable>("IPluginInstallerCustom")
+      .def("setParentWidget", bpy::pure_virtual(&MOBase::IPluginInstallerCustom::setParentWidget))
+      ;
+
+  bpy::class_<IPluginModPageWrapper, boost::noncopyable>("IPluginModPage")
+      .def("setParentWidget", bpy::pure_virtual(&MOBase::IPluginModPage::setParentWidget))
+      ;
+
+  bpy::class_<IPluginPreviewWrapper, boost::noncopyable>("IPluginPreview")
+      ;
+
+  bpy::class_<IPluginToolWrapper, bpy::bases<IPlugin>, boost::noncopyable>("IPluginTool")
+      .def("setParentWidget", bpy::pure_virtual(&MOBase::IPluginTool::setParentWidget))
+      ;
 
   GuessedValue_converters<QString>();
 
-  bpy::to_python_converter<ModRepositoryFileInfo, ModRepositoryFileInfo_to_python_dict>();
+  //bpy::to_python_converter<ModRepositoryFileInfo, ModRepositoryFileInfo_to_python_dict>();
 
+  QList_from_python_obj<ExecutableInfo>();
   QList_from_python_obj<PluginSetting>();
   bpy::to_python_converter<QList<ModRepositoryFileInfo>,
       QList_to_python_list<ModRepositoryFileInfo> >();
+  QList_from_python_obj<QString>();
+  bpy::to_python_converter<QList<QFileInfo>,
+      QList_to_python_list<QFileInfo>>();
+  QList_from_python_obj<QVariant>();
+  bpy::to_python_converter<QList<QVariant>,
+      QList_to_python_list<QVariant>>();
+
+  QMap_converters<QString, QVariant>();
+  QMap_converters<QString, QStringList>();
+
+  std_vector_from_python_obj<unsigned int>();
+  std_vector_from_python_obj<Mapping>();
+  bpy::to_python_converter<std::vector<Mapping>,
+      std_vector_to_python_list<Mapping>>();
 
   stdset_from_python_list<QString>();
+
+  registerGameFeaturesPythonConverters();
 }
 
 
@@ -1082,9 +1308,15 @@ QObject *PythonRunner::instantiate(const QString &pluginName)
     m_PythonObjects[pluginName] = moduleNamespace["createPlugin"]();
 
     bpy::object pluginObj = m_PythonObjects[pluginName];
-    TRY_PLUGIN_TYPE(IPluginInstallerCustom, pluginObj);
-    TRY_PLUGIN_TYPE(IPluginTool, pluginObj);
     TRY_PLUGIN_TYPE(IPluginGame, pluginObj);
+    // Must try the wrapper because it's only a plugin extension interface in C++, so doesn't extend QObject
+    TRY_PLUGIN_TYPE(IPluginDiagnoseWrapper, pluginObj);
+    // Must try the wrapper because it's only a plugin extension interface in C++, so doesn't extend QObject
+    TRY_PLUGIN_TYPE(IPluginFileMapperWrapper, pluginObj);
+    TRY_PLUGIN_TYPE(IPluginInstallerCustom, pluginObj);
+    TRY_PLUGIN_TYPE(IPluginModPage, pluginObj);
+    TRY_PLUGIN_TYPE(IPluginPreview, pluginObj);
+    TRY_PLUGIN_TYPE(IPluginTool, pluginObj);
   } catch (const bpy::error_already_set&) {
     qWarning("failed to run python script \"%s\"", qPrintable(pluginName));
     reportPythonError();
diff --git a/src/runner/sipapiaccess.h b/src/runner/sipapiaccess.h
new file mode 100644
index 0000000..c9c95d0
--- /dev/null
+++ b/src/runner/sipapiaccess.h
@@ -0,0 +1,16 @@
+#ifndef SIPAPIACCESS_H
+#define SIPAPIACCESS_H
+
+#include <sip.h>
+
+static const sipAPIDef *sipAPI()
+{
+  static const sipAPIDef *sipApi = nullptr;
+  if (sipApi == nullptr) {
+    sipApi = (const sipAPIDef *)PyCapsule_Import("sip._C_API", 0);
+  }
+
+  return sipApi;
+}
+
+#endif // SIPAPIACCESS_H
diff --git a/src/runner/uibasewrappers.h b/src/runner/uibasewrappers.h
index 780a506..36f1c0c 100644
--- a/src/runner/uibasewrappers.h
+++ b/src/runner/uibasewrappers.h
@@ -21,8 +21,12 @@
 #include <idownloadmanager.h>
 #include <ipluginlist.h>
 #include <imodlist.h>
+#include <isavegame.h>
+#include <isavegameinfowidget.h>
+
 #include "error.h"
 #include "gilock.h"
+#include "pycatch.h"
 
 extern MOBase::IOrganizer *s_Organizer;
 
@@ -434,53 +438,17 @@ struct IModListWrapper: MOBase::IModList, boost::python::wrapper<MOBase::IModLis
 };
 
 
-struct IPluginGameWrapper: MOBase::IPluginGame, boost::python::wrapper<MOBase::IPluginGame> {
-  virtual QString gameName() const override { return this->get_override("gameName")(); }
-  virtual void initializeProfile(const QDir &directory, ProfileSettings settings) const override {
-    this->get_override("initializeProfile")(directory, settings);
-  }
-  virtual QString savegameExtension() const override { return this->get_override("savegameExtension")(); }
-  virtual QString savegameSEExtension() const override { return this->get_override("savegameSEExtension")(); }
-  virtual bool isInstalled() const override { return this->get_override("isInstalled")(); }
-  virtual QIcon gameIcon() const override { return this->get_override("gameIcon")(); }
-  virtual QDir gameDirectory() const override { return this->get_override("gameDirectory")(); }
-  virtual QDir dataDirectory() const override { return this->get_override("dataDirectory")(); }
-  virtual void setGamePath(const QString &path) override { this->get_override("setGamePath")(path); }
-  virtual QDir documentsDirectory() const override { return this->get_override("documentsDirectory")(); }
-  virtual QDir savesDirectory() const override { return this->get_override("savesDirectory")(); }
-  virtual QList<MOBase::ExecutableInfo> executables() const override { return this->get_override("executables")(); }
-  virtual QString steamAPPId() const override { return this->get_override("steamAPPId")(); }
-  virtual QStringList primaryPlugins() const override { return this->get_override("primaryPlugins")(); }
-  virtual QStringList gameVariants() const override { return this->get_override("gameVariants")(); }
-  virtual void setGameVariant(const QString &variant) override { this->get_override("setGameVariant")(variant); }
-  virtual QString binaryName() const override { return this->get_override("binaryName")(); }
-  virtual QString gameShortName() const override { return this->get_override("gameShortName")(); }
-  virtual QStringList validShortNames() const override { return this->get_override("validShortNames")(); }
-  virtual QString gameNexusName() const override { return this->get_override("gameNexusName")(); }
-  virtual QStringList iniFiles() const override { return this->get_override("iniFiles")(); }
-  virtual QStringList DLCPlugins() const override { return this->get_override("DLCPlugins")(); }
-  virtual QStringList CCPlugins() const override { return this->get_override("CCPlugins")(); }
-  virtual LoadOrderMechanism loadOrderMechanism() const override { return this->get_override("loadorderMechanism")(); }
-  virtual SortMechanism sortMechanism() const override { return this->get_override("sortMechanism")(); }
-  virtual int nexusModOrganizerID() const override { return this->get_override("nexusModOrganizerID")(); }
-  virtual int nexusGameID() const override { return this->get_override("nexusGameID")(); }
-  virtual bool looksValid(QDir const &dir) const override { return this->get_override("looksValid")(dir); }
-  virtual QString gameVersion() const override { return this->get_override("gameVersion")(); }
-  virtual QString getLauncherName() const override { return this->get_override("getLauncherName")(); }
-
-  //Plugin interface. Could this bit be implemented just once?
-  virtual bool init(MOBase::IOrganizer *moInfo) override { return this->get_override("init")(moInfo); }
-  virtual QString name() const override { return this->get_override("name")(); }
-  virtual QString author() const override { return this->get_override("author")(); }
-  virtual QString description() const override { return this->get_override("description")(); }
-  virtual MOBase::VersionInfo version() const override { return this->get_override("version")(); }
-  virtual bool isActive() const override { return this->get_override("isActive")(); }
-  virtual QList<MOBase::PluginSetting> settings() const override { return this->get_override("settings")(); }
-
-protected:
-
-  virtual std::map<std::type_index, boost::any> featureList() const override { return this->get_override("featureList")(); }
-
+// This needs to be extendable in Python, so actually needs a wrapper
+// Everything else probably doesn't
+class ISaveGameWrapper : public MOBase::ISaveGame, public boost::python::wrapper<MOBase::ISaveGame>
+{
+public:
+  virtual QString getFilename() const override { try { return this->get_override("getFilename")(); } PYCATCH };
+  virtual QDateTime getCreationTime() const override { try { return this->get_override("getCreationTime")(); } PYCATCH };
+  virtual QString getSaveGroupIdentifier() const override { try { return this->get_override("getSaveGroupIdentifier")(); } PYCATCH };
+  virtual QStringList allFiles() const override { try { return this->get_override("allFiles")(); } PYCATCH };
+  virtual bool hasScriptExtenderFile() const override { try { return this->get_override("hasScriptExtenderFile")(); } PYCATCH };
 };
 
+
 #endif // UIBASEWRAPPERS_H