diff --git a/libs/libkis/Krita.cpp b/libs/libkis/Krita.cpp
index 6764e5bc1a..c11b9ccf45 100644
--- a/libs/libkis/Krita.cpp
+++ b/libs/libkis/Krita.cpp
@@ -1,418 +1,424 @@
 /*
  *  Copyright (c) 2016 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program 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 of the License, or
  *  (at your option) any later version.
  *
  *  This program 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 General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #include "Krita.h"
 
 #include <QPointer>
 #include <QVariant>
 
 #include <ksharedconfig.h>
 #include <kconfiggroup.h>
+#include <klocalizedstring.h>
 
 #include <KoColorSpaceRegistry.h>
 #include <KoColorProfile.h>
 #include <KoColorSpace.h>
 #include <KoDockRegistry.h>
 #include <KoColorSpaceEngine.h>
 #include <KoColorModelStandardIds.h>
 #include <KoID.h>
 
 #include <kis_filter_strategy.h>
 #include <kactioncollection.h>
 #include <KisPart.h>
 #include <KisMainWindow.h>
 #include <KisDocument.h>
 #include <kis_image.h>
 #include <kis_action.h>
 #include <KisViewManager.h>
 #include <KritaVersionWrapper.h>
 #include <kis_filter_registry.h>
 #include <kis_filter.h>
 #include <kis_filter_configuration.h>
 #include <kis_properties_configuration.h>
 #include <kis_config.h>
 #include <KisResourceServerProvider.h>
 #include <kis_workspace_resource.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <kis_brush_server.h>
 #include <KoResourceServerProvider.h>
 #include <kis_action_registry.h>
 #include <kis_icon_utils.h>
 #include <KisPart.h>
 
 #include "View.h"
 #include "Document.h"
 #include "Window.h"
 #include "Extension.h"
 #include "DockWidgetFactoryBase.h"
 #include "Filter.h"
 #include "InfoObject.h"
 #include "Resource.h"
 
 Krita* Krita::s_instance = 0;
 
 struct Krita::Private {
     Private() {}
     QList<Extension*> extensions;
     bool batchMode {false};
     Notifier *notifier{new Notifier()};
 };
 
 Krita::Krita(QObject *parent)
     : QObject(parent)
     , d(new Private)
 {
     qRegisterMetaType<Notifier*>();
     connect(KisPart::instance(), SIGNAL(sigWindowAdded(KisMainWindow*)), SLOT(mainWindowAdded(KisMainWindow*)));
 }
 
 Krita::~Krita()
 {
     qDeleteAll(d->extensions);
     delete d->notifier;
     delete d;
 }
 
 QList<QAction *> Krita::actions() const
 {
     KisMainWindow *mainWindow = KisPart::instance()->currentMainwindow();
     if (!mainWindow) {
         return QList<QAction*>();
     }
     KActionCollection *actionCollection = mainWindow->actionCollection();
     return actionCollection->actions();
 }
 
 QAction *Krita::action(const QString &name) const
 {
     KisMainWindow *mainWindow = KisPart::instance()->currentMainwindow();
     if (!mainWindow) {
         return 0;
     }
     KActionCollection *actionCollection = mainWindow->actionCollection();
     QAction *action = actionCollection->action(name);
     return action;
 }
 
 Document* Krita::activeDocument() const
 {
     KisMainWindow *mainWindow = KisPart::instance()->currentMainwindow();
     if (!mainWindow) {
         return 0;
     }
     KisView *view = mainWindow->activeView();
     if (!view) {
         return 0;
     }
     KisDocument *document = view->document();
     return new Document(document);
 }
 
 void Krita::setActiveDocument(Document* value)
 {
     Q_FOREACH(KisView *view, KisPart::instance()->views()) {
         if (view->document() == value->document().data()) {
             view->activateWindow();
             break;
         }
     }
 }
 
 bool Krita::batchmode() const
 {
     return d->batchMode;
 }
 
 void Krita::setBatchmode(bool value)
 {
     d->batchMode = value;
 }
 
 
 QList<Document *> Krita::documents() const
 {
     QList<Document *> ret;
     foreach(QPointer<KisDocument> doc, KisPart::instance()->documents()) {
         ret << new Document(doc);
     }
     return ret;
 }
 
 QStringList Krita::filters() const
 {
     QStringList ls = KisFilterRegistry::instance()->keys();
     std::sort(ls.begin(), ls.end());
     return ls;
 }
 
 Filter *Krita::filter(const QString &name) const
 {
     if (!filters().contains(name)) return 0;
 
     Filter *filter = new Filter();
     filter->setName(name);
     KisFilterSP f = KisFilterRegistry::instance()->value(name);
     KisFilterConfigurationSP fc = f->defaultConfiguration();
     InfoObject *info = new InfoObject(fc);
     filter->setConfiguration(info);
     return filter;
 }
 
 QStringList Krita::colorModels() const
 {
     QSet<QString> colorModelsIds;
     QList<KoID> ids = KoColorSpaceRegistry::instance()->colorModelsList(KoColorSpaceRegistry::AllColorSpaces);
     Q_FOREACH(KoID id, ids) {
         colorModelsIds << id.id();
     }
     return colorModelsIds.toList();
 }
 
 QStringList Krita::colorDepths(const QString &colorModel) const
 {
     QSet<QString> colorDepthsIds;
     QList<KoID> ids = KoColorSpaceRegistry::instance()->colorDepthList(colorModel, KoColorSpaceRegistry::AllColorSpaces);
     Q_FOREACH(KoID id, ids) {
         colorDepthsIds << id.id();
     }
     return colorDepthsIds.toList();
 }
 
 QStringList Krita::filterStrategies() const
 {
     return KisFilterStrategyRegistry::instance()->keys();
 }
 
 QStringList Krita::profiles(const QString &colorModel, const QString &colorDepth) const
 {
     QSet<QString> profileNames;
     QString id = KoColorSpaceRegistry::instance()->colorSpaceId(colorModel, colorDepth);
     QList<const KoColorProfile *> profiles = KoColorSpaceRegistry::instance()->profilesFor(id);
     Q_FOREACH(const KoColorProfile *profile, profiles) {
         profileNames << profile->name();
     }
     return profileNames.toList();
 }
 
 bool Krita::addProfile(const QString &profilePath)
 {
     KoColorSpaceEngine *iccEngine = KoColorSpaceEngineRegistry::instance()->get("icc");
     return iccEngine->addProfile(profilePath);
 }
 
 Notifier* Krita::notifier() const
 {
     return d->notifier;
 }
 
 QString Krita::version() const
 {
     return KritaVersionWrapper::versionString(true);
 }
 
 QList<View *> Krita::views() const
 {
     QList<View *> ret;
     foreach(QPointer<KisView> view, KisPart::instance()->views()) {
         ret << new View(view);
     }
     return ret;
 }
 
 Window *Krita::activeWindow() const
 {
     KisMainWindow *mainWindow = KisPart::instance()->currentMainwindow();
     if (!mainWindow) {
         return 0;
     }
     return new Window(mainWindow);
 }
 
 QList<Window*>  Krita::windows() const
 {
     QList<Window*> ret;
     foreach(QPointer<KisMainWindow> mainWin, KisPart::instance()->mainWindows()) {
         ret << new Window(mainWin);
     }
     return ret;
 }
 
 QMap<QString, Resource *> Krita::resources(const QString &type) const
 {
     QMap<QString, Resource *> resources = QMap<QString, Resource *> ();
 
     if (type.toLower() == "pattern") {
         KoResourceServer<KoPattern>* server = KoResourceServerProvider::instance()->patternServer();
         Q_FOREACH (KoResource *res, server->resources()) {
             resources[res->name()] = new Resource(res);
         }
     }
     else if (type.toLower() == "gradient") {
         KoResourceServer<KoAbstractGradient>* server = KoResourceServerProvider::instance()->gradientServer();
         Q_FOREACH (KoResource *res, server->resources()) {
             resources[res->name()] = new Resource(res);
         }
     }
     else if (type.toLower() == "brush") {
         KisBrushResourceServer* server = KisBrushServer::instance()->brushServer();
         Q_FOREACH (KisBrushSP res, server->resources()) {
             resources[res->name()] = new Resource(res.data());
         }
     }
     else if (type.toLower() == "preset") {
         KisPaintOpPresetResourceServer* server = KisResourceServerProvider::instance()->paintOpPresetServer();
         Q_FOREACH (KisPaintOpPresetSP res, server->resources()) {
             resources[res->name()] = new Resource(res.data());
         }
     }
     else if (type.toLower() == "palette") {
         KoResourceServer<KoColorSet>* server = KoResourceServerProvider::instance()->paletteServer();
         Q_FOREACH (KoResource *res, server->resources()) {
             resources[res->name()] = new Resource(res);
         }
     }
     else if (type.toLower() == "workspace") {
         KoResourceServer< KisWorkspaceResource >* server = KisResourceServerProvider::instance()->workspaceServer();
         Q_FOREACH (KoResource *res, server->resources()) {
             resources[res->name()] = new Resource(res);
         }
     }
     return resources;
 }
 
 QStringList Krita::recentDocuments() const
 {
     KConfigGroup grp = KSharedConfig::openConfig()->group(QString("RecentFiles"));
     QStringList keys = grp.keyList();
     QStringList recentDocuments;
 
     for(int i = 0; i <= keys.filter("File").count(); i++)
         recentDocuments << grp.readEntry(QString("File%1").arg(i), QString(""));
 
     return recentDocuments;
 }
 
 Document* Krita::createDocument(int width, int height, const QString &name, const QString &colorModel, const QString &colorDepth, const QString &profile, double resolution)
 {
     KisDocument *document = KisPart::instance()->createDocument();
     KisPart::instance()->addDocument(document);
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->colorSpace(colorModel, colorDepth, profile);
     Q_ASSERT(cs);
 
     QColor qc(Qt::white);
     qc.setAlpha(0);
     KoColor bgColor(qc, cs);
 
     if (!document->newImage(name, width, height, cs, bgColor, true, 1, "", double(resolution / 72) )) {
         qDebug() << "Could not create a new image";
         return 0;
     }
 
     Q_ASSERT(document->image());
     qDebug() << document->image()->objectName();
 
     return new Document(document);
 }
 
 Document* Krita::openDocument(const QString &filename)
 {
     KisDocument *document = KisPart::instance()->createDocument();
     document->setFileBatchMode(this->batchmode());
     KisPart::instance()->addDocument(document);
     document->openUrl(QUrl::fromLocalFile(filename), KisDocument::DontAddToRecent);
     document->setFileBatchMode(false);
     return new Document(document);
 }
 
 Window* Krita::openWindow()
 {
     KisMainWindow *mw = KisPart::instance()->createMainWindow();
     return new Window(mw);
 }
 
 void Krita::addExtension(Extension* extension)
 {
     d->extensions.append(extension);
 }
 
 QList< Extension* > Krita::extensions()
 {
     return d->extensions;
 }
 
 void Krita::writeSetting(const QString &group, const QString &name, const QString &value)
 {
     KConfigGroup grp = KSharedConfig::openConfig()->group(group);
     grp.writeEntry(name, value);
 }
 
 QString Krita::readSetting(const QString &group, const QString &name, const QString &defaultValue)
 {
     KConfigGroup grp = KSharedConfig::openConfig()->group(group);
     return grp.readEntry(name, defaultValue);
 }
 
 QIcon Krita::icon(QString &iconName) const
 {
     return KisIconUtils::loadIcon(iconName);
 }
 
 void Krita::addDockWidgetFactory(DockWidgetFactoryBase* factory)
 {
     KoDockRegistry::instance()->add(factory);
 }
 
 Krita* Krita::instance()
 {
     if (!s_instance)
     {
         s_instance = new Krita;
     }
     return s_instance;
 }
 
 /**
  * Scripter.fromVariant(variant)
  * variant is a QVariant
  * returns instance of QObject-subclass
  *
  * This is a helper method for PyQt because PyQt cannot cast a variant to a QObject or QWidget
  */
 QObject *Krita::fromVariant(const QVariant& v)
 {
 
     if (v.canConvert< QWidget* >())
     {
         QObject* obj = qvariant_cast< QWidget* >(v);
         return obj;
     }
     else if (v.canConvert< QObject* >())
     {
         QObject* obj = qvariant_cast< QObject* >(v);
         return obj;
     }
     else
         return 0;
 }
 
