diff --git a/plugins/extensions/pykrita/plugin/engine.cpp b/plugins/extensions/pykrita/plugin/engine.cpp
index 1f53fba318..92ec3cda85 100644
--- a/plugins/extensions/pykrita/plugin/engine.cpp
+++ b/plugins/extensions/pykrita/plugin/engine.cpp
@@ -1,793 +1,799 @@
 // This file is part of PyKrita, Krita' Python scripting plugin.
 //
 // Copyright (C) 2006 Paul Giannaros <paul@giannaros.org>
 // Copyright (C) 2012, 2013 Shaheed Haque <srhaque@theiet.org>
 // Copyright (C) 2013 Alex Turbov <i.zaufi@gmail.com>
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Lesser General Public
 // License as published by the Free Software Foundation; either
 // version 2.1 of the License, or (at your option) version 3, or any
 // later version accepted by the membership of KDE e.V. (or its
 // successor approved by the membership of KDE e.V.), which shall
 // act as a proxy defined in Section 6 of version 3 of the license.
 //
 // This library is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 // Lesser General Public License for more details.
 //
 // You should have received a copy of the GNU Lesser General Public
 // License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 //
 
 #include "engine.h"
 
 // config.h defines PYKRITA_PYTHON_LIBRARY, the path to libpython.so
 // on the build system
 
 #include "config.h"
 #include "utilities.h"
 
 #include <cmath>
 #include <Python.h>
 
 #include <QSettings>
 #include <QLibrary>
 #include <QFileInfo>
 
 #include <kconfig.h>
 #include <klocalizedstring.h>
 #include <kcolorscheme.h>
 
 //#include <KoServiceLocator.h>
 #include <KoResourcePaths.h>
 
 #include <kis_debug.h>
 
 /// Name of the file where per-plugin configuration is stored.
 #define CONFIG_FILE "kritapykritarc"
 
 #if PY_MAJOR_VERSION < 3
 # define PYKRITA_INIT initpykrita
 #else
 # define PYKRITA_INIT PyInit_pykrita
 #endif
 
 PyMODINIT_FUNC PYKRITA_INIT();                                 // fwd decl
 
 /// \note Namespace name written in uppercase intentionally!
 /// It will appear in debug output from Python plugins...
 namespace PYKRITA
 {
 PyObject* debug(PyObject* /*self*/, PyObject* args)
 {
     const char* text;
 
     if (PyArg_ParseTuple(args, "s", &text))
         dbgScript << text;
     Py_INCREF(Py_None);
     return Py_None;
 }
 }                                                           // namespace PYKRITA
 
 namespace
 {
 PyObject* s_pykrita;
 /**
  * \attention Krita has embedded Python, so init function \b never will be called
  * automatically! We can use this fact to initialize a pointer to an instance
  * of the \c Engine class (which is a part of the \c Plugin), so exported
  * functions will know it (yep, from Python's side they should be static).
  */
 PyKrita::Engine* s_engine_instance = 0;
 
 /**
  * Wrapper function, called explicitly from \c Engine::Engine
  * to initialize pointer to the only (by design) instance of the engine,
  * so exported (to Python) functions get know it... Then invoke
  * a real initialization sequence...
  */
 void pythonInitwrapper(PyKrita::Engine* const engine)
 {
     Q_ASSERT("Sanity check" && !s_engine_instance);
     s_engine_instance = engine;
     // Call initialize explicitly to initialize embedded interpreter.
     PYKRITA_INIT();
 }
 
 /**
  * Functions for the Python module called pykrita.
  * \todo Does it \b REALLY needed? Configuration data will be flushed
  * on exit anyway! Why to write it (and even allow to plugins to call this)
  * \b before krita really going to exit? It would be better to \b deprecate
  * this (harmful) function!
  */
 PyObject* pykritaSaveConfiguration(PyObject* /*self*/, PyObject* /*unused*/)
 {
     if (s_engine_instance)
         s_engine_instance->saveGlobalPluginsConfiguration();
     Py_INCREF(Py_None);
     return Py_None;
 }
 
 PyMethodDef pykritaMethods[] = {
     {
         "saveConfiguration"
         , &pykritaSaveConfiguration
         , METH_NOARGS
         , "Save the configuration of the plugin into " CONFIG_FILE
     }
     , {
         "qDebug"
         , &PYKRITA::debug
         , METH_VARARGS
         , "True KDE way to show debug info"
     }
     , { 0, 0, 0, 0 }
 };
 
 }                                                           // anonymous namespace
 
 //BEGIN Python module registration
 PyMODINIT_FUNC PYKRITA_INIT()
 {
 #if PY_MAJOR_VERSION < 3
     s_pykrita = Py_InitModule3("pykrita", pykritaMethods, "The pykrita module");
     PyModule_AddStringConstant(s_pykrita, "__file__", __FILE__);
 #else
     static struct PyModuleDef moduledef = {
         PyModuleDef_HEAD_INIT
         , "pykrita"
         , "The pykrita module"
         , -1
         , pykritaMethods
         , 0
         , 0
         , 0
         , 0
     };
     s_pykrita = PyModule_Create(&moduledef);
     PyModule_AddStringConstant(s_pykrita, "__file__", __FILE__);
     return s_pykrita;
 #endif
 }
 //END Python module registration
 
 
 //BEGIN PyKrita::Engine::PluginState
 PyKrita::Engine::PluginState::PluginState()
     : m_enabled(false)
     , m_broken(false)
     , m_unstable(false)
     , m_isDir(false)
 {
 }
 //END PyKrita::Engine::PluginState
 
 
 /**
  * Just initialize some members. The second (most important) part
  * is to call \c Engine::tryInitializeGetFailureReason()!
  * W/o that call instance is invalid and using it lead to UB!
  */
 PyKrita::Engine::Engine()
     : m_configuration(0)
     , m_sessionConfiguration(0)
     , m_engineIsUsable(false)
 {
 }
 
 /// \todo More accurate shutdown required:
 /// need to keep track what exactly was broken on
 /// initialize attempt...
 PyKrita::Engine::~Engine()
 {
     dbgScript << "Going to destroy the Python engine";
 
     // Notify Python that engine going to die
     {
         Python py = Python();
         py.functionCall("_pykritaUnloading");
     }
     unloadAllModules();
 
     // Clean internal configuration dicts
     // NOTE Do not need to save anything! It's already done!
     if (m_configuration) {
         Py_DECREF(m_configuration);
     }
     if (m_sessionConfiguration) {
         Py_DECREF(m_sessionConfiguration);
     }
 
+    Python::maybeFinalize();
+    Python::libraryUnload();
     s_engine_instance = 0;
 }
 
 void PyKrita::Engine::unloadAllModules()
 {
     // Unload all modules
     for (int i = 0; i < m_plugins.size(); ++i) {
         if (m_plugins[i].isEnabled() && !m_plugins[i].isBroken()) {
             unloadModule(i);
         }
     }
 }
 
 /**
  * \todo Make sure noone tries to use uninitialized engine!
  * (Or enable exceptions for this module, so this case wouldn't even araise?)
  */
 QString PyKrita::Engine::tryInitializeGetFailureReason()
 {
     dbgScript << "Construct the Python engine for Python" << PY_MAJOR_VERSION << "," << PY_MINOR_VERSION;
 
+    if (!Python::libraryLoad()) {
+        return i18nc("@info:tooltip ", "Cannot load Python library");
+    }
+
     // Update PYTHONPATH
     // 0) custom plugin directories (prefer local dir over systems')
     // 1) shipped krita module's dir
     QStringList pluginDirectories = KoResourcePaths::findDirs("pythonscripts");
     dbgScript << "Plugin Directories: " << pluginDirectories;
     if (!Python::setPath(pluginDirectories)) {
         return i18nc("@info:tooltip ", "Cannot set Python paths");
     }
 
     if (0 != PyImport_AppendInittab(Python::PYKRITA_ENGINE, PYKRITA_INIT)) {
         return i18nc("@info:tooltip ", "Cannot load built-in <icode>pykrita</icode> module");
     }
 
     Python::ensureInitialized();
     Python py = Python();
 
     PyRun_SimpleString(
         "import sip\n"
         "sip.setapi('QDate', 2)\n"
         "sip.setapi('QTime', 2)\n"
         "sip.setapi('QDateTime', 2)\n"
         "sip.setapi('QUrl', 2)\n"
         "sip.setapi('QTextStream', 2)\n"
         "sip.setapi('QString', 2)\n"
         "sip.setapi('QVariant', 2)\n"
     );
 
     // Initialize our built-in module.
     pythonInitwrapper(this);
     if (!s_pykrita) {
         return i18nc("@info:tooltip ", "No <icode>pykrita</icode> built-in module");
     }
 
     // Setup global configuration
     m_configuration = PyDict_New();
     /// \todo Check \c m_configuration ?
     // Host the configuration dictionary.
     py.itemStringSet("configuration", m_configuration);
 
     // Setup per session configuration
     m_sessionConfiguration = PyDict_New();
     py.itemStringSet("sessionConfiguration", m_sessionConfiguration);
 
     // Initialize 'plugins' dict of module 'pykrita'
     PyObject* plugins = PyDict_New();
     py.itemStringSet("plugins", plugins);
 
     // Get plugins available
     scanPlugins();
 
     // NOTE Empty failure reson string indicates success!
     m_engineIsUsable = true;
     return QString();
 }
 
 int PyKrita::Engine::columnCount(const QModelIndex&) const
 {
     return Column::LAST__;
 }
 
 int PyKrita::Engine::rowCount(const QModelIndex&) const
 {
     return m_plugins.size();
 }
 
 QModelIndex PyKrita::Engine::index(const int row, const int column, const QModelIndex& parent) const
 {
     if (!parent.isValid() && row < m_plugins.size() && column < Column::LAST__)
         return createIndex(row, column);
     return QModelIndex();
 }
 
 QModelIndex PyKrita::Engine::parent(const QModelIndex&) const
 {
     return QModelIndex();
 }
 
 QVariant PyKrita::Engine::headerData(
     const int section
     , const Qt::Orientation orientation
     , const int role
 ) const
 {
     if (role == Qt::DisplayRole && orientation == Qt::Horizontal) {
         switch (section) {
         case Column::NAME:
             return i18nc("@title:column", "Name");
         case Column::COMMENT:
             return i18nc("@title:column", "Comment");
         default:
             break;
         }
     }
     return QVariant();
 }
 
 QVariant PyKrita::Engine::data(const QModelIndex& index, const int role) const
 {
     Q_ASSERT("Sanity check" && index.row() < m_plugins.size());
     Q_ASSERT("Sanity check" && index.column() < Column::LAST__);
     switch (role) {
     case Qt::DisplayRole:
         switch (index.column()) {
         case Column::NAME:
             return m_plugins[index.row()].m_pythonPlugin.name();
         case Column::COMMENT:
             return m_plugins[index.row()].m_pythonPlugin.comment();
         default:
             break;
         }
         break;
     case Qt::CheckStateRole: {
         if (index.column() == Column::NAME) {
             const bool checked = m_plugins[index.row()].isEnabled();
             return checked ? Qt::Checked : Qt::Unchecked;
         }
         break;
     }
     case Qt::ToolTipRole:
         if (!m_plugins[index.row()].m_errorReason.isEmpty())
             return m_plugins[index.row()].m_errorReason;
         break;
     case Qt::ForegroundRole:
         if (m_plugins[index.row()].isUnstable()) {
             KColorScheme scheme(QPalette::Inactive, KColorScheme::View);
             return scheme.foreground(KColorScheme::NegativeText).color();
         }
     default:
         break;
     }
     return QVariant();
 }
 
 Qt::ItemFlags PyKrita::Engine::flags(const QModelIndex& index) const
 {
     Q_ASSERT("Sanity check" && index.row() < m_plugins.size());
     Q_ASSERT("Sanity check" && index.column() < Column::LAST__);
 
     int result = Qt::ItemIsSelectable;
     if (index.column() == Column::NAME)
         result |= Qt::ItemIsUserCheckable;
     // Disable to select/check broken modules
     if (!m_plugins[index.row()].isBroken())
         result |= Qt::ItemIsEnabled;
     return static_cast<Qt::ItemFlag>(result);
 }
 
 bool PyKrita::Engine::setData(const QModelIndex& index, const QVariant& value, const int role)
 {
     Q_ASSERT("Sanity check" && index.row() < m_plugins.size());
 
     if (role == Qt::CheckStateRole) {
         Q_ASSERT("Sanity check" && !m_plugins[index.row()].isBroken());
 
         const bool enabled = value.toBool();
         m_plugins[index.row()].m_enabled = enabled;
         if (enabled)
             loadModule(index.row());
         else
             unloadModule(index.row());
     }
     return true;
 }
 
 QStringList PyKrita::Engine::enabledPlugins() const
 {
     /// \todo \c std::transform + lambda or even better to use
     /// filtered and transformed view from boost
     QStringList result;
     Q_FOREACH(const PluginState & plugin, m_plugins)
     if (plugin.isEnabled()) {
         result.append(plugin.m_pythonPlugin.name());
     }
     return result;
 }
 
 void PyKrita::Engine::readGlobalPluginsConfiguration()
 {
     Python py = Python();
     PyDict_Clear(m_configuration);
     KConfig config(CONFIG_FILE, KConfig::SimpleConfig);
     config.sync();
     py.updateDictionaryFromConfiguration(m_configuration, &config);
 }
 
 void PyKrita::Engine::saveGlobalPluginsConfiguration()
 {
     Python py = Python();
     KConfig config(CONFIG_FILE, KConfig::SimpleConfig);
     py.updateConfigurationFromDictionary(&config, m_configuration);
     config.sync();
 }
 
 bool PyKrita::Engine::isPythonPluginUsable(const PyPlugin *pythonPlugin)
 {
     dbgScript << "Got Krita/PythonPlugin: " << pythonPlugin->name()
               << ", module-path=" << pythonPlugin->library()
               ;
     // Make sure mandatory properties are here
     if (pythonPlugin->name().isEmpty()) {
         dbgScript << "Ignore desktop file w/o a name";
         return false;
     }
     if (pythonPlugin->library().isEmpty()) {
         dbgScript << "Ignore desktop file w/o a module to import";
         return false;
     }
     return true;
 }
 
 bool PyKrita::Engine::setModuleProperties(PluginState& plugin)
 {
     // Find the module:
     // 0) try to locate directory based plugin first
     QString rel_path = plugin.moduleFilePathPart();
     rel_path = rel_path + "/" + "__init__.py";
     dbgScript << "Finding Pyrhon module with rel_path:" << rel_path;
 
     QString module_path = KoResourcePaths::findResource("pythonscripts", rel_path);
 
     dbgScript << "module_path:" << module_path;
 
     if (module_path.isEmpty()) {
         // 1) Nothing found, then try file based plugin
         rel_path = plugin.moduleFilePathPart() + ".py";
         dbgScript << "Finding Pyrhon module with rel_path:" << rel_path;
         module_path = KoResourcePaths::findResource("pythonscripts", rel_path);
         dbgScript << "module_path:" << module_path;
     } else {
         plugin.m_isDir = true;
     }
 
     // Is anything found at all?
     if (module_path.isEmpty()) {
         plugin.m_broken = true;
         plugin.m_errorReason = i18nc(
                                    "@info:tooltip"
                                    , "Unable to find the module specified <application>%1</application>"
                                    , plugin.m_pythonPlugin.library()
                                );
         dbgScript << "Cannot load module:" << plugin.m_errorReason;
         return false;
     }
     dbgScript << "Found module path:" << module_path;
     return true;
 }
 
 QPair<QString, PyKrita::version_checker> PyKrita::Engine::parseDependency(const QString& d)
 {
     // Check if dependency has package info attached
     const int pnfo = d.indexOf('(');
     if (pnfo != -1) {
         QString dependency = d.mid(0, pnfo);
         QString version_str = d.mid(pnfo + 1, d.size() - pnfo - 2).trimmed();
         dbgScript << "Desired version spec [" << dependency << "]:" << version_str;
         version_checker checker = version_checker::fromString(version_str);
         if (!(checker.isValid() && d.endsWith(')'))) {
             dbgScript << "Invalid version spec " << d;
             QString reason = i18nc(
                                  "@info:tooltip"
                                  , "<p>Specified version has invalid format for dependency <application>%1</application>: "
                                  "<icode>%2</icode>. Skipped</p>"
                                  , dependency
                                  , version_str
                              );
             return qMakePair(reason, version_checker());
         }
         return qMakePair(dependency, checker);
     }
     return qMakePair(d, version_checker(version_checker::undefined));
 }
 
 PyKrita::version PyKrita::Engine::tryObtainVersionFromTuple(PyObject* version_obj)
 {
     Q_ASSERT("Sanity check" && version_obj);
 
     if (PyTuple_Check(version_obj) == 0)
         return version::invalid();
 
     int version_info[3] = {0, 0, 0};
     for (unsigned i = 0; i < PyTuple_Size(version_obj); ++i) {
         PyObject* v = PyTuple_GetItem(version_obj, i);
         if (v && PyLong_Check(v))
             version_info[i] = PyLong_AsLong(v);
         else
             version_info[i] = -1;
     }
     if (version_info[0] != -1 && version_info[1] != -1 && version_info[2] != -1)
         return version(version_info[0], version_info[1], version_info[2]);
 
     return version::invalid();
 }
 
 /**
  * Try to parse version string as a simple triplet X.Y.Z.
  *
  * \todo Some modules has letters in a version string...
  * For example current \c pytz version is \e "2013d".
  */
 PyKrita::version PyKrita::Engine::tryObtainVersionFromString(PyObject* version_obj)
 {
     Q_ASSERT("Sanity check" && version_obj);
 
     if (!Python::isUnicode(version_obj))
         return version::invalid();
 
     QString version_str = Python::unicode(version_obj);
     if (version_str.isEmpty())
         return version::invalid();
 
     return version::fromString(version_str);
 }
 
 /**
  * Collect dependencies and check them. To do it
  * just try to import a module... when unload it ;)
  *
  * \c X-Python-Dependencies property of \c .desktop file has the following format:
  * <tt>python-module(version-info)</tt>, where <tt>python-module</tt>
  * a python module name to be imported, <tt>version-spec</tt>
  * is a version triplet delimited by dots, possible w/ leading compare
  * operator: \c =, \c <, \c >, \c <=, \c >=
  */
 void PyKrita::Engine::verifyDependenciesSetStatus(PluginState& plugin)
 {
     QStringList dependencies = plugin.m_pythonPlugin.property("X-Python-Dependencies").toStringList();
 #if PY_MAJOR_VERSION < 3
     {
         // Try to get Py2 only dependencies
         QStringList py2_dependencies = plugin.m_service->property("X-Python-2-Dependencies").toStringList();
         dependencies.append(py2_dependencies);
     }
 #endif
 
     Python py = Python();
     QString reason = i18nc("@info:tooltip", "<title>Dependency check</title>");
     Q_FOREACH(const QString & d, dependencies) {
         QPair<QString, version_checker> info_pair = parseDependency(d);
         version_checker& checker = info_pair.second;
         if (!checker.isValid()) {
             plugin.m_broken = true;
             reason += info_pair.first;
             continue;
         }
 
         dbgScript << "Try to import dependency module/package:" << d;
 
         // Try to import a module
         const QString& dependency = info_pair.first;
         PyObject* module = py.moduleImport(PQ(dependency));
         if (module) {
             if (checker.isEmpty()) {                        // Need to check smth?
                 dbgScript << "No version to check, just make sure it's loaded:" << dependency;
                 Py_DECREF(module);
                 continue;
             }
             // Try to get __version__ from module
             // See PEP396: http://www.python.org/dev/peps/pep-0396/
             PyObject* version_obj = py.itemString("__version__", PQ(dependency));
             if (!version_obj) {
                 dbgScript << "No __version__ for " << dependency
                           << "[" << plugin.m_pythonPlugin.name() << "]:\n" << py.lastTraceback()
                           ;
                 plugin.m_unstable = true;
                 reason += i18nc(
                               "@info:tooltip"
                               , "<p>Failed to check version of dependency <application>%1</application>: "
                               "Module do not have PEP396 <code>__version__</code> attribute. "
                               "It is not disabled, but behaviour is unpredictable...</p>"
                               , dependency
                           );
             }
             // PEP396 require __version__ to tuple of integers... try it!
             version dep_version = tryObtainVersionFromTuple(version_obj);
             if (!dep_version.isValid())
                 // Second attempt: some "bad" modules have it as a string
                 dep_version = tryObtainVersionFromString(version_obj);
 
             // Did we get it?
             if (!dep_version.isValid()) {
                 // Dunno what is this... Giving up!
                 dbgScript << "***: Can't parse module version for" << dependency;
                 plugin.m_unstable = true;
                 reason += i18nc(
                               "@info:tooltip"
                               , "<p><application>%1</application>: Unexpected module's version format"
                               , dependency
                           );
             } else if (!checker(dep_version)) {
                 dbgScript << "Version requirement check failed ["
                           << plugin.m_pythonPlugin.name() << "] for "
                           << dependency << ": wanted " << checker.operationToString()
                           << QString(checker.required())
                           << ", but found" << QString(dep_version)
                           ;
                 plugin.m_broken = true;
                 reason += i18nc(
                               "@info:tooltip"
                               , "<p><application>%1</application>: No suitable version found. "
                               "Required version %2 %3, but found %4</p>"
                               , dependency
                               , checker.operationToString()
                               , QString(checker.required())
                               , QString(dep_version)
                           );
             }
             // Do not need this module anymore...
             Py_DECREF(module);
         } else {
             dbgScript << "Load failure [" << plugin.m_pythonPlugin.name() << "]:\n" << py.lastTraceback();
             plugin.m_broken = true;
             reason += i18nc(
                           "@info:tooltip"
                           , "<p>Failure on module load <application>%1</application>:</p><pre>%2</pre>"
                           , dependency
                           , py.lastTraceback()
                       );
         }
     }
 
     if (plugin.isBroken() || plugin.isUnstable()) {
         plugin.m_errorReason = reason;
     }
 }
 
 void PyKrita::Engine::scanPlugins()
 {
     m_plugins.clear(); // Clear current state.
 
     QStringList desktopFiles = KoResourcePaths::findAllResources("data", "pykrita/*desktop");
     qDebug() << desktopFiles;
 
     Q_FOREACH(const QString &desktopFile, desktopFiles) {
 
         QSettings s(desktopFile, QSettings::IniFormat);
         s.beginGroup("Desktop Entry");
         if (s.value("ServiceTypes").toString() == "Krita/PythonPlugin") {
             PyPlugin pyplugin;
             pyplugin.m_comment = s.value("Comment").toString();
             pyplugin.m_name = s.value("Name").toString();
             pyplugin.m_libraryPath = s.value("X-KDE-Library").toString();
             pyplugin.m_properties["X-Python-2-Compatible"] = s.value("X-Python-2-Compatible", false).toBool();
 
             if (!isPythonPluginUsable(&pyplugin)) {
                 dbgScript << pyplugin.name() << "is not usable";
                 continue;
             }
 
             PluginState pluginState;
             pluginState.m_pythonPlugin = pyplugin;
 
             if (!setModuleProperties(pluginState)) {
                 dbgScript << "Cannot load" << pyplugin.name() << ": broken"
                           << pluginState.isBroken()
                           << "because:" << pluginState.errorReason();
                 continue;
             }
 
             verifyDependenciesSetStatus(pluginState);
             m_plugins.append(pluginState);
         }
     }
 }
 
 void PyKrita::Engine::setEnabledPlugins(const QStringList& enabled_plugins)
 {
     for (int i = 0; i < m_plugins.size(); ++i) {
         m_plugins[i].m_enabled = enabled_plugins.indexOf(m_plugins[i].m_pythonPlugin.name()) != -1;
     }
 }
 
 void PyKrita::Engine::tryLoadEnabledPlugins()
 {
     for (int i = 0; i < m_plugins.size(); ++i) {
         dbgScript << "Trying to load plugin" << m_plugins[i].pythonModuleName()
                   << ". Enabled:" << m_plugins[i].isEnabled()
                   << ". Broken: " << m_plugins[i].isBroken();
         if (!m_plugins[i].isBroken()) {
             m_plugins[i].m_enabled = true;
             loadModule(i);
         }
     }
 }
 
 void PyKrita::Engine::loadModule(const int idx)
 {
     Q_ASSERT("Plugin index is out of range!" && 0 <= idx && idx < m_plugins.size());
     PluginState& plugin = m_plugins[idx];
     Q_ASSERT(
         "Why to call loadModule() for disabled/broken plugin?"
         && plugin.isEnabled()
         && !plugin.isBroken()
     );
 
     QString module_name = plugin.pythonModuleName();
     dbgScript << "Loading module: " << module_name;
 
     Python py = Python();
 
     // Get 'plugins' key from 'pykrita' module dictionary.
     // Every entry has a module name as a key and 2 elements tuple as a value
     PyObject* plugins = py.itemString("plugins");
     Q_ASSERT(
         "'plugins' dict expected to be alive, otherwise code review required!"
         && plugins
     );
 
     PyObject* module = py.moduleImport(PQ(module_name));
     if (module) {
         // Move just loaded module to the dict
         const int ins_result = PyDict_SetItemString(plugins, PQ(module_name), module);
         Q_ASSERT("expected successful insertion" && ins_result == 0);
         Py_DECREF(module);
         // Handle failure in release mode.
         if (ins_result == 0) {
             // Initialize the module from Python's side
             PyObject* const args = Py_BuildValue("(s)", PQ(module_name));
             PyObject* result = py.functionCall("_pluginLoaded", Python::PYKRITA_ENGINE, args);
             Py_DECREF(args);
             if (result) {
                 dbgScript << "\t" << "success!";
                 return;
             }
         }
         plugin.m_errorReason = i18nc("@info:tooltip", "Internal engine failure");
     } else {
         plugin.m_errorReason = i18nc(
                                    "@info:tooltip"
                                    , "Module not loaded:<nl/>%1"
                                    , py.lastTraceback()
                                );
     }
     plugin.m_broken = true;
     warnScript << "Error loading plugin" << module_name;
 }
 
 void PyKrita::Engine::unloadModule(int idx)
 {
     Q_ASSERT("Plugin index is out of range!" && 0 <= idx && idx < m_plugins.size());
     PluginState& plugin = m_plugins[idx];
     Q_ASSERT("Why to call unloadModule() for broken plugin?" && !plugin.isBroken());
 
     dbgScript << "Unloading module: " << plugin.pythonModuleName();
 
     Python py = Python();
 
     // Get 'plugins' key from 'pykrita' module dictionary
     PyObject* plugins = py.itemString("plugins");
     Q_ASSERT(
         "'plugins' dict expected to be alive, otherwise code review required!"
         && plugins
     );
 
     PyObject* const args = Py_BuildValue("(s)", PQ(plugin.pythonModuleName()));
     py.functionCall("_pluginUnloading", Python::PYKRITA_ENGINE, args);
     Py_DECREF(args);
 
     // This will just decrement a reference count for module instance
     PyDict_DelItemString(plugins, PQ(plugin.pythonModuleName()));
 
     // Remove the module also from 'sys.modules' dict to really unload it,
     // so if reloaded all @init actions will work again!
     PyObject* sys_modules = py.itemString("modules", "sys");
     Q_ASSERT("Sanity check" && sys_modules);
     PyDict_DelItemString(sys_modules, PQ(plugin.pythonModuleName()));
 }
 
 // krita: space-indent on; indent-width 4;
 #undef PYKRITA_INIT