+QString Krita::krita_i18n(const QString &text)
+{
+    return i18n(text.toUtf8().constData());
+}
+
 void Krita::mainWindowAdded(KisMainWindow *kisWindow)
 {
     Q_FOREACH(Extension *extension, d->extensions) {
         Window window(kisWindow);
         extension->createActions(&window);
     }
 }
diff --git a/libs/libkis/Krita.h b/libs/libkis/Krita.h
index 39e66933f2..b862189247 100644
--- a/libs/libkis/Krita.h
+++ b/libs/libkis/Krita.h
@@ -1,343 +1,345 @@
 /*
  *  Copyright (c) 2016 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program 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 of the License, or
  *  (at your option) any later version.
  *
  *  This program 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 General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #ifndef LIBKIS_KRITA_H
 #define LIBKIS_KRITA_H
 
 #include <QObject>
 #include <QAction>
 
 #include "kritalibkis_export.h"
 #include "libkis.h"
 
 #include "Extension.h"
 #include "Document.h"
 #include "Window.h"
 #include "View.h"
 #include "Notifier.h"
 
 
 /**
  * Krita is a singleton class that offers the root access to the Krita object hierarchy.
  *
  * The Krita.instance() is aliased as two builtins: Scripter and Application.
  */
 class KRITALIBKIS_EXPORT Krita : public QObject
 {
     Q_OBJECT
 
 public:
     explicit Krita(QObject *parent = 0);
     ~Krita() override;
 
 public Q_SLOTS:
 
 
     /**
      * @return the currently active document, if there is one.
      */
     Document* activeDocument() const;
 
     /**
      * @brief setActiveDocument activates the first view that shows the given document
      * @param value the document we want to activate
      */
     void setActiveDocument(Document* value);
 
     /**
      * @brief batchmode determines whether the script is run in batch mode. If batchmode
      * is true, scripts should now show messageboxes or dialog boxes.
      *
      * Note that this separate from Document.setBatchmode(), which determines whether
      * export/save option dialogs are shown.
      *
      * @return true if the script is run in batchmode
      */
     bool batchmode() const;
 
     /**
      * @brief setBatchmode sets the batchmode to @param value; if true, scripts should
      * not show dialogs or messageboxes.
      */
     void setBatchmode(bool value);
 
     /**
      * @return return a list of all actions for the currently active mainWindow.
      */
     QList<QAction*> actions() const;
 
     /**
      * @return the action that has been registered under the given name, or 0 if no such action exists.
      */
     QAction *action(const QString &name) const;
 
     /**
      * @return a list of all open Documents
      */
     QList<Document*> documents() const;
 
     /**
      * @brief Filters are identified by an internal name. This function returns a list
      * of all existing registered filters.
      * @return a list of all registered filters
      */
     QStringList filters() const;
 
     /**
      * @brief filter construct a Filter object with a default configuration.
      * @param name the name of the filter. Use Krita.instance().filters() to get
      * a list of all possible filters.
      * @return the filter or None if there is no such filter.
      */
     Filter *filter(const QString &name) const;
 
     /**
      * @brief colorModels creates a list with all color models id's registered.
      * @return a list of all color models or a empty list if there is no such color models.
      */
     QStringList colorModels() const;
 
     /**
      * @brief colorDepths creates a list with the names of all color depths
      * compatible with the given color model.
      * @param colorModel the id of a color model.
      * @return a list of all color depths or a empty list if there is no such
      * color depths.
      */
     QStringList colorDepths(const QString &colorModel) const;
 
     /**
      * @brief filterStrategies Retrieves all installed filter strategies. A filter
      * strategy is used when transforming (scaling, shearing, rotating) an image to
      * calculate the value of the new pixels. You can use th
      * @return the id's of all available filters.
      */
     QStringList filterStrategies() const;
 
     /**
      * @brief profiles creates a list with the names of all color profiles compatible
      * with the given color model and color depth.
      * @param colorModel A string describing the color model of the image:
      * <ul>
      * <li>A: Alpha mask</li>
      * <li>RGBA: RGB with alpha channel (The actual order of channels is most often BGR!)</li>
      * <li>XYZA: XYZ with alpha channel</li>
      * <li>LABA: LAB with alpha channel</li>
      * <li>CMYKA: CMYK with alpha channel</li>
      * <li>GRAYA: Gray with alpha channel</li>
      * <li>YCbCrA: YCbCr with alpha channel</li>
      * </ul>
      * @param colorDepth A string describing the color depth of the image:
      * <ul>
      * <li>U8: unsigned 8 bits integer, the most common type</li>
      * <li>U16: unsigned 16 bits integer</li>
      * <li>F16: half, 16 bits floating point. Only available if Krita was built with OpenEXR</li>
      * <li>F32: 32 bits floating point</li>
      * </ul>
      * @return a list with valid names
      */
     QStringList profiles(const QString &colorModel, const QString &colorDepth) const;
 
     /**
      * @brief addProfile load the given profile into the profile registry.
      * @param profilePath the path to the profile.
      * @return true if adding the profile succeeded.
      */
     bool addProfile(const QString &profilePath);
 
     /**
      * @brief notifier the Notifier singleton emits signals when documents are opened and
      * closed, the configuration changes, views are opened and closed or windows are opened.
      * @return the notifier object
      */
     Notifier *notifier() const;
 
     /**
      * @brief version Determine the version of Krita
      *
      * Usage: print(Application.version ())
      *
      * @return the version string including git sha1 if Krita was built from git
      */
     QString version() const;
 
     /**
      * @return a list of all views. A Document can be shown in more than one view.
      */
     QList<View*> views() const;
 
     /**
      * @return the currently active window or None if there is no window
      */
     Window *activeWindow() const;
 
     /**
      * @return a list of all windows
      */
     QList<Window *> windows() const;
 
     /**
      * @brief resources returns a list of Resource objects of the given type
      * @param type Valid types are:
      *
      * <ul>
      * <li>pattern</li>
      * <li>gradient</li>
      * <li>brush</li>
      * <li>preset</li>
      * <li>palette</li>
      * <li>workspace</li>
      * </ul>
      */
     QMap<QString, Resource*> resources(const QString &type) const;
 
 
     /**
      * @brief return all recent documents registered in the RecentFiles group of the kritarc
      */
     QStringList recentDocuments() const;
 
 
     /**
      * @brief createDocument creates a new document and image and registers
      * the document with the Krita application.
      *
      * Unless you explicitly call Document::close() the document will remain
      * known to the Krita document registry. The document and its image will
      * only be deleted when Krita exits.
      *
      * The document will have one transparent layer.
      *
      * To create a new document and show it, do something like:
 @code
 from Krita import *
 
 def add_document_to_window():
     d = Application.createDocument(100, 100, "Test", "RGBA", "U8", "", 120.0)
     Application.activeWindow().addView(d)
 
 add_document_to_window()
 @endcode
      *
      * @param width the width in pixels
      * @param height the height in pixels
      * @param name the name of the image (not the filename of the document)
      * @param colorModel A string describing the color model of the image:
      * <ul>
      * <li>A: Alpha mask</li>
      * <li>RGBA: RGB with alpha channel (The actual order of channels is most often BGR!)</li>
      * <li>XYZA: XYZ with alpha channel</li>
      * <li>LABA: LAB with alpha channel</li>
      * <li>CMYKA: CMYK with alpha channel</li>
      * <li>GRAYA: Gray with alpha channel</li>
      * <li>YCbCrA: YCbCr with alpha channel</li>
      * </ul>
      * @param colorDepth A string describing the color depth of the image:
      * <ul>
      * <li>U8: unsigned 8 bits integer, the most common type</li>
      * <li>U16: unsigned 16 bits integer</li>
      * <li>F16: half, 16 bits floating point. Only available if Krita was built with OpenEXR</li>
      * <li>F32: 32 bits floating point</li>
      * </ul>
      * @param profile The name of an icc profile that is known to Krita. If an empty string is passed, the default is
      * taken.
      * @param resolution the resolution in points per inch.
      * @return the created document.
      */
     Document *createDocument(int width, int height, const QString &name, const QString &colorModel, const QString &colorDepth, const QString &profile, double resolution);
 
     /**
      * @brief openDocument creates a new Document, registers it with the Krita application and loads the given file.
      * @param filename the file to open in the document
      * @return the document
      */
     Document *openDocument(const QString &filename);
 
     /**
      * @brief openWindow create a new main window. The window is not shown by default.
      */
     Window *openWindow();
 
     /**
      * @brief addExtension add the given plugin to Krita. There will be a single instance of each Extension in the Krita process.
      * @param extension the extension to add.
      */
     void addExtension(Extension* extension);
 
     /**
      * return a list with all registered extension objects.
      */
     QList<Extension*> extensions();
 
     /**
      * @brief addDockWidgetFactory Add the given docker factory to the application. For scripts
      * loaded on startup, this means that every window will have one of the dockers created by the
      * factory.
      * @param factory The factory object.
      */
     void addDockWidgetFactory(DockWidgetFactoryBase* factory );
 
     /**
      * @brief writeSetting write the given setting under the given name to the kritarc file in
      * the given settings group.
      * @param group The group the setting belongs to. If empty, then the setting is written in the
      * general section
      * @param name The name of the setting
      * @param value The value of the setting. Script settings are always written as strings.
      */
     void writeSetting(const QString &group, const QString &name, const QString &value);
 
     /**
      * @brief readSetting read the given setting value from the kritarc file.
      * @param group The group the setting is part of. If empty, then the setting is read from
      * the general group.
      * @param name The name of the setting
      * @param defaultValue The default value of the setting
      * @return a string representing the setting.
      */
     QString readSetting(const QString &group, const QString &name, const QString &defaultValue);
 
     /**
      * @brief icon
      * This allows you to get icons from Krita's internal icons.
      * @param iconName name of the icon.
      * @return the icon related to this name.
      */
     QIcon icon(QString &iconName) const;
 
     /**
      * @brief instance retrieve the singleton instance of the Application object.
      */
     static Krita* instance();
 
     // Internal only: for use with mikro.py
     static QObject *fromVariant(const QVariant& v);
 
+    static QString krita_i18n(const QString &text);
+
 private Q_SLOTS:
 
     void mainWindowAdded(KisMainWindow *window);
 
 private:
     struct Private;
     Private *const d;
     static Krita* s_instance;
 
 };
 
 Q_DECLARE_METATYPE(Notifier*);
 
 #endif // LIBKIS_KRITA_H
diff --git a/plugins/extensions/pykrita/plugin/krita/__init__.py b/plugins/extensions/pykrita/plugin/krita/__init__.py
index 0feb22fbc4..573628f949 100644
--- a/plugins/extensions/pykrita/plugin/krita/__init__.py
+++ b/plugins/extensions/pykrita/plugin/krita/__init__.py
@@ -1,77 +1,77 @@
 from __future__ import print_function
 
 import pykrita
 import os
 import sys
 
 from .api import *
 from .decorators import *
 from .dockwidgetfactory import *
 from PyKrita import krita
 
 import signal
 signal.signal(signal.SIGINT, signal.SIG_DFL)
 
 krita_path = os.path.dirname(os.path.abspath(__file__))
 sys.path.insert(0, krita_path)
 print("%s added to PYTHONPATH" % krita_path, file=sys.stderr)
 
 # Look for PyQt
 try:
     from PyQt5 import QtCore
 except ImportError:
     print("Python cannot find the Qt5 bindings.", file=sys.stderr)
     print("Please make sure, that the needed packages are installed.", file=sys.stderr)
     raise
 
 # Shows nice looking error dialog if an unhandled exception occurs.
 import excepthook
 excepthook.install()
 
 if sys.version_info[0] > 2:
     import builtins
 else:
     import __builtin__ as builtins