diff --git a/plugins/extensions/pykrita/plugin/utilities.cpp b/plugins/extensions/pykrita/plugin/utilities.cpp
index d4ecb38410..d941604824 100644
--- a/plugins/extensions/pykrita/plugin/utilities.cpp
+++ b/plugins/extensions/pykrita/plugin/utilities.cpp
@@ -1,556 +1,607 @@
 // This file is part of PyKrita, Krita' Python scripting plugin.
 //
 // Copyright (C) 2006 Paul Giannaros <paul@giannaros.org>
 // Copyright (C) 2012, 2013 Shaheed Haque <srhaque@theiet.org>
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Lesser General Public
 // License as published by the Free Software Foundation; either
 // version 2.1 of the License, or (at your option) version 3, or any
 // later version accepted by the membership of KDE e.V. (or its
 // successor approved by the membership of KDE e.V.), which shall
 // act as a proxy defined in Section 6 of version 3 of the license.
 //
 // This library is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 // Lesser General Public License for more details.
 //
 // You should have received a copy of the GNU Lesser General Public
 // License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 //
 
 // config.h defines PYKRITA_PYTHON_LIBRARY, the path to libpython.so
 // on the build system
 
 #include "config.h"
 #include "utilities.h"
 
 #include <algorithm>
 
 #include <cmath>
 #include <Python.h>
 
 
 #include <QDir>
 #include <QLibrary>
 #include <QString>
 #include <QStringList>
 #include <QVector>
 
 #include <kconfigbase.h>
 #include <kconfiggroup.h>
 #include <klocalizedstring.h>
 #include <KoResourcePaths.h>
 
 #include <kis_debug.h>
 
 #define THREADED 1
 
 namespace PyKrita
 {
 namespace
 {
+#ifndef Q_OS_WIN
+QLibrary* s_pythonLibrary = 0;
+#endif
 PyThreadState* s_pythonThreadState = 0;
 }                                                           // anonymous namespace
 
 const char* Python::PYKRITA_ENGINE = "pykrita";
 
 Python::Python()
 {
 #if THREADED
     m_state = PyGILState_Ensure();
 #endif
 }
 
 Python::~Python()
 {
 #if THREADED
     PyGILState_Release(m_state);
 #endif
 }
 
 bool Python::prependStringToList(PyObject* const list, const QString& value)
 {
     PyObject* const u = unicode(value);
     bool result = !PyList_Insert(list, 0, u);
     Py_DECREF(u);
     if (!result)
         traceback(QString("Failed to prepend %1").arg(value));
     return result;
 }
 
 bool Python::functionCall(const char* const functionName, const char* const moduleName)
 {
     PyObject* const result = functionCall(functionName, moduleName, PyTuple_New(0));
     if (result)
         Py_DECREF(result);
     return bool(result);
 }
 
 PyObject* Python::functionCall(
     const char* const functionName
     , const char* const moduleName
     , PyObject* const arguments
 )
 {
     if (!arguments) {
         errScript << "Missing arguments for" << moduleName << functionName;
         return 0;
     }
     PyObject* const func = itemString(functionName, moduleName);
     if (!func) {
         errScript << "Failed to resolve" << moduleName << functionName;
         return 0;
     }
     if (!PyCallable_Check(func)) {
         traceback(QString("Not callable %1.%2").arg(moduleName).arg(functionName));
         return 0;
     }
     PyObject* const result = PyObject_CallObject(func, arguments);
     Py_DECREF(arguments);
     if (!result)
         traceback(QString("No result from %1.%2").arg(moduleName).arg(functionName));
 
     return result;
 }
 
 bool Python::itemStringDel(const char* const item, const char* const moduleName)
 {
     PyObject* const dict = moduleDict(moduleName);
     const bool result = dict && PyDict_DelItemString(dict, item);
     if (!result)
         traceback(QString("Could not delete item string %1.%2").arg(moduleName).arg(item));
     return result;
 }
 
 PyObject* Python::itemString(const char* const item, const char* const moduleName)
 {
     if (PyObject* const value = itemString(item, moduleDict(moduleName)))
         return value;
 
     errScript << "Could not get item string" << moduleName << item;
     return 0;
 }
 
 PyObject* Python::itemString(const char* item, PyObject* dict)
 {
     if (dict)
         if (PyObject* const value = PyDict_GetItemString(dict, item))
             return value;
     traceback(QString("Could not get item string %1").arg(item));
     return 0;
 }
 
 bool Python::itemStringSet(const char* const item, PyObject* const value, const char* const moduleName)
 {
     PyObject* const dict = moduleDict(moduleName);
     const bool result = dict && !PyDict_SetItemString(dict, item, value);
     if (!result)
         traceback(QString("Could not set item string %1.%2").arg(moduleName).arg(item));
     return result;
 }
 
 PyObject* Python::kritaHandler(const char* const moduleName, const char* const handler)
 {
     if (PyObject* const module = moduleImport(moduleName))
         return functionCall(handler, "krita", Py_BuildValue("(O)", module));
     return 0;
 }
 
 QString Python::lastTraceback() const
 {
     QString result;
     result.swap(m_traceback);
     return result;
 }
 
+bool Python::libraryLoad()
+{
+    // no-op on Windows
+#ifndef Q_OS_WIN
+    if (!s_pythonLibrary) {
+        dbgScript << "Creating s_pythonLibrary" << PYKRITA_PYTHON_LIBRARY;
+        s_pythonLibrary = new QLibrary(PYKRITA_PYTHON_LIBRARY);
+        if (!s_pythonLibrary) {
+            errScript << "Could not create" << PYKRITA_PYTHON_LIBRARY;
+            return false;
+        }
+
+        s_pythonLibrary->setLoadHints(QLibrary::ExportExternalSymbolsHint);
+        if (!s_pythonLibrary->load()) {
+            errScript << "Could not load" << PYKRITA_PYTHON_LIBRARY;
+            return false;
+        }
+    }
+#endif
+    return true;
+}
+
 bool Python::setPath(const QStringList& paths)
 {
     if (Py_IsInitialized()) {
         warnScript << "Setting paths when Python interpreter is already initialized";
     }
 #ifdef Q_OS_WIN
     constexpr char pathSeparator = ';';
 #else
     constexpr char pathSeparator = ':';
 #endif
     QString joinedPaths = paths.join(pathSeparator);
     // Append the default search path
     // TODO: Properly handle embedded Python
 #ifdef Q_OS_WIN
     QString currentPaths;
     // Find embeddable Python
     // TODO: Don't hard-code the paths
     QDir pythonDir(KoResourcePaths::getApplicationRoot());
     if (pythonDir.cd("python")) {
         dbgScript << "Found embeddable Python at" << pythonDir.absolutePath();
         currentPaths = pythonDir.absolutePath() + pathSeparator
                      + pythonDir.absoluteFilePath("python36.zip");
     } else {
 # if 1
         // Use local Python???
         currentPaths = QString::fromWCharArray(Py_GetPath());
         warnScript << "Embeddable Python not found.";
         warnScript << "Default paths:" << currentPaths;
 # else
         // Or should we fail?
         errScript << "Embeddable Python not found, not setting Python paths";
         return false;
 # endif
     }
 #else
     QString currentPaths = QString::fromLocal8Bit(qgetenv("PYTHONPATH"));
 #endif
     if (!currentPaths.isEmpty()) {
         joinedPaths = joinedPaths + pathSeparator + currentPaths;
     }
     dbgScript << "Setting paths:" << joinedPaths;
 #ifdef Q_OS_WIN
     QVector<wchar_t> joinedPathsWChars(joinedPaths.size() + 1, 0);
     joinedPaths.toWCharArray(joinedPathsWChars.data());
     Py_SetPath(joinedPathsWChars.data());
 #else
     qputenv("PYTHONPATH", joinedPaths.toLocal8Bit());
 #endif
     return true;
 }
 
 void Python::ensureInitialized()
 {
     if (Py_IsInitialized()) {
         warnScript << "Python interpreter is already initialized, not initializing again";
     } else {
         dbgScript << "Initializing Python interpreter";
         Py_InitializeEx(0);
         if (!Py_IsInitialized()) {
             errScript << "Could not initialise Python interpreter";
         }
 #if THREADED
         PyEval_InitThreads();
         s_pythonThreadState = PyGILState_GetThisThreadState();
         PyEval_ReleaseThread(s_pythonThreadState);
 #endif
     }
 }
 
+void Python::maybeFinalize()
+{
+    if (!Py_IsInitialized()) {
+        warnScript << "Python interpreter not initialized, no need to finalize";
+    } else {
+#if THREADED
+        PyEval_AcquireThread(s_pythonThreadState);
+#endif
+        Py_Finalize();
+    }
+}
+
+void Python::libraryUnload()
+{
+    // no-op on Windows
+#ifndef Q_OS_WIN
+    if (s_pythonLibrary) {
+        // Shut the interpreter down if it has been started.
+        if (s_pythonLibrary->isLoaded()) {
+            s_pythonLibrary->unload();
+        }
+        delete s_pythonLibrary;
+        s_pythonLibrary = 0;
+    }
+#endif
+}
 
 PyObject* Python::moduleActions(const char* moduleName)
 {
     return kritaHandler(moduleName, "moduleGetActions");
 }
 
 PyObject* Python::moduleConfigPages(const char* const moduleName)
 {
     return kritaHandler(moduleName, "moduleGetConfigPages");
 }
 
 QString Python::moduleHelp(const char* moduleName)
 {
     QString r;
     PyObject* const result = kritaHandler(moduleName, "moduleGetHelp");
     if (result) {
         r = unicode(result);
         Py_DECREF(result);
     }
     return r;
 }
 
 PyObject* Python::moduleDict(const char* const moduleName)
 {
     PyObject* const module = moduleImport(moduleName);
     if (module)
         if (PyObject* const dictionary = PyModule_GetDict(module))
             return dictionary;
 
     traceback(QString("Could not get dict %1").arg(moduleName));
     return 0;
 }
 
 PyObject* Python::moduleImport(const char* const moduleName)
 {
     PyObject* const module = PyImport_ImportModule(moduleName);
     if (module)
         return module;
 
     traceback(QString("Could not import %1").arg(moduleName));
     return 0;
 }
 
 void* Python::objectUnwrap(PyObject* o)
 {
     PyObject* const arguments = Py_BuildValue("(O)", o);
     PyObject* const result = functionCall("unwrapinstance", "sip", arguments);
     if (!result)
         return 0;
 
     void* const r = reinterpret_cast<void*>(ptrdiff_t(PyLong_AsLongLong(result)));
     Py_DECREF(result);
     return r;
 }
 
 PyObject* Python::objectWrap(void* const o, const QString& fullClassName)
 {
     const QString classModuleName = fullClassName.section('.', 0, -2);
     const QString className = fullClassName.section('.', -1);
     PyObject* const classObject = itemString(PQ(className), PQ(classModuleName));
     if (!classObject)
         return 0;
 
     PyObject* const arguments = Py_BuildValue("NO", PyLong_FromVoidPtr(o), classObject);
     PyObject* const result = functionCall("wrapinstance", "sip", arguments);
 
     return result;
 }
 
 // Inspired by http://www.gossamer-threads.com/lists/python/python/150924.
 void Python::traceback(const QString& description)
 {
     m_traceback.clear();
     if (!PyErr_Occurred())
         // Return an empty string on no error.
         // NOTE "Return a string?" really??
         return;
 
     PyObject* exc_typ;
     PyObject* exc_val;
     PyObject* exc_tb;
     PyErr_Fetch(&exc_typ, &exc_val, &exc_tb);
     PyErr_NormalizeException(&exc_typ, &exc_val, &exc_tb);
 
     // Include the traceback.
     if (exc_tb) {
         m_traceback = "Traceback (most recent call last):\n";
         PyObject* const arguments = PyTuple_New(1);
         PyTuple_SetItem(arguments, 0, exc_tb);
         PyObject* const result = functionCall("format_tb", "traceback", arguments);
         if (result) {
             for (int i = 0, j = PyList_Size(result); i < j; i++) {
                 PyObject* const tt = PyList_GetItem(result, i);
                 PyObject* const t = Py_BuildValue("(O)", tt);
                 char* buffer;
                 if (!PyArg_ParseTuple(t, "s", &buffer))
                     break;
                 m_traceback += buffer;
             }
             Py_DECREF(result);
         }
         Py_DECREF(exc_tb);
     }
 
     // Include the exception type and value.
     if (exc_typ) {
         PyObject* const temp = PyObject_GetAttrString(exc_typ, "__name__");
         if (temp) {
             m_traceback += unicode(temp);
             m_traceback += ": ";
         }
         Py_DECREF(exc_typ);
     }
 
     if (exc_val) {
         PyObject* const temp = PyObject_Str(exc_val);
         if (temp) {
             m_traceback += unicode(temp);
             m_traceback += "\n";
         }
         Py_DECREF(exc_val);
     }
     m_traceback += description;
 
     QStringList l = m_traceback.split("\n");
     Q_FOREACH(const QString &s, l) {
         errScript << s;
     }
     /// \todo How about to show it somewhere else than "console output"?
 }
 
 PyObject* Python::unicode(const QString& string)
 {
 #if PY_MAJOR_VERSION < 3
     /* Python 2.x. http://docs.python.org/2/c-api/unicode.html */
     PyObject* s = PyString_FromString(PQ(string));
     PyObject* u = PyUnicode_FromEncodedObject(s, "utf-8", "strict");
     Py_DECREF(s);
     return u;
 #elif PY_MINOR_VERSION < 3
     /* Python 3.2 or less. http://docs.python.org/3.2/c-api/unicode.html#unicode-objects */
 # ifdef Py_UNICODE_WIDE
     return PyUnicode_DecodeUTF16((const char*)string.constData(), string.length() * 2, 0, 0);
 # else
     return PyUnicode_FromUnicode(string.constData(), string.length());
 # endif
 #else /* Python 3.3 or greater. http://docs.python.org/3.3/c-api/unicode.html#unicode-objects */
     return PyUnicode_FromKindAndData(PyUnicode_2BYTE_KIND, string.constData(), string.length());
 #endif
 }
 
 QString Python::unicode(PyObject* const string)
 {
 #if PY_MAJOR_VERSION < 3
     /* Python 2.x. http://docs.python.org/2/c-api/unicode.html */
     if (PyString_Check(string))
         return QString(PyString_AsString(string));
     else if (PyUnicode_Check(string)) {
         const int unichars = PyUnicode_GetSize(string);
 # ifdef HAVE_USABLE_WCHAR_T
         return QString::fromWCharArray(PyUnicode_AsUnicode(string), unichars);
 # else
 #   ifdef Py_UNICODE_WIDE
         return QString::fromUcs4((const unsigned int*)PyUnicode_AsUnicode(string), unichars);
 #   else
         return QString::fromUtf16(PyUnicode_AsUnicode(string), unichars);
 #   endif
 # endif
     } else return QString();
 #elif PY_MINOR_VERSION < 3
     /* Python 3.2 or less. http://docs.python.org/3.2/c-api/unicode.html#unicode-objects */
     if (!PyUnicode_Check(string))
         return QString();
 
     const int unichars = PyUnicode_GetSize(string);
 # ifdef HAVE_USABLE_WCHAR_T
     return QString::fromWCharArray(PyUnicode_AsUnicode(string), unichars);
 # else
 #   ifdef Py_UNICODE_WIDE
     return QString::fromUcs4(PyUnicode_AsUnicode(string), unichars);
 #   else
     return QString::fromUtf16(PyUnicode_AsUnicode(string), unichars);
 #   endif
 # endif
 #else /* Python 3.3 or greater. http://docs.python.org/3.3/c-api/unicode.html#unicode-objects */
     if (!PyUnicode_Check(string))
         return QString();
 
     const int unichars = PyUnicode_GetLength(string);
     if (0 != PyUnicode_READY(string))
         return QString();
 
     switch (PyUnicode_KIND(string)) {
     case PyUnicode_1BYTE_KIND:
         return QString::fromLatin1((const char*)PyUnicode_1BYTE_DATA(string), unichars);
     case PyUnicode_2BYTE_KIND:
         return QString::fromUtf16(PyUnicode_2BYTE_DATA(string), unichars);
     case PyUnicode_4BYTE_KIND:
         return QString::fromUcs4(PyUnicode_4BYTE_DATA(string), unichars);
     default:
         break;
     }
     return QString();
 #endif
 }
 
 bool Python::isUnicode(PyObject* const string)
 {
 #if PY_MAJOR_VERSION < 3
     return PyString_Check(string) || PyUnicode_Check(string);
 #else
     return PyUnicode_Check(string);
 #endif
 }
 
 void Python::updateConfigurationFromDictionary(KConfigBase* const config, PyObject* const dictionary)
 {
     PyObject* groupKey;
     PyObject* groupDictionary;
     Py_ssize_t position = 0;
     while (PyDict_Next(dictionary, &position, &groupKey, &groupDictionary)) {
         if (!isUnicode(groupKey)) {
             traceback(QString("Configuration group name not a string"));
             continue;
         }
         QString groupName = unicode(groupKey);
         if (!PyDict_Check(groupDictionary)) {
             traceback(QString("Configuration group %1 top level key not a dictionary").arg(groupName));
             continue;
         }
 
         // There is a group per module.
         KConfigGroup group = config->group(groupName);
         PyObject* key;
         PyObject* value;
         Py_ssize_t x = 0;
         while (PyDict_Next(groupDictionary, &x, &key, &value)) {
             if (!isUnicode(key)) {
                 traceback(QString("Configuration group %1 itemKey not a string").arg(groupName));
                 continue;
             }
             PyObject* arguments = Py_BuildValue("(Oi)", value, 0);
             PyObject* pickled = functionCall("dumps", "pickle", arguments);
             if (pickled) {
 #if PY_MAJOR_VERSION < 3
                 QString ascii(unicode(pickled));
 #else
                 QString ascii(PyBytes_AsString(pickled));
 #endif
                 group.writeEntry(unicode(key), ascii);
                 Py_DECREF(pickled);
             } else {
                 errScript << "Cannot write" << groupName << unicode(key) << unicode(PyObject_Str(value));
             }
         }
     }
 }
 
 void Python::updateDictionaryFromConfiguration(PyObject* const dictionary, const KConfigBase* const config)
 {
     qDebug() << config->groupList();
     Q_FOREACH(QString groupName, config->groupList()) {
         KConfigGroup group = config->group(groupName);
         PyObject* groupDictionary = PyDict_New();
         PyDict_SetItemString(dictionary, PQ(groupName), groupDictionary);
         Q_FOREACH(QString key, group.keyList()) {
             QString pickled = group.readEntry(key);
 #if PY_MAJOR_VERSION < 3
             PyObject* arguments = Py_BuildValue("(s)", PQ(pickled));
 #else
             PyObject* arguments = Py_BuildValue("(y)", PQ(pickled));
 #endif
             PyObject* value = functionCall("loads", "pickle", arguments);
             if (value) {
                 PyDict_SetItemString(groupDictionary, PQ(key), value);
                 Py_DECREF(value);
             } else {
                 errScript << "Cannot read" << groupName << key << pickled;
             }
         }
         Py_DECREF(groupDictionary);
     }
 }
 
 bool Python::prependPythonPaths(const QString& path)
 {
     PyObject* sys_path = itemString("path", "sys");
     return bool(sys_path) && prependPythonPaths(path, sys_path);
 }
 
 bool Python::prependPythonPaths(const QStringList& paths)
 {
     PyObject* sys_path = itemString("path", "sys");
     if (!sys_path)
         return false;
 
     /// \todo Heh, boosts' range adaptors would be good here!
     QStringList reversed_paths;
     std::reverse_copy(
         paths.begin()
         , paths.end()
         , std::back_inserter(reversed_paths)
     );
 
     Q_FOREACH(const QString & path, reversed_paths)
     if (!prependPythonPaths(path, sys_path))
         return false;
 
     return true;
 }
 
 bool Python::prependPythonPaths(const QString& path, PyObject* sys_path)
 {
     Q_ASSERT("Dir entry expected to be valid" && sys_path);
     return bool(prependStringToList(sys_path, path));
 }
 
 }                                                           // namespace PyKrita
 
 // krita: indent-width 4;