-builtins.i18n = lambda s: QCoreApplication.translate("PyKrita", s)
+builtins.i18n = Krita.krita_i18n
 builtins.Scripter = Krita.instance()
 builtins.Application = Krita.instance()
 builtins.Krita = Krita.instance()
 
 
 def qDebug(text):
     '''Use KDE way to show debug info
 
         TODO Add a way to control debug output from partucular plugins (?)
     '''
     plugin = sys._getframe(1).f_globals['__name__']
     pykrita.qDebug('{}: {}'.format(plugin, text))
 
 
 @pykritaEventHandler('_pluginLoaded')
 def on_load(plugin):
     if plugin in init.functions:
         # Call registered init functions for the plugin
         init.fire(plugin=plugin)
         del init.functions[plugin]
     return True
 
 
 @pykritaEventHandler('_pluginUnloading')
 def on_unload(plugin):
     if plugin in unload.functions:
         # Deinitialize plugin
         unload.fire(plugin=plugin)
         del unload.functions[plugin]
     return True
 
 
 @pykritaEventHandler('_pykritaLoaded')
 def on_pykrita_loaded():
     qDebug('PYKRITA LOADED')
     return True
 
 
 @pykritaEventHandler('_pykritaUnloading')
 def on_pykrita_unloading():
     qDebug('UNLOADING PYKRITA')
     return True