diff --git a/plugins/extensions/pykrita/plugin/utilities.h b/plugins/extensions/pykrita/plugin/utilities.h
index 6b979d02b9..0324268a4a 100644
--- a/plugins/extensions/pykrita/plugin/utilities.h
+++ b/plugins/extensions/pykrita/plugin/utilities.h
@@ -1,231 +1,246 @@
 // This file is part of PyKrita, Krita' Python scripting plugin.
 //
 // A couple of useful macros and functions used inside of pykrita_engine.cpp and pykrita_plugin.cpp.
 //
 // Copyright (C) 2006 Paul Giannaros <paul@giannaros.org>
 // Copyright (C) 2012, 2013 Shaheed Haque <srhaque@theiet.org>
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Lesser General Public
 // License as published by the Free Software Foundation; either
 // version 2.1 of the License, or (at your option) version 3, or any
 // later version accepted by the membership of KDE e.V. (or its
 // successor approved by the membership of KDE e.V.), which shall
 // act as a proxy defined in Section 6 of version 3 of the license.
 //
 // This library is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 // Lesser General Public License for more details.
 //
 // You should have received a copy of the GNU Lesser General Public
 // License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 //
 
 #ifndef __PYKRITA_UTILITIES_H__
 # define  __PYKRITA_UTILITIES_H__
 
 #include <cmath>
 #include <Python.h>
 #include <QString>
 
 class KConfigBase;
 
 /// Save us some ruddy time when printing out QStrings with UTF-8
 # define PQ(x) x.toUtf8().constData()
 
 namespace PyKrita
 {
 
 /**
  * Instantiate this class on the stack to automatically get and release the
  * GIL.
  *
  * Also, making all the utility functions members of this class means that in
  * many cases the compiler tells us where the class in needed. In the remaining
  * cases (i.e. bare calls to the Python C API), inspection is used to needed
  * to add the requisite Python() object. To prevent this object being optimised
  * away in these cases due to lack of use, all instances have the form of an
  * assignment, e.g.:
  *
  *      Python py = Python()
  *
  * This adds a little overhead, but this is a small price for consistency.
  */
 class Python
 {
 public:
     Python();
     ~Python();
 
+    /**
+     * Load the Python shared library. This does nothing on Windows.
+     */
+    static bool libraryLoad();
+
     /**
      * Set the Python paths by calling Py_SetPath. This should be called before
      * initialization to ensure the proper libraries get loaded.
      */
     static bool setPath(const QStringList& paths);
 
     /**
      * Make sure the Python interpreter is initialized. Ideally should be only
      * called once.
      */
     static void ensureInitialized();
 
+    /**
+     * Finalize the Python interpreter. Not gauranteed to work.
+     */
+    static void maybeFinalize();
+
+    /**
+     * Unload the Python shared library. This does nothing on Windows.
+     */
+    static void libraryUnload();
+
     /// Convert a QString to a Python unicode object.
     static PyObject* unicode(const QString& string);
 
     /// Convert a Python unicode object to a QString.
     static QString unicode(PyObject* string);
 
     /// Test if a Python object is compatible with a QString.
     static bool isUnicode(PyObject* string);
 
     /// Prepend a QString to a list as a Python unicode object
     bool prependStringToList(PyObject* list, const QString& value);
 
     /**
      * Print and save (see @ref lastTraceback()) the current traceback in a
      * form approximating what Python would print:
      *
      * Traceback (most recent call last):
      *   File "/home/shahhaqu/.kde/share/apps/krita/pykrita/pluginmgr.py", line 13, in <module>
      *     import kdeui
      * ImportError: No module named kdeui
      * Could not import pluginmgr.
      */
     void traceback(const QString& description);
 
     /**
      * Store the last traceback we handled using @ref traceback().
      */
     QString lastTraceback(void) const;
 
     /**
      * Create a Python dictionary from a KConfigBase instance, writing the
      * string representation of the values.
      */
     void updateDictionaryFromConfiguration(PyObject* dictionary, const KConfigBase* config);
 
     /**
      * Write a Python dictionary to a configuration object, converting objects
      * to their string representation along the way.
      */
     void updateConfigurationFromDictionary(KConfigBase* config, PyObject* dictionary);
 
     /**
      * Call the named module's named entry point.
      */
     bool functionCall(const char* functionName, const char* moduleName = PYKRITA_ENGINE);
     PyObject* functionCall(const char* functionName, const char* moduleName, PyObject* arguments);
 
     /**
      * Delete the item from the named module's dictionary.
      */
     bool itemStringDel(const char* item, const char* moduleName = PYKRITA_ENGINE);
 
     /**
      * Get the item from the named module's dictionary.
      *
      * @return 0 or a borrowed reference to the item.
      */
     PyObject* itemString(const char* item, const char* moduleName = PYKRITA_ENGINE);
 
     /**
      * Get the item from the given dictionary.
      *
      * @return 0 or a borrowed reference to the item.
      */
     PyObject* itemString(const char* item, PyObject* dict);
 
     /**
      * Set the item in the named module's dictionary.
      */
     bool itemStringSet(const char* item, PyObject* value, const char* moduleName = PYKRITA_ENGINE);
 
     /**
      * Get the Actions defined by a module. The returned object is
      * [ { function, ( text, icon, shortcut, menu ) }... ] for each module
      * function decorated with @action.
      *
      * @return 0 or a new reference to the result.
      */
     PyObject* moduleActions(const char* moduleName);
 
     /**
      * Get the ConfigPages defined by a module. The returned object is
      * [ { function, callable, ( name, fullName, icon ) }... ] for each module
      * function decorated with @configPage.
      *
      * @return 0 or a new reference to the result.
      */
     PyObject* moduleConfigPages(const char* moduleName);
 
     /**
      * Get the named module's dictionary.
      *
      * @return 0 or a borrowed reference to the dictionary.
      */
     PyObject* moduleDict(const char* moduleName = PYKRITA_ENGINE);
 
     /**
      * Get the help text defined by a module.
      */
     QString moduleHelp(const char* moduleName);
 
     /**
      * Import the named module.
      *
      * @return 0 or a borrowed reference to the module.
      */
     PyObject* moduleImport(const char* moduleName);
 
     /**
      * A void * for an arbitrary Qt/KDE object that has been wrapped by SIP. Nifty.
      *
      * @param o         The object to be unwrapped. The reference is borrowed.
      */
     void* objectUnwrap(PyObject* o);
 
     /**
      * A PyObject * for an arbitrary Qt/KDE object using SIP wrapping. Nifty.
      *
      * @param o         The object to be wrapped.
      * @param className The full class name of o, e.g. "PyQt5.QtWidgets.QWidget".
      * @return @c 0 or a new reference to the object.
      */
     PyObject* objectWrap(void* o, const QString& className);
 
     /**
      * Add a given path to to the front of \c PYTHONPATH
      *
      * @param path      A string (path) to be added
      * @return @c true on success, @c false otherwise.
      */
     bool prependPythonPaths(const QString& path);
 
     /**
      * Add listed paths to to the front of \c PYTHONPATH
      *
      * @param paths     A string list (paths) to be added
      * @return @c true on success, @c false otherwise.
      */
     bool prependPythonPaths(const QStringList& paths);
 
     static const char* PYKRITA_ENGINE;
 
 private:
     /// @internal Helper function for @c prependPythonPaths overloads
     bool prependPythonPaths(const QString&, PyObject*);
     PyGILState_STATE m_state;
     mutable QString m_traceback;
 
     /**
      * Run a handler function supplied by the krita module on another module.
      *
      * @return 0 or a new reference to the result.
      */
     PyObject* kritaHandler(const char* moduleName, const char* handler);
 };
 
 }                                                           // namespace PyKrita
 #endif                                                      //  __PYKRITA_UTILITIES_H__
 // krita: indent-width 4;