diff --git a/plugins/extensions/pykrita/sip/krita/Krita.sip b/plugins/extensions/pykrita/sip/krita/Krita.sip
index 9132ce4eff..e4ca56ba0a 100644
--- a/plugins/extensions/pykrita/sip/krita/Krita.sip
+++ b/plugins/extensions/pykrita/sip/krita/Krita.sip
@@ -1,63 +1,64 @@
 
 class Krita : QObject
 {
 %TypeHeaderCode
 #include "Krita.h"
 %End
 public:
     Krita(QObject*  parent /TransferThis/ = 0);
     virtual ~Krita();
 public Q_SLOTS:
 
     Document * activeDocument() const /Factory/;
     void setActiveDocument(Document*  value);
     bool batchmode() const;
     void setBatchmode(bool value);
     QList<QAction *> actions() const;
     QAction *action(const QString & name) const;
     QList<Document *> documents() const /Factory/;
     QStringList filters() const;
     Filter * filter(const QString &name) const /Factory/;
     QStringList colorModels() const;
     QStringList colorDepths(const QString &colorModel) const;
     QStringList filterStrategies() const;
     QStringList profiles(const QString &colorModel, const QString &ColorDepth) const;
     bool addProfile(const QString &profilePath);
     Notifier * notifier() const;
     QString version() const;
     QList<View *> views() const /Factory/;
     Window * activeWindow() const /Factory/;
     QList<Window *> windows() const /Factory/;
     QMap<QString, Resource *> resources(const QString &type) const /Factory/;
     QStringList recentDocuments() const;
     Document * createDocument(int width, int height, const QString &name, const QString &colorModel, const QString &colorDepth, const QString &profile, double resolution)  /Factory/;
     QList<Extension*> extensions() /Factory/;
     Document * openDocument(const QString &filename)  /Factory/;
     Window * openWindow();
     QIcon icon(QString &iconName) const;
 
     void addExtension(Extension* _extension /GetWrapper/);
 %MethodCode
         Py_BEGIN_ALLOW_THREADS
         sipCpp->addExtension(a0);
         Py_END_ALLOW_THREADS
 
         sipTransferTo(a0Wrapper, Py_None);
 %End
     void addDockWidgetFactory(DockWidgetFactoryBase* _factory /GetWrapper/);
 %MethodCode
         Py_BEGIN_ALLOW_THREADS
         sipCpp->addDockWidgetFactory(a0);
         Py_END_ALLOW_THREADS
 
         sipTransferTo(a0Wrapper, Py_None);
 %End
 
     void writeSetting(const QString &group, const QString &name, const QString &value);
     QString readSetting(const QString &group, const QString &name, const QString &defaultValue);
 
     static Krita * instance();
     static QObject * fromVariant(const QVariant & v);
+    static QString krita_i18n(const QString &text);
 private:
     Krita(const Krita &); // Generated
 };