diff --git a/3rdparty/CMakeLists.txt b/3rdparty/CMakeLists.txt
index 7b0525d989..d37334a163 100644
--- a/3rdparty/CMakeLists.txt
+++ b/3rdparty/CMakeLists.txt
@@ -1,212 +1,216 @@
 project (krita-and-all-its-deps)
 
 #
 # Build all dependencies for Krita and finally Krita itself.
 # Parameters: EXTERNALS_DOWNLOAD_DIR place to download all packages
 #             INSTALL_ROOT place to install everything to
 #             MXE_TOOLCHAIN: the toolchain file to cross-compile using MXE
-# 
+#
 # Example usage: cmake ..\kritadeposx -DEXTERNALS_DOWNLOAD_DIR=/dev2/d -DINSTALL_ROOT=/dev2/i -DWIN64_BUILD=TRUE  -DBOOST_LIBRARYDIR=/dev2/i/lib   -G "Visual Studio 11 Win64"
 
 
 cmake_minimum_required(VERSION 2.8.6)
 
 if(NOT SUBMAKE_JOBS)
 	set(SUBMAKE_JOBS 1)
 endif(NOT SUBMAKE_JOBS)
 
 if (CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR)
 	message(FATAL_ERROR "Compiling in the source directory is not supported. Use for example 'mkdir build; cd build; cmake ..'.")
 endif (CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR)
 
 # Tools must be obtained to work with:
 include (ExternalProject)
 
 # allow specification of a directory with pre-downloaded
 # requirements
 if(NOT IS_DIRECTORY ${EXTERNALS_DOWNLOAD_DIR})
     message(FATAL_ERROR "No externals download dir set. Use -DEXTERNALS_DOWNLOAD_DIR")
 endif()
 
 if(NOT IS_DIRECTORY ${INSTALL_ROOT})
     message(FATAL_ERROR "No install dir set. Use -DINSTALL_ROOT")
 endif()
 
 set(TOP_INST_DIR ${INSTALL_ROOT})
 set(EXTPREFIX "${TOP_INST_DIR}")
 set(CMAKE_PREFIX_PATH "${EXTPREFIX}")
 
 if (${CMAKE_GENERATOR} STREQUAL "Visual Studio 14 2015 Win64")
-    SET(GLOBAL_PROFILE 
-        -DCMAKE_MODULE_LINKER_FLAGS=/machine:x64 
-        -DCMAKE_EXE_LINKER_FLAGS=/machine:x64 
-        -DCMAKE_SHARED_LINKER_FLAGS=/machine:x64 
-        -DCMAKE_STATIC_LINKER_FLAGS=/machine:x64 
+    SET(GLOBAL_PROFILE
+        -DCMAKE_MODULE_LINKER_FLAGS=/machine:x64
+        -DCMAKE_EXE_LINKER_FLAGS=/machine:x64
+        -DCMAKE_SHARED_LINKER_FLAGS=/machine:x64
+        -DCMAKE_STATIC_LINKER_FLAGS=/machine:x64
     )
 endif ()
 
 message( STATUS "CMAKE_GENERATOR: ${CMAKE_GENERATOR}")
 message( STATUS "CMAKE_CL_64: ${CMAKE_CL_64}")
 
 set(GLOBAL_BUILD_TYPE RelWithDebInfo)
 set(GLOBAL_PROFILE ${GLOBAL_PROFILE} -DBUILD_TESTING=false)
 
 if (MINGW)
 	option(QT_ENABLE_DEBUG_INFO "Build Qt with debug info included" OFF)
 	option(QT_ENABLE_DYNAMIC_OPENGL "Build Qt with dynamic ANGLE support '-opengl dynamic -angle' (needs env var 'WindowsSdkDir' set to path of Windows 10 SDK)" ON)
     if (QT_ENABLE_DYNAMIC_OPENGL)
 		if (DEFINED ENV{WindowsSdkDir})
 			message(STATUS "WindowsSdkDir is set to '$ENV{WindowsSdkDir}'")
 		else (DEFINED ENV{WindowsSdkDir})
 			message(FATAL_ERROR "Environment variable 'WindowsSdkDir' not set! Please set it to path of Windows 10 SDK or disable QT_ENABLE_DYNAMIC_OPENGL")
 		endif (DEFINED ENV{WindowsSdkDir})
 	endif (QT_ENABLE_DYNAMIC_OPENGL)
 endif (MINGW)
 
 set(SECURITY_EXE_LINKER_FLAGS "")
 set(SECURITY_SHARED_LINKER_FLAGS "")
 set(SECURITY_MODULE_LINKER_FLAGS "")
 if (MINGW)
 	option(USE_MINGW_HARDENING_LINKER "Enable DEP (NX), ASLR and high-entropy ASLR linker flags (mingw-w64)" ON)
 	if (USE_MINGW_HARDENING_LINKER)
 		set(SECURITY_EXE_LINKER_FLAGS "-Wl,--dynamicbase -Wl,--nxcompat -Wl,--disable-auto-image-base")
 		set(SECURITY_SHARED_LINKER_FLAGS "-Wl,--dynamicbase -Wl,--nxcompat -Wl,--disable-auto-image-base")
 		set(SECURITY_MODULE_LINKER_FLAGS "-Wl,--dynamicbase -Wl,--nxcompat -Wl,--disable-auto-image-base")
 		if ("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
 			# Enable high-entropy ASLR for 64-bit
 			# The image base has to be >4GB for HEASLR to be enabled.
 			# The values used here are kind of arbitrary.
 			set(SECURITY_EXE_LINKER_FLAGS "${SECURITY_EXE_LINKER_FLAGS} -Wl,--high-entropy-va -Wl,--image-base,0x140000000")
 			set(SECURITY_SHARED_LINKER_FLAGS "${SECURITY_SHARED_LINKER_FLAGS} -Wl,--high-entropy-va -Wl,--image-base,0x180000000")
 			set(SECURITY_MODULE_LINKER_FLAGS "${SECURITY_MODULE_LINKER_FLAGS} -Wl,--high-entropy-va -Wl,--image-base,0x180000000")
 			set(GLOBAL_PROFILE ${GLOBAL_PROFILE}
 				-DCMAKE_EXE_LINKER_FLAGS=${SECURITY_EXE_LINKER_FLAGS}
 				-DCMAKE_SHARED_LINKER_FLAGS=${SECURITY_SHARED_LINKER_FLAGS}
 				-DCMAKE_MODULE_LINKER_FLAGS=${SECURITY_MODULE_LINKER_FLAGS}
 			)
 		endif ("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
 	else (USE_MINGW_HARDENING_LINKER)
 		message(WARNING "Linker Security Flags not enabled!")
 	endif (USE_MINGW_HARDENING_LINKER)
 endif (MINGW)
 
 if (DEFINED EP_PREFIX)
 	set_directory_properties(PROPERTIES EP_PREFIX ${EP_PREFIX})
 endif (DEFINED EP_PREFIX)
 
 if (MSVC)
         set(GLOBAL_PROFILE ${GLOBAL_PROFILE} -DCMAKE_EXE_LINKER_FLAGS=/PROFILE -DCMAKE_SHARED_LINKER_FLAGS=/PROFILE)
 	set(PATCH_COMMAND myptch)
 endif()
 
 if (MINGW)
    set(PATCH_COMMAND myptch)
 endif()
 
 if (MSYS)
 	set(PATCH_COMMAND patch)
-    set(GLOBAL_PROFILE ${GLOBAL_PROFILE} 
+    set(GLOBAL_PROFILE ${GLOBAL_PROFILE}
                            -DCMAKE_TOOLCHAIN_FILE=${MXE_TOOLCHAIN}
                            -DCMAKE_FIND_PREFIX_PATH=${CMAKE_PREFIX_PATH}
                            -DCMAKE_SYSTEM_INCLUDE_PATH=${CMAKE_PREFIX_PATH}/include
-                           -DCMAKE_INCLUDE_PATH=${CMAKE_PREFIX_PATH}/include 
+                           -DCMAKE_INCLUDE_PATH=${CMAKE_PREFIX_PATH}/include
                            -DCMAKE_LIBRARY_PATH=${CMAKE_PREFIX_PATH}/lib
                            -DZLIB_ROOT=${CMAKE_PREFIX_PATH}
     )
     set(GLOBAL_AUTOMAKE_PROFILE  --host=i686-pc-mingw32 )
-endif() 
+endif()
 
 if (APPLE)
     set(GLOBAL_PROFILE ${GLOBAL_PROFILE} -DCMAKE_MACOSX_RPATH=ON -DKDE_SKIP_RPATH_SETTINGS=ON -DBUILD_WITH_INSTALL_RPATH=ON -DAPPLE_SUPPRESS_X11_WARNING=ON)
     set(PATCH_COMMAND patch)
 endif ()
 
 if (UNIX AND NOT APPLE)
 	set(LINUX true)
     set(PATCH_COMMAND patch)
 endif ()
 
 function(TestCompileLinkPythonLibs OUTPUT_VARNAME)
 	include(CheckCXXSourceCompiles)
 	set(CMAKE_REQUIRED_INCLUDES ${PYTHON_INCLUDE_PATH})
 	set(CMAKE_REQUIRED_LIBRARIES ${PYTHON_LIBRARIES})
 	if (MINGW)
 		set(CMAKE_REQUIRED_DEFINITIONS -D_hypot=hypot)
 	endif (MINGW)
 	unset(${OUTPUT_VARNAME} CACHE)
 	CHECK_CXX_SOURCE_COMPILES("
 #include <Python.h>
 int main(int argc, char *argv[]) {
 	Py_InitializeEx(0);
 }" ${OUTPUT_VARNAME})
 endfunction()
 
 if (MINGW)
 	option(ENABLE_PYTHON_DEPS "Enable Python deps (sip, pyqt)" ON)
 	if (ENABLE_PYTHON_DEPS)
-		find_package(PythonInterp 3.6 EXACT)
-		find_package(PythonLibs 3.6 EXACT)
+        if (ENABLE_PYTHON_2)
+            message(FATAL_ERROR "Python 2.7 is not supported on Windows at the moment.")
+        else(ENABLE_PYTHON_2)
+            find_package(PythonInterp 3.6 EXACT)
+            find_package(PythonLibs 3.6 EXACT)
+        endif(ENABLE_PYTHON_2)
 		if (PYTHONLIBS_FOUND AND PYTHONINTERP_FOUND)
 			message(STATUS "Python requirements met.")
 			TestCompileLinkPythonLibs(CAN_USE_PYTHON_LIBS)
 			if (NOT CAN_USE_PYTHON_LIBS)
 				message(FATAL_ERROR "Compiling with Python library failed, please check whether the architecture is correct!")
 			endif (NOT CAN_USE_PYTHON_LIBS)
 		else (PYTHONLIBS_FOUND AND PYTHONINTERP_FOUND)
 			message(FATAL_ERROR "Python requirements not met. To disable Python deps, set ENABLE_PYTHON_DEPS to OFF.")
 		endif (PYTHONLIBS_FOUND AND PYTHONINTERP_FOUND)
 	endif (ENABLE_PYTHON_DEPS)
 endif (MINGW)
 
 # this list must be dependency-ordered
 if (ENABLE_PYTHON_DEPS OR NOT MINGW)
 	add_subdirectory( ext_python )
 endif (ENABLE_PYTHON_DEPS OR NOT MINGW)
 if (MSVC)
     add_subdirectory( ext_patch )
     add_subdirectory( ext_png2ico )
 endif (MSVC)
 if (MINGW)
     add_subdirectory( ext_patch )
     add_subdirectory( ext_png2ico )
 endif (MINGW)
 add_subdirectory( ext_iconv )
 add_subdirectory( ext_gettext )
 add_subdirectory( ext_zlib )
 add_subdirectory( ext_boost )
 add_subdirectory( ext_jpeg )
 add_subdirectory( ext_tiff )
 add_subdirectory( ext_png )
 add_subdirectory( ext_eigen3 )
 add_subdirectory( ext_expat ) # for exiv2
 add_subdirectory( ext_exiv2 )
 add_subdirectory( ext_ilmbase )
 add_subdirectory( ext_lcms2 )
 add_subdirectory( ext_openexr )
 add_subdirectory( ext_vc )
 add_subdirectory( ext_gsl )
 add_subdirectory( ext_fftw3 )
 add_subdirectory( ext_ocio )
 if (MSVC)
     add_subdirectory( ext_pthreads )
 endif (MSVC)
 add_subdirectory( ext_fontconfig)
 add_subdirectory( ext_freetype)
 add_subdirectory( ext_qt )
 add_subdirectory( ext_poppler )
 add_subdirectory( ext_libraw )
 add_subdirectory( ext_frameworks )
 if (ENABLE_PYTHON_DEPS OR NOT MINGW)
 	add_subdirectory( ext_sip )
 	add_subdirectory( ext_pyqt )
 endif (ENABLE_PYTHON_DEPS OR NOT MINGW)
 
 if (MSVC OR MINGW)
     add_subdirectory( ext_drmingw )
 endif (MSVC OR MINGW)
 
 if (NOT APPLE)
 	add_subdirectory( ext_gmic )
 endif (NOT APPLE)
 
 add_subdirectory(ext_giflib)
diff --git a/CMakeLists.txt b/CMakeLists.txt
index d419b6312c..e4e30d59f0 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,733 +1,747 @@
 project(krita)
 
 message(STATUS "Using CMake version: ${CMAKE_VERSION}")
 
 cmake_minimum_required(VERSION 2.8.12 FATAL_ERROR)
 
 set(MIN_QT_VERSION 5.6.0)
 option(OVERRIDE_QT_VERSION "Use this to make it possible to build with Qt < 5.6.0. There will be bugs." OFF)
 if (OVERRIDE_QT_VERSION)
     set(MIN_QT_VERSION 5.4.0)
 endif()
 
 set(MIN_FRAMEWORKS_VERSION 5.7.0)
 
 if (POLICY CMP0002)
     cmake_policy(SET CMP0002 OLD)
 endif()
 
 if (POLICY CMP0017)
     cmake_policy(SET CMP0017 NEW)
 endif ()
 
 if (POLICY CMP0022)
     cmake_policy(SET CMP0022 OLD)
 endif ()
 
 if (POLICY CMP0026)
     cmake_policy(SET CMP0026 OLD)
 endif()
 
 if (POLICY CMP0042)
     cmake_policy(SET CMP0042 NEW)
 endif()
 
 if (POLICY CMP0046)
     cmake_policy(SET CMP0046 OLD)
 endif ()
 
 if (POLICY CMP0059)
     cmake_policy(SET CMP0059 OLD)
 endif()
 
 if (POLICY CMP0063)
     cmake_policy(SET CMP0063 OLD)
 endif()
 
 if (POLICY CMP0054)
     cmake_policy(SET CMP0054 OLD)
 endif()
 
 if (POLICY CMP0064)
     cmake_policy(SET CMP0064 OLD)
 endif()
 
 
 if (APPLE)
     set(APPLE_SUPPRESS_X11_WARNING TRUE)
     set(KDE_SKIP_RPATH_SETTINGS TRUE)
     set(CMAKE_MACOSX_RPATH 1)
     set(BUILD_WITH_INSTALL_RPATH 1)
     add_definitions(-mmacosx-version-min=10.9 -Wno-macro-redefined -Wno-deprecated-register)
 endif()
 
 if (LINUX)
     if (CMAKE_COMPILER_IS_GNUCXX AND NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.9 AND NOT WINDOWS)
         add_definitions(-Werror=delete-incomplete)
     endif()
 endif()
 
  ######################
 #######################
 ## Constants defines ##
 #######################
 ######################
 
 # define common versions of Krita applications, used to generate kritaversion.h
 # update these version for every release:
 set(KRITA_VERSION_STRING "4.0.3")
 # Major version: 3 for 3.x, 4 for 4.x, etc.
 set(KRITA_STABLE_VERSION_MAJOR 4)
 # Minor version: 0 for 4.0, 1 for 4.1, etc.
 set(KRITA_STABLE_VERSION_MINOR 0)
 # Bugfix release version, or 0 for before the first stable release
 set(KRITA_VERSION_RELEASE 3)
 # the 4th digit, really only used for the Windows installer:
 # - [Pre-]Alpha: Starts from 0, increment 1 per release
 # - Beta: Starts from 50, increment 1 per release
 # - Stable: Set to 100, bump to 101 if emergency update is needed
 set(KRITA_VERSION_REVISION 100)
 #set(KRITA_ALPHA 1) # uncomment only for Alpha
 #set(KRITA_BETA 1) # uncomment only for Beta
 #set(KRITA_RC 1) # uncomment only for RC
 set(KRITA_YEAR 2018) # update every year
 
 if(NOT DEFINED KRITA_ALPHA AND NOT DEFINED KRITA_BETA AND NOT DEFINED KRITA_RC)
     set(KRITA_STABLE 1) # do not edit
 endif()
 
 message(STATUS "Krita version: ${KRITA_VERSION_STRING}")
 
 # Define the generic version of the Krita libraries here
 # This makes it easy to advance it when the next Krita release comes.
 # 14 was the last GENERIC_KRITA_LIB_VERSION_MAJOR of the previous Krita series
 # (2.x) so we're starting with 15 in 3.x series, 16 in 4.x series
 if(KRITA_STABLE_VERSION_MAJOR EQUAL 4)
     math(EXPR GENERIC_KRITA_LIB_VERSION_MAJOR "${KRITA_STABLE_VERSION_MINOR} + 16")
 else()
     # let's make sure we won't forget to update the "16"
     message(FATAL_ERROR "Reminder: please update offset == 16 used to compute GENERIC_KRITA_LIB_VERSION_MAJOR to something bigger")
 endif()
 set(GENERIC_KRITA_LIB_VERSION "${GENERIC_KRITA_LIB_VERSION_MAJOR}.0.0")
 set(GENERIC_KRITA_LIB_SOVERSION "${GENERIC_KRITA_LIB_VERSION_MAJOR}")
 
 LIST (APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/modules")
 LIST (APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/kde_macro")
 
 # fetch git revision for the current build
 
 set(KRITA_GIT_SHA1_STRING "")
 set(KRITA_GIT_BRANCH_STRING "")
 
 include(GetGitRevisionDescription)
 get_git_head_hash(GIT_SHA1)
 get_git_branch(GIT_BRANCH)
 
 if(GIT_SHA1)
    string(SUBSTRING ${GIT_SHA1} 0 7 GIT_SHA1)
    set(KRITA_GIT_SHA1_STRING ${GIT_SHA1})
    if(GIT_BRANCH)
        set(KRITA_GIT_BRANCH_STRING ${GIT_BRANCH})
    else()
        set(KRITA_GIT_BRANCH_STRING "(detached HEAD)")
    endif()
 endif()
 
 if(NOT DEFINED RELEASE_BUILD)
     # estimate mode by CMAKE_BUILD_TYPE content if not set on cmdline
     string(TOLOWER "${CMAKE_BUILD_TYPE}" CMAKE_BUILD_TYPE_TOLOWER)
     set(RELEASE_BUILD_TYPES "release" "relwithdebinfo" "minsizerel")
     list(FIND RELEASE_BUILD_TYPES "${CMAKE_BUILD_TYPE_TOLOWER}" INDEX)
     if (INDEX EQUAL -1)
         set(RELEASE_BUILD FALSE)
     else()
         set(RELEASE_BUILD TRUE)
     endif()
 endif()
 message(STATUS "Release build: ${RELEASE_BUILD}")
 
 # create test make targets
 enable_testing()
 # collect list of broken tests, empty here to start fresh with each cmake run
 set(KRITA_BROKEN_TESTS "" CACHE INTERNAL "KRITA_BROKEN_TESTS")
 
  ############
 #############
 ## Options ##
 #############
 ############
 
 include(FeatureSummary)
 
 if (WIN32)
     option(USE_DRMINGW "Support the Dr. Mingw crash handler (only on windows)" ON)
     add_feature_info("Dr. Mingw" USE_DRMINGW "Enable the Dr. Mingw crash handler")
 
     if (MINGW)
         option(USE_MINGW_HARDENING_LINKER "Enable DEP (NX), ASLR and high-entropy ASLR linker flags (mingw-w64)" ON)
         add_feature_info("Linker Security Flags" USE_MINGW_HARDENING_LINKER "Enable DEP (NX), ASLR and high-entropy ASLR linker flags")
         if (USE_MINGW_HARDENING_LINKER)
             set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--dynamicbase -Wl,--nxcompat -Wl,--disable-auto-image-base")
             set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--dynamicbase -Wl,--nxcompat -Wl,--disable-auto-image-base")
             set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -Wl,--dynamicbase -Wl,--nxcompat -Wl,--disable-auto-image-base")
             if ("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
                 # Enable high-entropy ASLR for 64-bit
                 # The image base has to be >4GB for HEASLR to be enabled.
                 # The values used here are kind of arbitrary.
                 set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--high-entropy-va -Wl,--image-base,0x140000000")
                 set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--high-entropy-va -Wl,--image-base,0x180000000")
                 set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -Wl,--high-entropy-va -Wl,--image-base,0x180000000")
             endif ("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
         else (USE_MINGW_HARDENING_LINKER)
             message(WARNING "Linker Security Flags not enabled!")
         endif (USE_MINGW_HARDENING_LINKER)
     endif (MINGW)
 endif ()
 
 option(HIDE_SAFE_ASSERTS "Don't show message box for \"safe\" asserts, just ignore them automatically and dump a message to the terminal." ON)
 configure_file(config-hide-safe-asserts.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-hide-safe-asserts.h)
 add_feature_info("Safe Asserts" HIDE_SAFE_ASSERTS "Don't show message box for \"safe\" asserts, just ignore them automatically and dump a message to the terminal.")
 
 option(FOUNDATION_BUILD "A Foundation build is a binary release build that can package some extra things like color themes. Linux distributions that build and install Krita into a default system location should not define this option to true." OFF)
 add_feature_info("Foundation Build" FOUNDATION_BUILD "A Foundation build is a binary release build that can package some extra things like color themes. Linux distributions that build and install Krita into a default system location should not define this option to true.")
 
 option(KRITA_ENABLE_BROKEN_TESTS "Enable tests that are marked as broken" OFF)
 add_feature_info("Enable Broken Tests" KRITA_ENABLE_BROKEN_TESTS "Runs broken test when \"make test\" is invoked (use -DKRITA_ENABLE_BROKEN_TESTS=ON to enable).")
 
+option(ENABLE_PYTHON_2 "Enables the compiler to look for Python 2.7 instead of Python 3. Some packaged scripts are not compatible with Python 2 and this should only be used if you really have to use 2.7." OFF)
 
 include(MacroJPEG)
 
  #########################################################
 ## Look for Python3 It is also searched by KF5,         ##
 ## so we should request the correct version in advance  ##
 #########################################################
 
 function(TestCompileLinkPythonLibs OUTPUT_VARNAME)
     include(CheckCXXSourceCompiles)
     set(CMAKE_REQUIRED_INCLUDES ${PYTHON_INCLUDE_PATH})
     set(CMAKE_REQUIRED_LIBRARIES ${PYTHON_LIBRARIES})
     if (MINGW)
         set(CMAKE_REQUIRED_DEFINITIONS -D_hypot=hypot)
     endif (MINGW)
     unset(${OUTPUT_VARNAME} CACHE)
     CHECK_CXX_SOURCE_COMPILES("
 #include <Python.h>
 int main(int argc, char *argv[]) {
     Py_InitializeEx(0);
 }" ${OUTPUT_VARNAME})
 endfunction()
 
 if(MINGW)
-    find_package(PythonInterp 3.6 EXACT)
-    find_package(PythonLibs 3.6 EXACT)
+    if(ENABLE_PYTHON_2)
+        message(FATAL_ERROR "Python 2.7 is not supported on Windows at the moment.")
+    else(ENABLE_PYTHON_2)
+        find_package(PythonInterp 3.6 EXACT)
+        find_package(PythonLibs 3.6 EXACT)
+    endif(ENABLE_PYTHON_2)
     if (PYTHONLIBS_FOUND AND PYTHONINTERP_FOUND)
-        find_package(PythonLibrary 3.6)
+        if(ENABLE_PYTHON_2)
+            find_package(PythonLibrary 2.7)
+        else(ENABLE_PYTHON_2)
+            find_package(PythonLibrary 3.6)
+        endif(ENABLE_PYTHON_2)
         TestCompileLinkPythonLibs(CAN_USE_PYTHON_LIBS)
         if (NOT CAN_USE_PYTHON_LIBS)
             message(FATAL_ERROR "Compiling with Python library failed, please check whether the architecture is correct. Python will be disabled.")
         endif (NOT CAN_USE_PYTHON_LIBS)
     endif (PYTHONLIBS_FOUND AND PYTHONINTERP_FOUND)
 else(MINGW)
-    find_package(PythonInterp 3.0)
-    find_package(PythonLibrary 3.0)
+    if(ENABLE_PYTHON_2)
+        find_package(PythonInterp 2.7)
+        find_package(PythonLibrary 2.7)
+    else(ENABLE_PYTHON_2)
+        find_package(PythonInterp 3.0)
+        find_package(PythonLibrary 3.0)
+    endif(ENABLE_PYTHON_2)
 endif(MINGW)
 
  ########################
 #########################
 ## Look for KDE and Qt ##
 #########################
 ########################
 
 find_package(ECM 5.19 REQUIRED NOMODULE)
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${ECM_MODULE_PATH} ${ECM_KDE_MODULE_DIR})
 include(ECMOptionalAddSubdirectory)
 include(ECMAddAppIcon)
 include(ECMSetupVersion)
 include(ECMMarkNonGuiExecutable)
 include(ECMGenerateHeaders)
 include(GenerateExportHeader)
 include(ECMMarkAsTest)
 include(ECMInstallIcons)
 
 include(CMakePackageConfigHelpers)
 include(WriteBasicConfigVersionFile)
 include(CheckFunctionExists)
 
 include(KDEInstallDirs)
 include(KDECMakeSettings)
 include(KDECompilerSettings)
 
 # do not reorder to be alphabetical: this is the order in which the frameworks
 # depend on each other.
 find_package(KF5 ${MIN_FRAMEWORKS_VERSION} REQUIRED COMPONENTS
         Archive
         Config
         WidgetsAddons
         Completion
         CoreAddons
         GuiAddons
         I18n
         ItemModels
         ItemViews
         WindowSystem
 )
 
 # KConfig deprecated authorizeKAction. In order to be warning free,
 # compile with the updated function when the dependency is new enough.
 # Remove this (and the uses of the define) when the minimum KF5
 # version is >= 5.24.0.
 if (${KF5Config_VERSION} VERSION_LESS "5.24.0" )
     message("Old KConfig (< 5.24.0) found.")
     add_definitions(-DKCONFIG_BEFORE_5_24)
 endif()
 
 find_package(Qt5 ${MIN_QT_VERSION}
         REQUIRED COMPONENTS
         Core
         Gui
         Widgets
         Xml
         Network
         PrintSupport
         Svg
         Test
         Concurrent
 )
 
 include (MacroAddFileDependencies)
 include (MacroBoolTo01)
 include (MacroEnsureOutOfSourceBuild)
 macro_ensure_out_of_source_build("Compiling Krita inside the source directory is not possible. Please refer to the build instruction https://community.kde.org/Krita#Build_Instructions")
 
 
 
 # Note: OPTIONAL_COMPONENTS does not seem to be reliable
 # (as of ECM 5.15.0, CMake 3.2)
 
 find_package(Qt5Multimedia ${MIN_QT_VERSION})
 set_package_properties(Qt5Multimedia PROPERTIES
         DESCRIPTION "Qt multimedia integration"
         URL "http://www.qt.io/"
         TYPE OPTIONAL
         PURPOSE "Optionally used to provide sound support for animations")
 
 macro_bool_to_01(Qt5Multimedia_FOUND HAVE_QT_MULTIMEDIA)
 configure_file(config-qtmultimedia.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-qtmultimedia.h )
 
 if (NOT APPLE)
 find_package(Qt5Quick ${MIN_QT_VERSION})
 set_package_properties(Qt5Quick PROPERTIES
         DESCRIPTION "QtQuick"
         URL "http://www.qt.io/"
         TYPE OPTIONAL
         PURPOSE "Optionally used for the touch gui for Krita")
 
 macro_bool_to_01(Qt5Quick_FOUND HAVE_QT_QUICK)
 
 find_package(Qt5QuickWidgets ${MIN_QT_VERSION})
 set_package_properties(Qt5QuickWidgets PROPERTIES
         DESCRIPTION "QtQuickWidgets"
         URL "http://www.qt.io/"
         TYPE OPTIONAL
         PURPOSE "Optionally used for the touch gui for Krita")
 endif()
 
 if (NOT WIN32 AND NOT APPLE)
 
     find_package(Qt5 ${MIN_QT_VERSION} REQUIRED X11Extras)
 
     find_package(Qt5DBus ${MIN_QT_VERSION})
     set(HAVE_DBUS ${Qt5DBus_FOUND})
     set_package_properties(Qt5DBus PROPERTIES
         DESCRIPTION "Qt DBUS integration"
         URL "http://www.qt.io/"
         TYPE OPTIONAL
         PURPOSE "Optionally used to provide a dbus api on Linux")
 
     find_package(KF5KIO ${MIN_FRAMEWORKS_VERSION})
     macro_bool_to_01(KF5KIO_FOUND HAVE_KIO)
     set_package_properties(KF5KIO PROPERTIES
         DESCRIPTION "KDE's KIO Framework"
         URL "http://api.kde.org/frameworks-api/frameworks5-apidocs/kio/html/index.html"
         TYPE OPTIONAL
         PURPOSE "Optionally used for recent document handling")
 
     find_package(KF5Crash ${MIN_FRAMEWORKS_VERSION})
     macro_bool_to_01(KF5Crash_FOUND HAVE_KCRASH)
     set_package_properties(KF5Crash PROPERTIES
         DESCRIPTION "KDE's Crash Handler"
         URL "http://api.kde.org/frameworks-api/frameworks5-apidocs/kcrash/html/index.html"
         TYPE OPTIONAL
         PURPOSE "Optionally used to provide crash reporting on Linux")
 
     find_package(X11 REQUIRED COMPONENTS Xinput)
     set(HAVE_X11 TRUE)
     add_definitions(-DHAVE_X11)
 
     find_package(XCB COMPONENTS XCB ATOM)
     set(HAVE_XCB ${XCB_FOUND})
 else()
     set(HAVE_DBUS FALSE)
     set(HAVE_X11 FALSE)
     set(HAVE_XCB FALSE)
 endif()
 
 
 add_definitions(
   -DQT_USE_QSTRINGBUILDER
   -DQT_STRICT_ITERATORS
   -DQT_NO_SIGNALS_SLOTS_KEYWORDS
   -DQT_USE_FAST_OPERATOR_PLUS
   -DQT_USE_FAST_CONCATENATION
   -DQT_NO_URL_CAST_FROM_STRING
 )
 
 if (${Qt5_VERSION} VERSION_GREATER "5.8.0" )
     add_definitions(-DQT_DISABLE_DEPRECATED_BEFORE=0x50900)
 elseif(${Qt5_VERSION} VERSION_GREATER "5.7.0" )
     add_definitions(-DQT_DISABLE_DEPRECATED_BEFORE=0x50800)
 elseif(${Qt5_VERSION} VERSION_GREATER "5.6.0" )
     add_definitions(-DQT_DISABLE_DEPRECATED_BEFORE=0x50700)
 else()
     add_definitions(-DQT_DISABLE_DEPRECATED_BEFORE=0x50600)
 endif()
 
 add_definitions(-DTRANSLATION_DOMAIN=\"krita\")
 
 #
 # The reason for this mode is that the Debug mode disable inlining
 #
 if(CMAKE_COMPILER_IS_GNUCXX)
     set(CMAKE_CXX_FLAGS_KRITADEVS "-O3 -g" CACHE STRING "" FORCE)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}  -fext-numeric-literals")
 endif()
 
 if(UNIX)
     set(CMAKE_REQUIRED_LIBRARIES "${CMAKE_REQUIRED_LIBRARIES};m")
 endif()
 
 if(WIN32)
     if(MSVC)
         # C4522: 'class' : multiple assignment operators specified
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -wd4522")
     endif()
 endif()
 
 # KDECompilerSettings adds the `--export-all-symbols` linker flag.
 # We don't really need it.
 if(MINGW)
     string(REPLACE "-Wl,--export-all-symbols" "" CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS}")
     string(REPLACE "-Wl,--export-all-symbols" "" CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS}")
 endif(MINGW)
 
 # enable exceptions globally
 kde_enable_exceptions()
 
 set(KRITA_DEFAULT_TEST_DATA_DIR ${CMAKE_SOURCE_DIR}/sdk/tests/data/)
 macro(macro_add_unittest_definitions)
   add_definitions(-DFILES_DATA_DIR="${CMAKE_CURRENT_SOURCE_DIR}/data/")
   add_definitions(-DFILES_OUTPUT_DIR="${CMAKE_CURRENT_BINARY_DIR}")
   add_definitions(-DFILES_DEFAULT_DATA_DIR="${KRITA_DEFAULT_TEST_DATA_DIR}")
   add_definitions(-DSYSTEM_RESOURCES_DATA_DIR="${CMAKE_SOURCE_DIR}/krita/data/")
 endmacro()
 
 
 
 
 # overcome some platform incompatibilities
 if(WIN32)
     include_directories(${CMAKE_CURRENT_SOURCE_DIR}/winquirks)
     add_definitions(-D_USE_MATH_DEFINES)
     add_definitions(-DNOMINMAX)
     set(WIN32_PLATFORM_NET_LIBS ws2_32.lib netapi32.lib)
 endif()
 
 # set custom krita plugin installdir
 set(KRITA_PLUGIN_INSTALL_DIR ${LIB_INSTALL_DIR}/kritaplugins)
 
  ###########################
 ############################
 ## Required dependencies  ##
 ############################
 ###########################
 
 find_package(PNG REQUIRED)
 
 if (APPLE)
     # this is not added correctly on OSX -- see http://forum.kde.org/viewtopic.php?f=139&t=101867&p=221242#p221242
     include_directories(SYSTEM ${PNG_INCLUDE_DIR})
 endif()
 
 add_definitions(-DBOOST_ALL_NO_LIB)
-find_package(Boost 1.55 REQUIRED COMPONENTS system) 
+find_package(Boost 1.55 REQUIRED COMPONENTS system)
 include_directories(SYSTEM ${Boost_INCLUDE_DIRS})
 ##
 ## Test for GNU Scientific Library
 ##
 find_package(GSL)
 set_package_properties(GSL PROPERTIES
     URL "http://www.gnu.org/software/gsl"
     TYPE RECOMMENDED
     PURPOSE "Required by Krita's Transform tool.")
 macro_bool_to_01(GSL_FOUND HAVE_GSL)
 configure_file(config-gsl.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-gsl.h )
 
  ###########################
 ############################
 ## Optional dependencies  ##
 ############################
 ###########################
 
 
 find_package(ZLIB)
 set_package_properties(ZLIB PROPERTIES
     DESCRIPTION "Compression library"
     URL "http://www.zlib.net/"
     TYPE OPTIONAL
     PURPOSE "Optionally used by the G'Mic and the PSD plugins")
 macro_bool_to_01(ZLIB_FOUND HAVE_ZLIB)
 
 find_package(OpenEXR)
 set_package_properties(OpenEXR PROPERTIES
     DESCRIPTION "High dynamic-range (HDR) image file format"
     URL "http://www.openexr.com"
     TYPE OPTIONAL
     PURPOSE "Required by the Krita OpenEXR filter")
 macro_bool_to_01(OPENEXR_FOUND HAVE_OPENEXR)
 set(LINK_OPENEXR_LIB)
 if(OPENEXR_FOUND)
     include_directories(SYSTEM ${OPENEXR_INCLUDE_DIR})
     set(LINK_OPENEXR_LIB ${OPENEXR_LIBRARIES})
     add_definitions(${OPENEXR_DEFINITIONS})
 endif()
 
 find_package(TIFF)
 set_package_properties(TIFF PROPERTIES
     DESCRIPTION "TIFF Library and Utilities"
     URL "http://www.remotesensing.org/libtiff"
     TYPE OPTIONAL
     PURPOSE "Required by the Krita TIFF filter")
 
 find_package(JPEG)
 set_package_properties(JPEG PROPERTIES
     DESCRIPTION "Free library for JPEG image compression. Note: libjpeg8 is NOT supported."
     URL "http://www.libjpeg-turbo.org"
     TYPE OPTIONAL
     PURPOSE "Required by the Krita JPEG filter")
 
 find_package(GIF)
 set_package_properties(GIF PROPERTIES
     DESCRIPTION "Library for loading and saving gif files."
     URL "http://giflib.sourceforge.net/"
     TYPE OPTIONAL
     PURPOSE "Required by the Krita GIF filter")
 
 set(LIBRAW_MIN_VERSION  "0.16")
 find_package(LibRaw ${LIBRAW_MIN_VERSION})
 set_package_properties(LibRaw PROPERTIES
     DESCRIPTION "Library to decode RAW images"
     URL "http://www.libraw.org"
     TYPE OPTIONAL
     PURPOSE "Required to build the raw import plugin")
 
 find_package(FFTW3)
 set_package_properties(FFTW3 PROPERTIES
     DESCRIPTION "A fast, free C FFT library"
     URL "http://www.fftw.org/"
     TYPE OPTIONAL
     PURPOSE "Required by the Krita for fast convolution operators and some G'Mic features")
 macro_bool_to_01(FFTW3_FOUND HAVE_FFTW3)
 
 find_package(OCIO)
 set_package_properties(OCIO PROPERTIES
     DESCRIPTION "The OpenColorIO Library"
     URL "http://www.opencolorio.org"
     TYPE OPTIONAL
     PURPOSE "Required by the Krita LUT docker")
 macro_bool_to_01(OCIO_FOUND HAVE_OCIO)
 
 set_package_properties(PythonLibrary PROPERTIES
     DESCRIPTION "Python Library"
     URL "http://www.python.org"
     TYPE OPTIONAL
     PURPOSE "Required by the Krita PyQt plugin")
 macro_bool_to_01(PYTHONLIBS_FOUND HAVE_PYTHONLIBS)
 
 find_package(SIP "4.18.0")
 set_package_properties(SIP PROPERTIES
     DESCRIPTION "Support for generating SIP Python bindings"
     URL "https://www.riverbankcomputing.com/software/sip/download"
     TYPE OPTIONAL
     PURPOSE "Required by the Krita PyQt plugin")
 macro_bool_to_01(SIP_FOUND HAVE_SIP)
 
 find_package(PyQt5 "5.6.0")
 set_package_properties(PyQt5 PROPERTIES
     DESCRIPTION "Python bindings for Qt5."
     URL "https://www.riverbankcomputing.com/software/pyqt/download5"
     TYPE OPTIONAL
     PURPOSE "Required by the Krita PyQt plugin")
 macro_bool_to_01(PYQT5_FOUND HAVE_PYQT5)
 
 
 ##
 ## Look for OpenGL
 ##
 # TODO: see if there is a better check for QtGui being built with opengl support (and thus the QOpenGL* classes)
 if(Qt5Gui_OPENGL_IMPLEMENTATION)
     message(STATUS "Found QtGui OpenGL support")
 else()
     message(FATAL_ERROR  "Did NOT find QtGui OpenGL support. Check your Qt configuration. You cannot build Krita without Qt OpenGL support.")
 endif()
 
 ##
 ## Test for eigen3
 ##
 find_package(Eigen3 3.0 REQUIRED)
 set_package_properties(Eigen3 PROPERTIES
     DESCRIPTION "C++ template library for linear algebra"
     URL "http://eigen.tuxfamily.org"
     TYPE REQUIRED)
 
 ##
 ## Test for exiv2
 ##
 find_package(Exiv2 0.16 REQUIRED)
 set_package_properties(Exiv2 PROPERTIES
     DESCRIPTION "Image metadata library and tools"
     URL "http://www.exiv2.org"
     PURPOSE "Required by Krita")
 
 ##
 ## Test for lcms
 ##
 find_package(LCMS2 2.4 REQUIRED)
 set_package_properties(LCMS2 PROPERTIES
     DESCRIPTION "LittleCMS Color management engine"
     URL "http://www.littlecms.com"
     TYPE REQUIRED
     PURPOSE "Will be used for color management and is necessary for Krita")
 if(LCMS2_FOUND)
     if(NOT ${LCMS2_VERSION} VERSION_LESS 2040 )
         set(HAVE_LCMS24 TRUE)
     endif()
     set(HAVE_REQUIRED_LCMS_VERSION TRUE)
     set(HAVE_LCMS2 TRUE)
 endif()
 
 ##
 ## Test for Vc
 ##
 set(OLD_CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} )
 set(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/modules )
 set(HAVE_VC FALSE)
-if (NOT ${CMAKE_SYSTEM_PROCESSOR} MATCHES "arm") 
+if (NOT ${CMAKE_SYSTEM_PROCESSOR} MATCHES "arm")
     if(NOT MSVC)
         find_package(Vc 1.1.0)
         set_package_properties(Vc PROPERTIES
             DESCRIPTION "Portable, zero-overhead SIMD library for C++"
             URL "https://github.com/VcDevel/Vc"
             TYPE OPTIONAL
             PURPOSE "Required by the Krita for vectorization")
         macro_bool_to_01(Vc_FOUND HAVE_VC)
     endif()
 endif()
 configure_file(config-vc.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-vc.h )
 
 if(HAVE_VC)
     message(STATUS "Vc found!")
     set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH}
                         "${CMAKE_SOURCE_DIR}/cmake/vc")
 
     include (VcMacros)
 
     if(Vc_COMPILER_IS_CLANG)
         set(ADDITIONAL_VC_FLAGS "-Wabi -ffp-contract=fast")
         if(NOT WIN32)
             set(ADDITIONAL_VC_FLAGS "${ADDITIONAL_VC_FLAGS} -fPIC")
         endif()
     elseif (NOT MSVC)
         set(ADDITIONAL_VC_FLAGS "-Wabi -fabi-version=0 -ffp-contract=fast")
         if(NOT WIN32)
             set(ADDITIONAL_VC_FLAGS "${ADDITIONAL_VC_FLAGS} -fPIC")
         endif()
     endif()
 
     #Handle Vc master
     if(Vc_COMPILER_IS_GCC OR Vc_COMPILER_IS_CLANG)
         AddCompilerFlag("-std=c++11" _ok)
         if(NOT _ok)
             AddCompilerFlag("-std=c++0x" _ok)
         endif()
     endif()
 
     macro(ko_compile_for_all_implementations_no_scalar _objs _src)
         vc_compile_for_all_implementations(${_objs} ${_src} FLAGS ${ADDITIONAL_VC_FLAGS} ONLY SSE2 SSSE3 SSE4_1 AVX AVX2+FMA+BMI2)
     endmacro()
 
     macro(ko_compile_for_all_implementations _objs _src)
         vc_compile_for_all_implementations(${_objs} ${_src} FLAGS ${ADDITIONAL_VC_FLAGS} ONLY Scalar SSE2 SSSE3 SSE4_1 AVX AVX2+FMA+BMI2)
     endmacro()
 endif()
 set(CMAKE_MODULE_PATH ${OLD_CMAKE_MODULE_PATH} )
 
 add_definitions(${QT_DEFINITIONS} ${QT_QTDBUS_DEFINITIONS})
 
 ##
 ## Test endianness
 ##
 include (TestBigEndian)
 test_big_endian(CMAKE_WORDS_BIGENDIAN)
 
 ##
 ## Test for qt-poppler
 ##
 find_package(Poppler COMPONENTS Qt5)
 set_package_properties(Poppler PROPERTIES
     DESCRIPTION "A PDF rendering library"
     URL "http://poppler.freedesktop.org"
     TYPE OPTIONAL
     PURPOSE "Required by the Krita PDF filter.")
 
  ############################
 #############################
 ## Add Krita helper macros ##
 #############################
 ############################
 
 include(MacroKritaAddBenchmark)
 
  ####################
 #####################
 ## Define includes ##
 #####################
 ####################
 
 # for config.h and <toplevel/foo.h> includes (if any?)
 include_directories(BEFORE ${CMAKE_CURRENT_SOURCE_DIR}
                            ${CMAKE_CURRENT_BINARY_DIR}
                            ${CMAKE_SOURCE_DIR}/interfaces
 )
 
 add_subdirectory(libs)
 add_subdirectory(plugins)
 add_subdirectory(benchmarks)
 add_subdirectory(krita)
 
 configure_file(KoConfig.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/KoConfig.h )
 configure_file(config_convolution.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config_convolution.h)
 configure_file(config-ocio.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-ocio.h )
 
 check_function_exists(powf HAVE_POWF)
 configure_file(config-powf.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-powf.h)
 
 if(WIN32)
     include(${CMAKE_CURRENT_LIST_DIR}/packaging/windows/ConfigureInstallerNsis.cmake)
 endif()
 
 message("\nBroken tests:")
 foreach(tst ${KRITA_BROKEN_TESTS})
     message("    * ${tst}")
 endforeach()
 
 feature_summary(WHAT ALL FATAL_ON_MISSING_REQUIRED_PACKAGES)
diff --git a/cmake/modules/FindPythonLibrary.cmake b/cmake/modules/FindPythonLibrary.cmake
index f9b34aa78d..849d42a92a 100644
--- a/cmake/modules/FindPythonLibrary.cmake
+++ b/cmake/modules/FindPythonLibrary.cmake
@@ -1,54 +1,58 @@
 # Find Python
 # ~~~~~~~~~~~
 # Find the Python interpreter and related Python directories.
 #
 # This file defines the following variables:
 #
 # PYTHON_EXECUTABLE - The path and filename of the Python interpreter.
 #
 # PYTHON_SHORT_VERSION - The version of the Python interpreter found,
 #     excluding the patch version number. (e.g. 2.5 and not 2.5.1))
 #
 # PYTHON_LONG_VERSION - The version of the Python interpreter found as a human
 #     readable string.
 #
 # PYTHON_SITE_PACKAGES_DIR - Location of the Python site-packages directory.
 #
 # PYTHON_INCLUDE_PATH - Directory holding the python.h include file.
 #
 # PYTHON_LIBRARY, PYTHON_LIBRARIES- Location of the Python library.
 
 # Copyright (c) 2007, Simon Edwards <simon@simonzone.com>
 # Copyright (c) 2012, Luca Beltrame <lbeltrame@kde.org>
 # Redistribution and use is allowed according to the terms of the BSD license.
 # For details see the accompanying COPYING-CMAKE-SCRIPTS file.
 
 include(FindPackageHandleStandardArgs)
 
-find_package(PythonInterp)
+if (ENABLE_PYTHON_2)
+    find_package(PythonInterp 2.7 REQUIRED)
+else(ENABLE_PYTHON_2)
+    find_package(PythonInterp 3.0 REQUIRED)
+endif(ENABLE_PYTHON_2)
 
 if (PYTHONINTERP_FOUND)
 
     # Set the Python libraries to what we actually found for interpreters
     set(Python_ADDITIONAL_VERSIONS "${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}")
     # These are kept for compatibility
     set(PYTHON_SHORT_VERSION "${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}")
     set(PYTHON_LONG_VERSION ${PYTHON_VERSION_STRING})
 
     find_package(PythonLibs QUIET)
 
     if(PYTHONLIBS_FOUND)
         set(PYTHON_LIBRARY ${PYTHON_LIBRARIES})
     endif(PYTHONLIBS_FOUND)
 
     # Auto detect Python site-packages directory
     execute_process(COMMAND ${PYTHON_EXECUTABLE} -c "from distutils.sysconfig import get_python_lib; print(get_python_lib(True))"
                     OUTPUT_VARIABLE PYTHON_SITE_PACKAGES_DIR
                     OUTPUT_STRIP_TRAILING_WHITESPACE
                    )
 
     message(STATUS "Python system site-packages directory: ${PYTHON_SITE_PACKAGES_DIR}")
 
 endif(PYTHONINTERP_FOUND)
 
 find_package_handle_standard_args(PythonLibrary DEFAULT_MSG PYTHON_LIBRARY)
diff --git a/plugins/extensions/pykrita/plugin/CMakeLists.txt b/plugins/extensions/pykrita/plugin/CMakeLists.txt
index fea46c4b05..f3d98e3762 100644
--- a/plugins/extensions/pykrita/plugin/CMakeLists.txt
+++ b/plugins/extensions/pykrita/plugin/CMakeLists.txt
@@ -1,41 +1,41 @@
 # NOTE Disable trivial Qt keywords due conflicts w/ some Python.h header
 # (at least version 3.3 of it has a member PyType_Spec::slots)
 add_definitions(-DQT_NO_KEYWORDS)
 configure_file(config.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config.h)
 
-set(SOURCES 
-    plugin.cpp 
+set(SOURCES
+    plugin.cpp
     pyqtpluginsettings.cpp
     utilities.cpp
     PykritaModule.cpp
     PythonPluginManager.cpp
     PythonPluginsModel.cpp
 )
 
-ki18n_wrap_ui(SOURCES 
-    info.ui 
+ki18n_wrap_ui(SOURCES
+    info.ui
     manager.ui
 )
 
 add_library(kritapykrita MODULE ${SOURCES})
 
 target_link_libraries(
     kritapykrita
     ${PYTHON_LIBRARY}
     kritaui
     kritalibkis
   )
 
 if (MINGW)
     target_compile_definitions(kritapykrita PRIVATE _hypot=hypot)
 endif (MINGW)
 
 install(TARGETS kritapykrita DESTINATION ${KRITA_PLUGIN_INSTALL_DIR})
 
 # Install "built-in" api
 install(
     DIRECTORY krita
     DESTINATION ${LIB_INSTALL_DIR}/krita-python-libs
     FILES_MATCHING PATTERN "*.py"
 )
 
diff --git a/plugins/extensions/pykrita/plugin/PykritaModule.cpp b/plugins/extensions/pykrita/plugin/PykritaModule.cpp
index 5238f272c2..517468a805 100644
--- a/plugins/extensions/pykrita/plugin/PykritaModule.cpp
+++ b/plugins/extensions/pykrita/plugin/PykritaModule.cpp
@@ -1,79 +1,115 @@
 // 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 "PykritaModule.h"
 
 #include "kis_debug.h"
 
 #define PYKRITA_INIT PyInit_pykrita
 
+struct module_state {
+    PyObject *error;
+};
+
+#if defined(IS_PY3K)
+#define GETSTATE(m) ((struct module_state*)PyModule_GetState(m))
+#else
+#define GETSTATE(m) (&_state)
+static struct module_state _state;
+#endif
+
 /// \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
 {
     PyMethodDef pykritaMethods[] = {
         {
             "qDebug"
             , &PYKRITA::debug
             , METH_VARARGS
             , "True KDE way to show debug info"
         }
         , { 0, 0, 0, 0 }
     };
 }                                                           // anonymous namespace
 
 //BEGIN Python module registration
+#if defined(IS_PY3K)
+// Python 3 initializes modules differently from Python 2
+//
+static struct PyModuleDef moduledef = {
+    PyModuleDef_HEAD_INIT
+    , "pykrita"
+    , "The pykrita module"
+    , -1
+    , pykritaMethods
+    , 0
+    , 0
+    , 0
+    , 0
+};
+
+#define INITERROR return NULL
+
 PyMODINIT_FUNC PyInit_pykrita()
+
+#else
+#define INITERROR return
+
+void
+initpykrita(void)
+#endif
 {
-    static struct PyModuleDef moduledef = {
-        PyModuleDef_HEAD_INIT
-        , "pykrita"
-        , "The pykrita module"
-        , -1
-        , pykritaMethods
-        , 0
-        , 0
-        , 0
-        , 0
-    };
+#if defined(IS_PY3K)
     PyObject *pykritaModule = PyModule_Create(&moduledef);
+#else
+    PyObject *pykritaModule = Py_InitModule("pykrita", pykritaMethods);
+#endif
+
+    if (pykritaModule == NULL)
+        INITERROR;
+
     PyModule_AddStringConstant(pykritaModule, "__file__", __FILE__);
+
+#if defined(IS_PY3K)
     return pykritaModule;
+#endif
 }
+
 //END Python module registration
 
 // krita: space-indent on; indent-width 4;
 #undef PYKRITA_INIT
diff --git a/plugins/extensions/pykrita/plugin/PykritaModule.h b/plugins/extensions/pykrita/plugin/PykritaModule.h
index 4bf9953475..28a674eed1 100644
--- a/plugins/extensions/pykrita/plugin/PykritaModule.h
+++ b/plugins/extensions/pykrita/plugin/PykritaModule.h
@@ -1,33 +1,43 @@
 /*
  * This file is part of PyKrita, Krita' Python scripting plugin.
  *
  * Copyright (C) 2013 Alex Turbov <i.zaufi@gmail.com>
  * Copyright (C) 2014-2016 Boudewijn Rempt <boud@valdyas.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) version 3.
  *
  * 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
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #ifndef __PYKRITA_MODULE_H__
 #define  __PYKRITA_MODULE_H__
 
 #include <Python.h>
 
+#if PY_MAJOR_VERSION >= 3
+#ifndef IS_PY3K
+#define IS_PY3K
+#endif
+#endif
+
 /**
  * Initializer for the built-in Python module.
  */
+#if defined(IS_PY3K)
 PyMODINIT_FUNC PyInit_pykrita();
+#else
+void initpykrita();
+#endif
 
 #endif
diff --git a/plugins/extensions/pykrita/plugin/PythonPluginManager.cpp b/plugins/extensions/pykrita/plugin/PythonPluginManager.cpp
index 2a6b1c5e36..49f3c6bd5a 100644
--- a/plugins/extensions/pykrita/plugin/PythonPluginManager.cpp
+++ b/plugins/extensions/pykrita/plugin/PythonPluginManager.cpp
@@ -1,411 +1,418 @@
 /*
  * This file is part of PyKrita, Krita' Python scripting plugin.
  *
  * Copyright (C) 2013 Alex Turbov <i.zaufi@gmail.com>
  * Copyright (C) 2014-2016 Boudewijn Rempt <boud@valdyas.org>
  * Copyright (C) 2017 Jouni Pentikäinen (joupent@gmail.com)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * 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
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "PythonPluginManager.h"
 
 #include <QFile>
 #include <QFileInfo>
 #include <QSettings>
 #include <KoResourcePaths.h>
 #include <KConfigCore/KConfig>
 #include <KI18n/KLocalizedString>
 #include <KConfigCore/KSharedConfig>
 #include <KConfigCore/KConfigGroup>
 
 #include "config.h"
 #include "version_checker.h"
 
 PythonPluginManager* instance = 0;
 
 // PythonPlugin implementation
 
 QString PythonPlugin::moduleFilePathPart() const
 {
     QString filePath = m_moduleName;
     return filePath.replace(".", "/");
 }
 
 bool PythonPlugin::isValid() const
 {
     dbgScript << "Got Krita/PythonPlugin: " << name()
               << ", module-path=" << moduleName()
                 ;
     // Make sure mandatory properties are here
     if (m_name.isEmpty()) {
         dbgScript << "Ignore desktop file w/o a name";
         return false;
     }
     if (m_moduleName.isEmpty()) {
         dbgScript << "Ignore desktop file w/o a module to import";
         return false;
     }
+#if PY_MAJOR_VERSION == 2
+    // Check if the plug-in is compatible with Python 2 or not.
+    if (m_properties["X-Python-2-Compatible"].toBool() != true) {
+        dbgScript << "Ignoring plug-in. It is marked incompatible with Python 2.";
+        return false;
+    }
+#endif
 
     return true;
 }
 
 // PythonPluginManager implementation
 
 PythonPluginManager::PythonPluginManager()
         : QObject(0)
         , m_model(0, this)
 {}
 
 const QList<PythonPlugin>& PythonPluginManager::plugins() const
 {
     return m_plugins;
 }
 
 PythonPlugin * PythonPluginManager::plugin(int index) {
     if (index >= 0 && index < m_plugins.count()) {
         return &m_plugins[index];
     }
 
     return nullptr;
 }
 
 PythonPluginsModel * PythonPluginManager::model()
 {
     return &m_model;
 }
 
 void PythonPluginManager::unloadAllModules()
 {
     Q_FOREACH(PythonPlugin plugin, m_plugins) {
         if (plugin.m_loaded) {
             unloadModule(plugin);
         }
     }
 }
 
 bool PythonPluginManager::verifyModuleExists(PythonPlugin &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 Python 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 Python module with rel_path:" << rel_path;
         module_path = KoResourcePaths::findResource("pythonscripts", rel_path);
         dbgScript << "module_path:" << module_path;
     }
 
     // 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.moduleName()
                                );
         dbgScript << "Cannot load module:" << plugin.m_errorReason;
         return false;
     }
     dbgScript << "Found module path:" << module_path;
     return true;
 }
 
 QPair<QString, PyKrita::version_checker> PythonPluginManager::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;
         PyKrita::version_checker checker = PyKrita::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, PyKrita::version_checker());
         }
         return qMakePair(dependency, checker);
     }
     return qMakePair(d, PyKrita::version_checker(PyKrita::version_checker::undefined));
 }
 
 /**
  * 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 PythonPluginManager::verifyDependenciesSetStatus(PythonPlugin& plugin)
 {
     QStringList dependencies = plugin.property("X-Python-Dependencies").toStringList();
 
     PyKrita::Python py = PyKrita::Python();
     QString reason = i18nc("@info:tooltip", "<title>Dependency check</title>");
     Q_FOREACH(const QString & d, dependencies) {
         QPair<QString, PyKrita::version_checker> info_pair = parseDependency(d);
         PyKrita::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.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
                           );
             }
             PyKrita::version dep_version = PyKrita::version::fromPythonObject(version_obj);
 
             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.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.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 PythonPluginManager::scanPlugins()
 {
     m_plugins.clear();
 
     KConfigGroup pluginSettings(KSharedConfig::openConfig(), "python");
 
     QStringList desktopFiles = KoResourcePaths::findAllResources("data", "pykrita/*desktop");
 
     Q_FOREACH(const QString &desktopFile, desktopFiles) {
 
         QSettings s(desktopFile, QSettings::IniFormat);
         s.beginGroup("Desktop Entry");
         if (s.value("ServiceTypes").toString() == "Krita/PythonPlugin") {
             PythonPlugin plugin;
             plugin.m_comment = s.value("Comment").toString();
             plugin.m_name = s.value("Name").toString();
             plugin.m_moduleName = s.value("X-KDE-Library").toString();
             plugin.m_properties["X-Python-2-Compatible"] = s.value("X-Python-2-Compatible", false).toBool();
 
             QString manual = s.value("X-Krita-Manual").toString();
             if (!manual.isEmpty()) {
                 QFile f(QFileInfo(desktopFile).path() + "/" + plugin.m_moduleName + "/" + manual);
                 if (f.exists()) {
                     f.open(QFile::ReadOnly);
                     QByteArray ba = f.readAll();
                     f.close();
                     plugin.m_manual = QString::fromUtf8(ba);
                 }
             }
             if (!plugin.isValid()) {
                 dbgScript << plugin.name() << "is not usable";
                 continue;
             }
 
             if (!verifyModuleExists(plugin)) {
                 dbgScript << "Cannot load" << plugin.name() << ": broken"
                           << plugin.isBroken()
                           << "because:" << plugin.errorReason();
                 continue;
             }
 
             verifyDependenciesSetStatus(plugin);
 
             plugin.m_enabled = pluginSettings.readEntry(QString("enable_") + plugin.moduleName(), false);
 
             m_plugins.append(plugin);
         }
     }
 }
 
 void PythonPluginManager::tryLoadEnabledPlugins()
 {
     for (PythonPlugin &plugin : m_plugins) {
         dbgScript << "Trying to load plugin" << plugin.moduleName()
                   << ". Enabled:" << plugin.isEnabled()
                   << ". Broken: " << plugin.isBroken();
 
         if (plugin.m_enabled && !plugin.isBroken()) {
             loadModule(plugin);
         }
     }
 }
 
 void PythonPluginManager::loadModule(PythonPlugin &plugin)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(plugin.isEnabled() && !plugin.isBroken());
 
     QString module_name = plugin.moduleName();
     dbgScript << "Loading module: " << module_name;
 
     PyKrita::Python py = PyKrita::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");
     KIS_SAFE_ASSERT_RECOVER_RETURN(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);
         KIS_SAFE_ASSERT_RECOVER_NOOP(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", PyKrita::Python::PYKRITA_ENGINE, args);
             Py_DECREF(args);
             if (result) {
                 dbgScript << "\t" << "success!";
                 plugin.m_loaded = true;
                 return;
             }
         }
         plugin.m_errorReason = i18nc("@info:tooltip", "Internal engine failure");
     } else {
         plugin.m_errorReason = i18nc(
                                    "@info:tooltip"
                                    , "Module not loaded:<br/>%1"
                                    , py.lastTraceback().replace("\n", "<br/>")
                                );
     }
     plugin.m_broken = true;
     warnScript << "Error loading plugin" << module_name;
 }
 
 void PythonPluginManager::unloadModule(PythonPlugin &plugin)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(plugin.m_loaded);
     KIS_SAFE_ASSERT_RECOVER_RETURN(!plugin.isBroken());
 
     dbgScript << "Unloading module: " << plugin.moduleName();
 
     PyKrita::Python py = PyKrita::Python();
 
     // Get 'plugins' key from 'pykrita' module dictionary
     PyObject* plugins = py.itemString("plugins");
     KIS_SAFE_ASSERT_RECOVER_RETURN(plugins);
 
     PyObject* const args = Py_BuildValue("(s)", PQ(plugin.moduleName()));
     py.functionCall("_pluginUnloading", PyKrita::Python::PYKRITA_ENGINE, args);
     Py_DECREF(args);
 
     // This will just decrement a reference count for module instance
     PyDict_DelItemString(plugins, PQ(plugin.moduleName()));
 
     // 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");
     KIS_SAFE_ASSERT_RECOVER_RETURN(sys_modules);
     PyDict_DelItemString(sys_modules, PQ(plugin.moduleName()));
 
     plugin.m_loaded = false;
 }
 
 void PythonPluginManager::setPluginEnabled(PythonPlugin &plugin, bool enabled)
 {
     bool wasEnabled = plugin.isEnabled();
 
     if (wasEnabled && !enabled) {
         unloadModule(plugin);
     }
 
     plugin.m_enabled = enabled;
     KConfigGroup pluginSettings(KSharedConfig::openConfig(), "python");
     pluginSettings.writeEntry(QString("enable_") + plugin.moduleName(), enabled);
 
     if (!wasEnabled && enabled) {
         loadModule(plugin);
     }
 }
diff --git a/plugins/extensions/pykrita/plugin/krita/__init__.py b/plugins/extensions/pykrita/plugin/krita/__init__.py
index 3052b96e32..0feb22fbc4 100644
--- a/plugins/extensions/pykrita/plugin/krita/__init__.py
+++ b/plugins/extensions/pykrita/plugin/krita/__init__.py
@@ -1,72 +1,77 @@
+from __future__ import print_function
+
 import pykrita
 import os
 import sys
 
-import signal
-signal.signal(signal.SIGINT, signal.SIG_DFL)
-
 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()
 
-import builtins
+if sys.version_info[0] > 2:
+    import builtins
+else:
+    import __builtin__ as builtins
 builtins.i18n = lambda s: QCoreApplication.translate("PyKrita", s)
 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/plugin/krita/dockwidgetfactory.py b/plugins/extensions/pykrita/plugin/krita/dockwidgetfactory.py
index 164785e19f..bfbacd9051 100644
--- a/plugins/extensions/pykrita/plugin/krita/dockwidgetfactory.py
+++ b/plugins/extensions/pykrita/plugin/krita/dockwidgetfactory.py
@@ -1,14 +1,14 @@
 from PyQt5.QtCore import *
 from PyQt5.QtGui import *
 from PyQt5.QtWidgets import *
 from PyKrita.krita import *
 
 
 class DockWidgetFactory(DockWidgetFactoryBase):
 
     def __init__(self, _id, _dockPosition, _klass):
-        super().__init__(_id, _dockPosition)
+        super(DockWidgetFactory, self).__init__(_id, _dockPosition)
         self.klass = _klass
 
     def createDockWidget(self):
         return self.klass()
diff --git a/plugins/extensions/pykrita/plugin/utilities.cpp b/plugins/extensions/pykrita/plugin/utilities.cpp
index c1c7b491d4..8212384ece 100644
--- a/plugins/extensions/pykrita/plugin/utilities.cpp
+++ b/plugins/extensions/pykrita/plugin/utilities.cpp
@@ -1,693 +1,703 @@
 // 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 "PythonPluginManager.h"
 
 #include <algorithm>
 
 #include <cmath>
 #include <Python.h>
 
 #include <QDir>
 #include <QLibrary>
 #include <QString>
 #include <QStringList>
 #include <QVector>
 #include <QFileInfo>
 
 #include <kconfigbase.h>
 #include <kconfiggroup.h>
 #include <klocalizedstring.h>
 #include <KoResourcePaths.h>
 
 #include <kis_debug.h>
 
 #include "PykritaModule.h"
 
 #define THREADED 1
 
 namespace PyKrita
 {
     static InitResult initStatus = INIT_UNINITIALIZED;
     static QScopedPointer<PythonPluginManager> pluginManagerInstance;
 
     InitResult initialize()
     {
         // Already initialized?
         if (initStatus == INIT_OK) return INIT_OK;
 
         dbgScript << "Initializing Python plugin for Python" << PY_MAJOR_VERSION << "," << PY_MINOR_VERSION;
 
         if (!Python::libraryLoad()) {
             return INIT_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)) {
             initStatus = INIT_CANNOT_SET_PYTHON_PATHS;
             return initStatus;
         }
 
+#if defined(IS_PY3K)
         if (0 != PyImport_AppendInittab(Python::PYKRITA_ENGINE, PyInit_pykrita)) {
+#else
+        if (0 != PyImport_AppendInittab(Python::PYKRITA_ENGINE, initpykrita)) {
+#endif
             initStatus = INIT_CANNOT_LOAD_PYKRITA_MODULE;
             return initStatus;
         }
 
         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 'plugins' dict of module 'pykrita'
         PyObject* plugins = PyDict_New();
         py.itemStringSet("plugins", plugins);
 
         pluginManagerInstance.reset(new PythonPluginManager());
 
+#if defined(IS_PY3K)
         // Initialize our built-in module.
         auto pykritaModule = PyInit_pykrita();
 
         if (!pykritaModule) {
             initStatus = INIT_CANNOT_LOAD_PYKRITA_MODULE;
             return initStatus;
             //return i18nc("@info:tooltip ", "No <icode>pykrita</icode> built-in module");
         }
+#else
+        initpykrita();
+#endif
 
         initStatus = INIT_OK;
         return initStatus;
     }
 
     PythonPluginManager *pluginManager()
     {
         auto pluginManager = pluginManagerInstance.data();
         KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(pluginManager, nullptr);
         return pluginManager;
     }
 
     void finalize() {
         dbgScript << "Going to destroy the Python engine";
         if (pluginManagerInstance) {
             pluginManagerInstance->unloadAllModules();
 
             PyKrita::Python::maybeFinalize();
             PyKrita::Python::libraryUnload();
 
             pluginManagerInstance.reset();
             initStatus = INIT_UNINITIALIZED;
         }
     }
 
     namespace
 {
 #ifndef Q_OS_WIN
 QLibrary* s_pythonLibrary = 0;
 #endif
 PyThreadState* s_pythonThreadState = 0;
 bool isPythonPathSet = false;
 }                                                           // 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
 #ifdef Q_OS_LINUX
     if (!s_pythonLibrary) {
 
         QFileInfo fi(PYKRITA_PYTHON_LIBRARY);
         qDebug() << fi.canonicalFilePath() << fi.exists();
         if (fi.exists()) {
             qDebug() << "Creating s_pythonLibrary" << PYKRITA_PYTHON_LIBRARY;
             s_pythonLibrary = new QLibrary(PYKRITA_PYTHON_LIBRARY);
         }
         else {
             QString libraryName = fi.fileName();
             QString applicationRoot = KoResourcePaths::getApplicationRoot();
             QStringList locations;
             locations << applicationRoot + "/lib"
                       << applicationRoot + "/lib64"
                       << applicationRoot + "/lib/X64_86-linux-gnu";
             Q_FOREACH(const QString &location, locations) {
                 QDir d(location);
                 QStringList entries = d.entryList(QStringList() << libraryName + "*");
                 qDebug() << entries;
                 Q_FOREACH(const QString &entry, entries) {
                      QFileInfo fi2(location + "/" + entry);
                      if (fi2.exists()) {
                         s_pythonLibrary = new QLibrary(fi2.canonicalFilePath());
                         break;
                      }
                 }
             }
         }
         if (!s_pythonLibrary) {
             qDebug() << "Could not create" << PYKRITA_PYTHON_LIBRARY;
             return false;
         }
 
         s_pythonLibrary->setLoadHints(QLibrary::ExportExternalSymbolsHint);
         if (!s_pythonLibrary->load()) {
             qDebug() << QString("Could not load %1 -- Reason: %2").arg(s_pythonLibrary->fileName()).arg(s_pythonLibrary->errorString());
             return false;
         }
     }
 #endif
     return true;
 }
 
 namespace
 {
 
 QString findKritaPythonLibsPath(const QString &libdir)
 {
     QDir rootDir(KoResourcePaths::getApplicationRoot());
     QFileInfoList candidates =  rootDir.entryInfoList(QStringList() << "lib*", QDir::Dirs | QDir::NoDotAndDotDot) + rootDir.entryInfoList(QStringList() << "Frameworks", QDir::Dirs | QDir::NoDotAndDotDot);
     Q_FOREACH (const QFileInfo &entry, candidates) {
         QDir libDir(entry.absoluteFilePath());
         if (libDir.cd(libdir)) {
             return libDir.absolutePath();
         } else {
             // Handle cases like Linux where libs are placed in a sub-dir
             // with the ABI name
             Q_FOREACH (const QFileInfo &subEntry, libDir.entryInfoList(QDir::Dirs | QDir::NoDotAndDotDot)) {
                 QDir subDir(subEntry.absoluteFilePath());
                 if (subDir.cd(libdir)) {
                     return subDir.absolutePath();
                 }
             }
         }
     }
     return QString();
 }
 
 } // namespace
 
 bool Python::setPath(const QStringList& scriptPaths)
 {
 
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!Py_IsInitialized(), false);
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!isPythonPathSet, false);
 
     bool runningInBundle = (KoResourcePaths::getApplicationRoot().toLower().contains(".mount_krita") || KoResourcePaths::getApplicationRoot().toLower().contains("krita.app"));
     qDebug() << "Python::setPath. Script paths:" << scriptPaths << runningInBundle;
 
 #ifdef Q_OS_WIN
     constexpr char pathSeparator = ';';
 #else
     constexpr char pathSeparator = ':';
 #endif
 
     QString originalPath;
     // Start with the script paths
     QStringList paths(scriptPaths);
 
     // Append the Krita libraries path
     QString pythonLibsPath = findKritaPythonLibsPath("krita-python-libs");
     qDebug() << "pythonLibsPath (krita-python-libs)" << pythonLibsPath;
     if (pythonLibsPath.isEmpty()) {
         qDebug() << "Cannot find krita-python-libs";
         return false;
     }
     qDebug() << "Found krita-python-libs at" << pythonLibsPath;
     paths.append(pythonLibsPath);
 
 #ifndef Q_OS_WIN
     // Append the sip libraries path
     pythonLibsPath = findKritaPythonLibsPath("sip");
     qDebug() << "pythonLibsPath (sip)" << pythonLibsPath;
     if (!pythonLibsPath.isEmpty()) {
         qDebug() << "Found sip at" << pythonLibsPath;
         paths.append(pythonLibsPath);
     }
 #endif
 
 #ifdef Q_OS_WIN
     // Find embeddable Python at <root>/python
     QDir pythonDir(KoResourcePaths::getApplicationRoot());
     if (pythonDir.cd("python")) {
         dbgScript << "Found bundled Python at" << pythonDir.absolutePath();
         // The default paths for Windows embeddable Python is ./python36.zip;./
         // HACK: Assuming bundled Python is version 3.6.*
         // FIXME: Should we read python36._pth for the paths or use Py_GetPath?
         paths.append(pythonDir.absoluteFilePath("python36.zip"));
         paths.append(pythonDir.absolutePath());
     } else {
         errScript << "Bundled Python not found, cannot set Python library paths";
         return false;
     }
 #else
     // If using a system Python install, respect the current PYTHONPATH
     if (KoResourcePaths::getApplicationRoot().toLower().contains(".mount_krita")) {
         // We're running from an appimage, so we need our local python
         QString p = QFileInfo(PYKRITA_PYTHON_LIBRARY).fileName();
         QString p2 = p.remove("lib").remove("m.so");
         qDebug() << "\t" << p << p2;
         originalPath = findKritaPythonLibsPath(p);
         paths.append(originalPath + "/lib-dynload");
         paths.append(originalPath + "/site-packages");
         paths.append(originalPath + "/site-packages/PyQt5");
     }
     else {
         // Use the system path
         originalPath = QString::fromLocal8Bit(qgetenv("PYTHONPATH"));
     }
 #endif
 
     QString joinedPaths = paths.join(pathSeparator);
     if (!originalPath.isEmpty()) {
         joinedPaths = joinedPaths + pathSeparator + originalPath;
     }
     qDebug() << "Setting python paths:" << joinedPaths;
 #ifdef Q_OS_WIN
     QVector<wchar_t> joinedPathsWChars(joinedPaths.size() + 1, 0);
     joinedPaths.toWCharArray(joinedPathsWChars.data());
     Py_SetPath(joinedPathsWChars.data());
 #else
     if (KoResourcePaths::getApplicationRoot().contains(".mount_Krita")) {
         QVector<wchar_t> joinedPathsWChars(joinedPaths.size() + 1, 0);
         joinedPaths.toWCharArray(joinedPathsWChars.data());
-        Py_SetPath(joinedPathsWChars.data());
+        PyRun_SimpleString("import sys; import os");
+        QString pathCommand = QString("sys.path += '") + joinedPaths + QString("'.split(os.pathsep)");
+        PyRun_SimpleString(pathCommand.toUtf8().constData());
     }
     else {
         qputenv("PYTHONPATH", joinedPaths.toLocal8Bit());
     }
 #endif
     isPythonPathSet = true;
     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 initialize 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;
 }
 
 // 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
 }
 
 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/sip/CMakeLists.txt b/plugins/extensions/pykrita/sip/CMakeLists.txt
index e9b3d3a2b8..1f47f0af1c 100644
--- a/plugins/extensions/pykrita/sip/CMakeLists.txt
+++ b/plugins/extensions/pykrita/sip/CMakeLists.txt
@@ -1,27 +1,30 @@
 include(SIPMacros)
 
 message( ${SIP_VERSION} " - The version of SIP found expressed as a 6 digit hex number suitable for comparison as a string.")
 message( ${SIP_VERSION_STR} " - The version of SIP found as a human readable string.")
 message( ${SIP_EXECUTABLE} " - Path and filename of the SIP command line executable.")
 message( ${SIP_INCLUDE_DIR} " - Directory holding the SIP C++ header file.")
 message( ${SIP_DEFAULT_SIP_DIR} " - default SIP dir" )
 
-set(SIP_INCLUDES 
+set(SIP_INCLUDES
     ${SIP_DEFAULT_SIP_DIR}
     ${PYQT5_SIP_DIR}
     ${PYQT_SIP_DIR_OVERRIDE}
      ./krita)
 
 set(SIP_CONCAT_PARTS 1)
 set(SIP_TAGS ALL WS_X11 ${PYQT5_VERSION_TAG})
 set(SIP_EXTRA_OPTIONS -g -x PyKDE_QVector)
 
 set(PYTHON_SITE_PACKAGES_INSTALL_DIR ${LIB_INSTALL_DIR}/krita-python-libs)
 file(GLOB PYKRITA_KRITA_sip_files ./krita/*.sip)
 set(SIP_EXTRA_FILES_DEPEND ${PYKRITA_KRITA_sip_files})
 add_sip_python_module(PyKrita.krita ./krita/kritamod.sip kritalibkis kritaui kritaimage kritalibbrush)
 
-#install(FILES
-#    ./__init__.py
-#    DESTINATION ${PYTHON_SITE_PACKAGES_INSTALL_DIR})
-
+if (ENABLE_PYTHON_2)
+    # Add an init file to turn it into a valid py2 module.
+    # Otherwise PyKrita cannot be loaded.
+    install(FILES
+        ./__init__.py
+        DESTINATION ${PYTHON_SITE_PACKAGES_INSTALL_DIR}/PyKrita)
+endif (ENABLE_PYTHON_2)
diff --git a/plugins/extensions/pykrita/sip/__init__.py b/plugins/extensions/pykrita/sip/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/plugins/python/assignprofiledialog/assignprofiledialog.py b/plugins/python/assignprofiledialog/assignprofiledialog.py
index c4b92bec31..36e57198f5 100644
--- a/plugins/python/assignprofiledialog/assignprofiledialog.py
+++ b/plugins/python/assignprofiledialog/assignprofiledialog.py
@@ -1,59 +1,60 @@
 '''
 This script is licensed CC 0 1.0, so that you can learn from it.
 
 ------ CC 0 1.0 ---------------
 
 The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
 
 You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.
 
 https://creativecommons.org/publicdomain/zero/1.0/legalcode
 '''
-import sys
-from PyQt5.QtGui import *
-from PyQt5.QtWidgets import *
-from krita import *
+from PyQt5.QtCore import Qt
+from PyQt5.QtWidgets import (QDialogButtonBox, QDialog,
+                             QMessageBox, QComboBox, QVBoxLayout)
+from krita import Extension
 
 
 class AssignProfileDialog(Extension):
 
     def __init__(self, parent):
-        super().__init__(parent)
+        super(AssignProfileDialog, self).__init__(parent)
 
     def assignProfile(self):
         doc = Application.activeDocument()
-        if doc == None:
+        if doc is None:
             QMessageBox.information(Application.activeWindow().qwindow(), "Assign Profile", "There is no active document.")
             return
 
         self.dialog = QDialog(Application.activeWindow().qwindow())
 
         self.cmbProfile = QComboBox(self.dialog)
         for profile in sorted(Application.profiles(doc.colorModel(), doc.colorDepth())):
             self.cmbProfile.addItem(profile)
 
         vbox = QVBoxLayout(self.dialog)
         vbox.addWidget(self.cmbProfile)
         self.buttonBox = QDialogButtonBox(self.dialog)
-        self.buttonBox.setOrientation(QtCore.Qt.Horizontal)
+        self.buttonBox.setOrientation(Qt.Horizontal)
         self.buttonBox.setStandardButtons(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
         self.buttonBox.accepted.connect(self.dialog.accept)
         self.buttonBox.accepted.connect(self.accept)
         self.buttonBox.rejected.connect(self.dialog.reject)
         vbox.addWidget(self.buttonBox)
         self.dialog.show()
         self.dialog.activateWindow()
         self.dialog.exec_()
 
     def accept(self):
         doc = Application.activeDocument()
         doc.setColorProfile(self.cmbProfile.currentText())
 
     def setup(self):
         pass
-    
+
     def createActions(self, window):
         action = window.createAction("assing_profile_to_image", "Assign Profile to Image")
         action.triggered.connect(self.assignProfile)
 
+
 Scripter.addExtension(AssignProfileDialog(Application))
diff --git a/plugins/python/assignprofiledialog/kritapykrita_assignprofiledialog.desktop b/plugins/python/assignprofiledialog/kritapykrita_assignprofiledialog.desktop
index 68d999295d..e9175e1c9d 100644
--- a/plugins/python/assignprofiledialog/kritapykrita_assignprofiledialog.desktop
+++ b/plugins/python/assignprofiledialog/kritapykrita_assignprofiledialog.desktop
@@ -1,39 +1,39 @@
 [Desktop Entry]
 Type=Service
 ServiceTypes=Krita/PythonPlugin
 X-KDE-Library=assignprofiledialog
-X-Python-2-Compatible=false
+X-Python-2-Compatible=true
 X-Krita-Manual=Manual.html
 Name=Assign Profile to Image
 Name[ca]=Assigna un perfil a una imatge
 Name[ca@valencia]=Assigna un perfil a una imatge
 Name[cs]=Přiřadit obrázku profil
 Name[en_GB]=Assign Profile to Image
 Name[es]=Asignar perfil a imagen
 Name[gl]=Asignar un perfil á imaxe
 Name[it]=Assegna profilo a immagine
 Name[nl]=Profiel aan afbeelding toewijzen
 Name[pl]=Przypisz profil do obrazu
 Name[pt]=Atribuir um Perfil à Imagem
 Name[sv]=Tilldela profil till bild
 Name[tr]=Görüntüye Profil Ata
 Name[uk]=Призначити профіль до зображення
 Name[x-test]=xxAssign Profile to Imagexx
 Name[zh_CN]=应用配置到图像
 Name[zh_TW]=指定設定檔到圖像
 Comment=Assign a profile to an image without converting it.
 Comment[ca]=Assigna un perfil a una imatge sense convertir-la.
 Comment[ca@valencia]=Assigna un perfil a una imatge sense convertir-la.
 Comment[en_GB]=Assign a profile to an image without converting it.
 Comment[es]=Asignar un perfil a una imagen sin convertirla.
 Comment[gl]=Asignar un perfil a unha imaxe sen convertela.
 Comment[it]=Assegna un profilo a un'immagine senza convertirla.
 Comment[nl]=Een profiel aan een afbeelding toewijzen zonder het te converteren.
 Comment[pl]=Przypisz profil do obrazu bez jego przekształcania.
 Comment[pt]=Atribuir um perfil a uma imagem sem a converter.
 Comment[sv]=Tilldela en profil till en bild utan att konvertera den.
 Comment[tr]=Bir görüntüye, görüntüyü değiştirmeden bir profil ata.
 Comment[uk]=Призначити профіль до зображення без його перетворення.
 Comment[x-test]=xxAssign a profile to an image without converting it.xx
 Comment[zh_CN]=为图像设定配置而无需转换它。
 Comment[zh_TW]=將設定檔指定給圖像，而不進行轉換。
diff --git a/plugins/python/colorspace/colorspace.py b/plugins/python/colorspace/colorspace.py
index 938326960b..3d4c4bd8ab 100644
--- a/plugins/python/colorspace/colorspace.py
+++ b/plugins/python/colorspace/colorspace.py
@@ -1,34 +1,34 @@
 '''
 This script is licensed CC 0 1.0, so that you can learn from it.
 
 ------ CC 0 1.0 ---------------
 
 The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
 
 You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.
 
 https://creativecommons.org/publicdomain/zero/1.0/legalcode
 '''
 import krita
-from colorspace import uicolorspace
+from . import uicolorspace
 
 
 class ColorSpaceExtension(krita.Extension):
 
     def __init__(self, parent):
         super(ColorSpaceExtension, self).__init__(parent)
 
     def setup(self):
         pass
-    
+
     def createActions(self, window):
         action = window.createAction("color_space", "Color Space")
         action.setToolTip("Plugin to change color space to selected documents")
         action.triggered.connect(self.initialize)
 
     def initialize(self):
         self.uicolorspace = uicolorspace.UIColorSpace()
         self.uicolorspace.initialize()
 
 
 Scripter.addExtension(ColorSpaceExtension(krita.Krita.instance()))
diff --git a/plugins/python/colorspace/kritapykrita_colorspace.desktop b/plugins/python/colorspace/kritapykrita_colorspace.desktop
index 0873232dff..0edd1c53e4 100644
--- a/plugins/python/colorspace/kritapykrita_colorspace.desktop
+++ b/plugins/python/colorspace/kritapykrita_colorspace.desktop
@@ -1,41 +1,41 @@
 [Desktop Entry]
 Type=Service
 ServiceTypes=Krita/PythonPlugin
 X-KDE-Library=colorspace
-X-Python-2-Compatible=false
+X-Python-2-Compatible=true
 X-Krita-Manual=Manual.html
 Name=Color Space
 Name[ca]=Espai de color
 Name[ca@valencia]=Espai de color
 Name[cs]=Barevný prostor
 Name[de]=Farbraum
 Name[en_GB]=Colour Space
 Name[es]=Espacio de color
 Name[gl]=Espazo de cores
 Name[it]=Spazio dei colori
 Name[nl]=Kleurruimte
 Name[pl]=Przestrzeń barw
 Name[pt]=Espaço de Cores
 Name[sv]=Färgrymd
 Name[tr]=Renk Aralığı
 Name[uk]=Простір кольорів
 Name[x-test]=xxColor Spacexx
 Name[zh_CN]=色彩空间
 Name[zh_TW]=色彩空間
 Comment=Plugin to change color space to selected documents
 Comment[ca]=Un connector per canviar l'espai de color dels documents seleccionats
 Comment[ca@valencia]=Un connector per canviar l'espai de color dels documents seleccionats
 Comment[cs]=Modul pro změnu rozsahu barvy pro vybrané dokumenty
 Comment[en_GB]=Plugin to change colour space to selected documents
 Comment[es]=Complemento para cambiar el espacio de color de los documentos seleccionados
 Comment[gl]=Complemento para cambiar o espazo de cores dos documentos seleccionados.
 Comment[it]=Estensione per cambiare lo spazio dei colori ai documenti selezionati
 Comment[nl]=Plug-in om kleurruimte te wijzigen aan geselecteerde documenten
 Comment[pl]=Wtyczka do zmiany przestrzeni barw dla wybranych dokumentów
 Comment[pt]='Plugin' para  mudar o espaço de cores para os documentos seleccionados
 Comment[sv]=Insticksprogram för att ändra färgrymd för valda dokument
 Comment[tr]=Seçili belgede renk aralığını değiştirmek için eklenti
 Comment[uk]=Додаток для зміни простору кольорів у позначених документах
 Comment[x-test]=xxPlugin to change color space to selected documentsxx
 Comment[zh_CN]=将颜色空间改为所选文档的插件
 Comment[zh_TW]=用於變更色彩空間為選定文件的外掛程式
diff --git a/plugins/python/colorspace/uicolorspace.py b/plugins/python/colorspace/uicolorspace.py
index accd3ab57e..f7c9a8378e 100644
--- a/plugins/python/colorspace/uicolorspace.py
+++ b/plugins/python/colorspace/uicolorspace.py
@@ -1,129 +1,129 @@
 '''
 This script is licensed CC 0 1.0, so that you can learn from it.
 
 ------ CC 0 1.0 ---------------
 
 The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
 
 You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.
 
 https://creativecommons.org/publicdomain/zero/1.0/legalcode
 '''
-from colorspace import colorspacedialog
-from colorspace.components import colormodelcombobox, colordepthcombobox, colorprofilecombobox
+from . import colorspacedialog
+from .components import colormodelcombobox, colordepthcombobox, colorprofilecombobox
 from PyQt5.QtCore import Qt
 from PyQt5.QtWidgets import (QFormLayout, QListWidget, QListWidgetItem,
                              QAbstractItemView, QComboBox, QDialogButtonBox,
                              QVBoxLayout, QFrame, QMessageBox, QPushButton,
                              QHBoxLayout, QAbstractScrollArea)
 from PyQt5.QtGui import QIcon
 import krita
-from colorspace import resources_rc
+from . import resources_rc
 
 
 class UIColorSpace(object):
 
     def __init__(self):
         self.mainDialog = colorspacedialog.ColorSpaceDialog()
         self.mainLayout = QVBoxLayout(self.mainDialog)
         self.formLayout = QFormLayout()
         self.documentLayout = QVBoxLayout()
         self.refreshButton = QPushButton(QIcon(':/icons/refresh.svg'), "Refresh")
         self.widgetDocuments = QListWidget()
         self.colorModelComboBox = colormodelcombobox.ColorModelComboBox(self)
         self.colorDepthComboBox = colordepthcombobox.ColorDepthComboBox(self)
         self.colorProfileComboBox = colorprofilecombobox.ColorProfileComboBox(self)
         self.buttonBox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
 
         self.kritaInstance = krita.Krita.instance()
         self.documentsList = []
         self.colorModelsList = []
         self.colorDepthsList = []
         self.colorProfilesList = []
 
         self.refreshButton.clicked.connect(self.refreshButtonClicked)
         self.buttonBox.accepted.connect(self.confirmButton)
         self.buttonBox.rejected.connect(self.mainDialog.close)
 
         self.mainDialog.setWindowModality(Qt.NonModal)
         self.widgetDocuments.setSelectionMode(QAbstractItemView.MultiSelection)
         self.widgetDocuments.setSizeAdjustPolicy(QAbstractScrollArea.AdjustToContents)
 
     def initialize(self):
         self.loadDocuments()
         self.loadColorModels()
         self.loadColorDepths()
         self.loadColorProfiles()
 
         self.documentLayout.addWidget(self.widgetDocuments)
         self.documentLayout.addWidget(self.refreshButton)
 
         self.formLayout.addRow('Documents', self.documentLayout)
         self.formLayout.addRow('Color Model', self.colorModelComboBox)
         self.formLayout.addRow('Color Depth', self.colorDepthComboBox)
         self.formLayout.addRow('Color Profile', self.colorProfileComboBox)
 
         self.line = QFrame()
         self.line.setFrameShape(QFrame.HLine)
         self.line.setFrameShadow(QFrame.Sunken)
 
         self.mainLayout.addLayout(self.formLayout)
         self.mainLayout.addWidget(self.line)
         self.mainLayout.addWidget(self.buttonBox)
 
         self.mainDialog.resize(500, 300)
         self.mainDialog.setWindowTitle("Color Space")
         self.mainDialog.setSizeGripEnabled(True)
         self.mainDialog.show()
         self.mainDialog.activateWindow()
 
     def loadColorModels(self):
         self.colorModelsList = sorted(self.kritaInstance.colorModels())
 
         self.colorModelComboBox.addItems(self.colorModelsList)
 
     def loadColorDepths(self):
         self.colorDepthComboBox.clear()
 
         colorModel = self.colorModelComboBox.currentText()
         self.colorDepthsList = sorted(self.kritaInstance.colorDepths(colorModel))
 
         self.colorDepthComboBox.addItems(self.colorDepthsList)
 
     def loadColorProfiles(self):
         self.colorProfileComboBox.clear()
 
         colorModel = self.colorModelComboBox.currentText()
         colorDepth = self.colorDepthComboBox.currentText()
         self.colorProfilesList = sorted(self.kritaInstance.profiles(colorModel, colorDepth))
 
         self.colorProfileComboBox.addItems(self.colorProfilesList)
 
     def loadDocuments(self):
         self.widgetDocuments.clear()
 
         self.documentsList = [document for document in self.kritaInstance.documents() if document.fileName()]
 
         for document in self.documentsList:
             self.widgetDocuments.addItem(document.fileName())
 
     def refreshButtonClicked(self):
         self.loadDocuments()
 
     def confirmButton(self):
         selectedPaths = [item.text() for item in self.widgetDocuments.selectedItems()]
         selectedDocuments = [document for document in self.documentsList for path in selectedPaths if path == document.fileName()]
 
         self.msgBox = QMessageBox(self.mainDialog)
         if selectedDocuments:
             self.convertColorSpace(selectedDocuments)
             self.msgBox.setText("The selected documents has been converted.")
         else:
             self.msgBox.setText("Select at least one document.")
         self.msgBox.exec_()
 
     def convertColorSpace(self, documents):
         for document in documents:
             document.setColorSpace(self.colorModelComboBox.currentText(),
                                    self.colorDepthComboBox.currentText(),
                                    self.colorProfileComboBox.currentText())
diff --git a/plugins/python/documenttools/documenttools.py b/plugins/python/documenttools/documenttools.py
index 9432c9309e..cf498ef349 100644
--- a/plugins/python/documenttools/documenttools.py
+++ b/plugins/python/documenttools/documenttools.py
@@ -1,34 +1,34 @@
 '''
 This script is licensed CC 0 1.0, so that you can learn from it.
 
 ------ CC 0 1.0 ---------------
 
 The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
 
 You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.
 
 https://creativecommons.org/publicdomain/zero/1.0/legalcode
 '''
 import krita
-from documenttools import uidocumenttools
+from . import uidocumenttools
 
 
 class DocumentToolsExtension(krita.Extension):
 
     def __init__(self, parent):
         super(DocumentToolsExtension, self).__init__(parent)
 
     def setup(self):
         pass
-    
+
     def createActions(self, window):
         action = window.createAction("document_tools", "Document Tools")
         action.setToolTip("Plugin to manipulate properties of selected documents")
         action.triggered.connect(self.initialize)
 
     def initialize(self):
         self.uidocumenttools = uidocumenttools.UIDocumentTools()
         self.uidocumenttools.initialize()
 
 
 Scripter.addExtension(DocumentToolsExtension(krita.Krita.instance()))
diff --git a/plugins/python/documenttools/kritapykrita_documenttools.desktop b/plugins/python/documenttools/kritapykrita_documenttools.desktop
index e57a2d8356..e36bfb32ba 100644
--- a/plugins/python/documenttools/kritapykrita_documenttools.desktop
+++ b/plugins/python/documenttools/kritapykrita_documenttools.desktop
@@ -1,40 +1,40 @@
 [Desktop Entry]
 Type=Service
 ServiceTypes=Krita/PythonPlugin
 X-KDE-Library=documenttools
-X-Python-2-Compatible=false
+X-Python-2-Compatible=true
 X-Krita-Manual=Manual.html
 Name=Document Tools
 Name[ca]=Eines de document
 Name[ca@valencia]=Eines de document
 Name[cs]=Dokumentové nástroje
 Name[en_GB]=Document Tools
 Name[es]=Herramientas de documentos
 Name[gl]=Ferramentas de documentos
 Name[it]=Strumenti per i documenti
 Name[nl]=Documenthulpmiddelen
 Name[pl]=Narzędzia dokumentu
 Name[pt]=Ferramentas de Documentos
 Name[sv]=Dokumentverktyg
 Name[tr]=Belge Araçları
 Name[uk]=Засоби документа
 Name[x-test]=xxDocument Toolsxx
 Name[zh_CN]=文档工具
 Name[zh_TW]=文件工具
 Comment=Plugin to manipulate properties of selected documents
 Comment[ca]=Un connector per manipular propietats dels documents seleccionats
 Comment[ca@valencia]=Un connector per manipular propietats dels documents seleccionats
 Comment[cs]=Modul pro správu vlastností vybraných dokumentů
 Comment[en_GB]=Plugin to manipulate properties of selected documents
 Comment[es]=Complemento para manipular las propiedades de los documentos seleccionados
 Comment[gl]=Complemento para manipular as propiedades dos documentos seleccionados.
 Comment[it]=Estensione per manipolare le proprietà dei documenti selezionati
 Comment[nl]=Plug-in voor het manipuleren van eigenschappen van geselecteerde documenten
 Comment[pl]=Wtyczka do zmiany właściwości wybranych dokumentów
 Comment[pt]='Plugin' para manipular as propriedades dos documentos seleccionados
 Comment[sv]=Insticksprogram för att ändra egenskaper för valda dokument
 Comment[tr]=Seçili belgelerin özelliklerini değiştirmek için eklenti
 Comment[uk]=Додаток для керування властивостями позначених документів
 Comment[x-test]=xxPlugin to manipulate properties of selected documentsxx
 Comment[zh_CN]=操纵选中文档的属性的插件
 Comment[zh_TW]=用於修改所選文件屬性的外掛程式
diff --git a/plugins/python/documenttools/uidocumenttools.py b/plugins/python/documenttools/uidocumenttools.py
index 41e627122d..eec5e51279 100644
--- a/plugins/python/documenttools/uidocumenttools.py
+++ b/plugins/python/documenttools/uidocumenttools.py
@@ -1,106 +1,107 @@
 '''
 This script is licensed CC 0 1.0, so that you can learn from it.
 
 ------ CC 0 1.0 ---------------
 
 The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
 
 You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.
 
 https://creativecommons.org/publicdomain/zero/1.0/legalcode
 '''
-from documenttools import documenttoolsdialog
+from . import documenttoolsdialog
 from PyQt5.QtCore import Qt
 from PyQt5.QtWidgets import (QFormLayout, QListWidget, QAbstractItemView,
                              QDialogButtonBox, QVBoxLayout, QFrame, QTabWidget,
                              QPushButton, QAbstractScrollArea, QMessageBox)
 import krita
 import importlib
 
 
 class UIDocumentTools(object):
 
     def __init__(self):
         self.mainDialog = documenttoolsdialog.DocumentToolsDialog()
         self.mainLayout = QVBoxLayout(self.mainDialog)
         self.formLayout = QFormLayout()
         self.documentLayout = QVBoxLayout()
         self.refreshButton = QPushButton("Refresh")
         self.widgetDocuments = QListWidget()
         self.tabTools = QTabWidget()
         self.buttonBox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
 
         self.kritaInstance = krita.Krita.instance()
         self.documentsList = []
 
         self.refreshButton.clicked.connect(self.refreshButtonClicked)
         self.buttonBox.accepted.connect(self.confirmButton)
         self.buttonBox.rejected.connect(self.mainDialog.close)
 
         self.mainDialog.setWindowModality(Qt.NonModal)
         self.widgetDocuments.setSelectionMode(QAbstractItemView.MultiSelection)
         self.widgetDocuments.setSizeAdjustPolicy(QAbstractScrollArea.AdjustToContents)
 
     def initialize(self):
         self.loadDocuments()
         self.loadTools()
 
         self.documentLayout.addWidget(self.widgetDocuments)
         self.documentLayout.addWidget(self.refreshButton)
 
         self.formLayout.addRow('Documents', self.documentLayout)
         self.formLayout.addRow(self.tabTools)
 
         self.line = QFrame()
         self.line.setFrameShape(QFrame.HLine)
         self.line.setFrameShadow(QFrame.Sunken)
 
         self.mainLayout.addLayout(self.formLayout)
         self.mainLayout.addWidget(self.line)
         self.mainLayout.addWidget(self.buttonBox)
 
         self.mainDialog.resize(500, 300)
         self.mainDialog.setWindowTitle("Document Tools")
         self.mainDialog.setSizeGripEnabled(True)
         self.mainDialog.show()
         self.mainDialog.activateWindow()
 
     def loadTools(self):
         modulePath = 'documenttools.tools'
         toolsModule = importlib.import_module(modulePath)
         modules = []
 
         for classPath in toolsModule.ToolClasses:
-            _module, _klass = classPath.rsplit('.', maxsplit=1)
+            _module = classPath[:classPath.rfind(".")]
+            _klass = classPath[classPath.rfind(".") + 1:]
             modules.append(dict(module='{0}.{1}'.format(modulePath, _module),
                                 klass=_klass))
 
         for module in modules:
             m = importlib.import_module(module['module'])
             toolClass = getattr(m, module['klass'])
             obj = toolClass(self.mainDialog)
             self.tabTools.addTab(obj, obj.objectName())
 
     def loadDocuments(self):
         self.widgetDocuments.clear()
 
         self.documentsList = [document for document in self.kritaInstance.documents() if document.fileName()]
 
         for document in self.documentsList:
             self.widgetDocuments.addItem(document.fileName())
 
     def refreshButtonClicked(self):
         self.loadDocuments()
 
     def confirmButton(self):
         selectedPaths = [item.text() for item in self.widgetDocuments.selectedItems()]
         selectedDocuments = [document for document in self.documentsList for path in selectedPaths if path == document.fileName()]
 
         self.msgBox = QMessageBox(self.mainDialog)
         if selectedDocuments:
             widget = self.tabTools.currentWidget()
             widget.adjust(selectedDocuments)
             self.msgBox.setText("The selected documents has been modified.")
         else:
             self.msgBox.setText("Select at least one document.")
         self.msgBox.exec_()
diff --git a/plugins/python/exportlayers/exportlayers.py b/plugins/python/exportlayers/exportlayers.py
index de0b65af49..c6336f62a5 100644
--- a/plugins/python/exportlayers/exportlayers.py
+++ b/plugins/python/exportlayers/exportlayers.py
@@ -1,34 +1,34 @@
 '''
 This script is licensed CC 0 1.0, so that you can learn from it.
 
 ------ CC 0 1.0 ---------------
 
 The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
 
 You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.
 
 https://creativecommons.org/publicdomain/zero/1.0/legalcode
 '''
 import krita
-from exportlayers import uiexportlayers
+from . import uiexportlayers
 
 
 class ExportLayersExtension(krita.Extension):
 
     def __init__(self, parent):
         super(ExportLayersExtension, self).__init__(parent)
 
     def setup(self):
         pass
-    
+
     def createActions(self, window):
         action = window.createAction("export_layers", "Export Layers")
         action.setToolTip("Plugin to export layers from a document")
         action.triggered.connect(self.initialize)
 
     def initialize(self):
         self.uiexportlayers = uiexportlayers.UIExportLayers()
         self.uiexportlayers.initialize()
 
 
 Scripter.addExtension(ExportLayersExtension(krita.Krita.instance()))
diff --git a/plugins/python/exportlayers/kritapykrita_exportlayers.desktop b/plugins/python/exportlayers/kritapykrita_exportlayers.desktop
index 69edd94ac1..dc6678c072 100644
--- a/plugins/python/exportlayers/kritapykrita_exportlayers.desktop
+++ b/plugins/python/exportlayers/kritapykrita_exportlayers.desktop
@@ -1,40 +1,40 @@
 [Desktop Entry]
 Type=Service
 ServiceTypes=Krita/PythonPlugin
 X-KDE-Library=exportlayers
 X-Krita-Manual=Manual.html
-X-Python-2-Compatible=false
+X-Python-2-Compatible=true
 Name=Export Layers
 Name[ca]=Exportació de capes
 Name[ca@valencia]=Exportació de capes
 Name[cs]=Exportovat vrstvy
 Name[en_GB]=Export Layers
 Name[es]=Exportar capas
 Name[gl]=Exportar as capas
 Name[it]=Esporta livelli
 Name[nl]=Lagen exporteren
 Name[pl]=Eksportowanie warstw
 Name[pt]=Exportar as Camadas
 Name[sv]=Exportera lager
 Name[tr]=Katmanları Dışa Aktar
 Name[uk]=Експортувати шари
 Name[x-test]=xxExport Layersxx
 Name[zh_CN]=导出图层
 Name[zh_TW]=匯出圖層
 Comment=Plugin to export layers from a document
 Comment[ca]=Un connector per exportar capes d'un document
 Comment[ca@valencia]=Un connector per exportar capes d'un document
 Comment[cs]=Modul pro export vrstev z dokumentu
 Comment[en_GB]=Plugin to export layers from a document
 Comment[es]=Complemento para exportar las capas de un documento
 Comment[gl]=Complemento para exportar as capas dun documento.
 Comment[it]=Estensione per esportare i livelli da un documento
 Comment[nl]=Plug-in om lagen uit een document te exporteren
 Comment[pl]=Wtyczka do eksportowania warstw z dokumentu
 Comment[pt]='Plugin' para exportar as camadas de um documento
 Comment[sv]=Insticksprogram för att exportera lager från ett dokument
 Comment[tr]=Belgenin katmanlarını dışa aktarmak için eklenti
 Comment[uk]=Додаток для експортування шарів з документа
 Comment[x-test]=xxPlugin to export layers from a documentxx
 Comment[zh_CN]=从文档导出图层的插件
 Comment[zh_TW]=用於從文件匯出圖層的外掛程式
diff --git a/plugins/python/exportlayers/uiexportlayers.py b/plugins/python/exportlayers/uiexportlayers.py
index 625fbfad26..9b8c3239d9 100644
--- a/plugins/python/exportlayers/uiexportlayers.py
+++ b/plugins/python/exportlayers/uiexportlayers.py
@@ -1,180 +1,184 @@
 '''
 This script is licensed CC 0 1.0, so that you can learn from it.
 
 ------ CC 0 1.0 ---------------
 
 The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
 
 You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.
 
 https://creativecommons.org/publicdomain/zero/1.0/legalcode
 '''
-from exportlayers import exportlayersdialog
+from . import exportlayersdialog
 from PyQt5.QtCore import Qt
 from PyQt5.QtWidgets import (QFormLayout, QListWidget, QHBoxLayout,
                              QDialogButtonBox, QVBoxLayout, QFrame,
                              QPushButton, QAbstractScrollArea, QLineEdit,
                              QMessageBox, QFileDialog, QCheckBox, QSpinBox,
                              QComboBox)
 import os
 import errno
 import krita
 
 
 class UIExportLayers(object):
 
     def __init__(self):
         self.mainDialog = exportlayersdialog.ExportLayersDialog()
         self.mainLayout = QVBoxLayout(self.mainDialog)
         self.formLayout = QFormLayout()
         self.documentLayout = QVBoxLayout()
         self.directorySelectorLayout = QHBoxLayout()
         self.optionsLayout = QVBoxLayout()
         self.resolutionLayout = QHBoxLayout()
 
         self.refreshButton = QPushButton("Refresh")
         self.widgetDocuments = QListWidget()
         self.directoryTextField = QLineEdit()
         self.directoryDialogButton = QPushButton("...")
         self.exportFilterLayersCheckBox = QCheckBox("Export filter layers")
         self.batchmodeCheckBox = QCheckBox("Export in batchmode")
         self.ignoreInvisibleLayersCheckBox = QCheckBox("Ignore invisible layers")
         self.xResSpinBox = QSpinBox()
         self.yResSpinBox = QSpinBox()
         self.formatsComboBox = QComboBox()
 
         self.buttonBox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
 
         self.kritaInstance = krita.Krita.instance()
         self.documentsList = []
 
         self.directoryTextField.setReadOnly(True)
         self.batchmodeCheckBox.setChecked(True)
         self.directoryDialogButton.clicked.connect(self._selectDir)
         self.widgetDocuments.currentRowChanged.connect(self._setResolution)
         self.refreshButton.clicked.connect(self.refreshButtonClicked)
         self.buttonBox.accepted.connect(self.confirmButton)
         self.buttonBox.rejected.connect(self.mainDialog.close)
 
         self.mainDialog.setWindowModality(Qt.NonModal)
         self.widgetDocuments.setSizeAdjustPolicy(QAbstractScrollArea.AdjustToContents)
 
     def initialize(self):
         self.loadDocuments()
 
         self.xResSpinBox.setRange(1, 10000)
         self.yResSpinBox.setRange(1, 10000)
 
         self.formatsComboBox.addItem("jpeg")
         self.formatsComboBox.addItem("png")
 
         self.documentLayout.addWidget(self.widgetDocuments)
         self.documentLayout.addWidget(self.refreshButton)
 
         self.directorySelectorLayout.addWidget(self.directoryTextField)
         self.directorySelectorLayout.addWidget(self.directoryDialogButton)
 
         self.optionsLayout.addWidget(self.exportFilterLayersCheckBox)
         self.optionsLayout.addWidget(self.batchmodeCheckBox)
         self.optionsLayout.addWidget(self.ignoreInvisibleLayersCheckBox)
 
         self.resolutionLayout.addWidget(self.xResSpinBox)
         self.resolutionLayout.addWidget(self.yResSpinBox)
 
         self.formLayout.addRow('Documents', self.documentLayout)
         self.formLayout.addRow('Initial directory', self.directorySelectorLayout)
         self.formLayout.addRow('Export options', self.optionsLayout)
         self.formLayout.addRow('Resolution', self.resolutionLayout)
         self.formLayout.addRow('Images Extensions', self.formatsComboBox)
 
         self.line = QFrame()
         self.line.setFrameShape(QFrame.HLine)
         self.line.setFrameShadow(QFrame.Sunken)
 
         self.mainLayout.addLayout(self.formLayout)
         self.mainLayout.addWidget(self.line)
         self.mainLayout.addWidget(self.buttonBox)
 
         self.mainDialog.resize(500, 300)
         self.mainDialog.setWindowTitle("Export Layers")
         self.mainDialog.setSizeGripEnabled(True)
         self.mainDialog.show()
         self.mainDialog.activateWindow()
 
     def loadDocuments(self):
         self.widgetDocuments.clear()
 
         self.documentsList = [document for document in self.kritaInstance.documents() if document.fileName()]
 
         for document in self.documentsList:
             self.widgetDocuments.addItem(document.fileName())
 
     def refreshButtonClicked(self):
         self.loadDocuments()
 
     def confirmButton(self):
         selectedPaths = [item.text() for item in self.widgetDocuments.selectedItems()]
         selectedDocuments = [document for document in self.documentsList for path in selectedPaths if path == document.fileName()]
 
         self.msgBox = QMessageBox(self.mainDialog)
         if not selectedDocuments:
             self.msgBox.setText("Select one document.")
         elif not self.directoryTextField.text():
             self.msgBox.setText("Select the initial directory.")
         else:
             self.export(selectedDocuments[0])
             self.msgBox.setText("All layers has been exported.")
         self.msgBox.exec_()
 
     def mkdir(self, directory):
+        target_directory = self.directoryTextField.text() + directory
+        if os.path.exists(target_directory) and os.path.isdir(target_directory):
+            return
+
         try:
-            os.makedirs(self.directoryTextField.text() + directory)
+            os.makedirs(target_directory)
         except OSError as e:
-            if e.errno != errno.EEXIST:
-                raise
+            raise e
 
     def export(self, document):
         Application.setBatchmode(self.batchmodeCheckBox.isChecked())
 
         documentName = document.fileName() if document.fileName() else 'Untitled'
-        fileName, extension = str(documentName).rsplit('/', maxsplit=1)[-1].split('.', maxsplit=1)
+        fileName, extension = os.path.splitext(os.path.basename(documentName))
         self.mkdir('/' + fileName)
 
         self._exportLayers(document.rootNode(), self.formatsComboBox.currentText(), '/' + fileName)
         Application.setBatchmode(True)
 
     def _exportLayers(self, parentNode, fileFormat, parentDir):
         """ This method get all sub-nodes from the current node and export then in
             the defined format."""
 
         for node in parentNode.childNodes():
             newDir = ''
             if node.type() == 'grouplayer':
-                newDir = parentDir + '/' + node.name()
+                newDir = os.path.join(parentDir, node.name())
                 self.mkdir(newDir)
             elif not self.exportFilterLayersCheckBox.isChecked() and 'filter' in node.type():
                 continue
             elif self.ignoreInvisibleLayersCheckBox.isChecked() and not node.visible():
                 continue
             else:
                 nodeName = node.name()
                 _fileFormat = self.formatsComboBox.currentText()
                 if '[jpeg]' in nodeName:
                     _fileFormat = 'jpeg'
                 elif '[png]' in nodeName:
                     _fileFormat = 'png'
 
-                layerFileName = '{0}{1}/{2}.{3}'.format(self.directoryTextField.text(), parentDir, node.name(), _fileFormat)
-                teste = node.save(layerFileName, self.xResSpinBox.value(), self.yResSpinBox.value())
+                layerFileName = '{0}{1}/{2}.{3}'.format(self.directoryTextField.text(),
+                                                        parentDir, node.name(), _fileFormat)
+                node.save(layerFileName, self.xResSpinBox.value(), self.yResSpinBox.value())
 
             if node.childNodes():
                 self._exportLayers(node, fileFormat, newDir)
 
     def _selectDir(self):
         directory = QFileDialog.getExistingDirectory(self.mainDialog, "Select a folder", os.path.expanduser("~"), QFileDialog.ShowDirsOnly)
         self.directoryTextField.setText(directory)
 
     def _setResolution(self, index):
         document = self.documentsList[index]
         self.xResSpinBox.setValue(document.width())
         self.yResSpinBox.setValue(document.height())
diff --git a/plugins/python/filtermanager/components/filtermanagertreemodel.py b/plugins/python/filtermanager/components/filtermanagertreemodel.py
index b6576871ca..b2bb646938 100644
--- a/plugins/python/filtermanager/components/filtermanagertreemodel.py
+++ b/plugins/python/filtermanager/components/filtermanagertreemodel.py
@@ -1,134 +1,134 @@
 '''
 This script is licensed CC 0 1.0, so that you can learn from it.
 
 ------ CC 0 1.0 ---------------
 
 The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
 
 You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.
 
 https://creativecommons.org/publicdomain/zero/1.0/legalcode
 '''
 from PyQt5.QtCore import QAbstractItemModel, QFile, QIODevice, QModelIndex, Qt
 from PyQt5.QtWidgets import QApplication, QTreeView
-from filtermanager.components import filtermanagertreeitem
+from . import filtermanagertreeitem
 from PyQt5.QtGui import QPixmap
 
 
 class FilterManagerTreeModel(QAbstractItemModel):
 
     TYPE_COLUMN = 1
     NODE_COLUMN = 3
     DOCUMENT_COLUMN = 4
 
     def __init__(self, uiFilterManager, parent=None):
         super(FilterManagerTreeModel, self).__init__(parent)
 
         self.rootItem = filtermanagertreeitem.FilterManagerTreeItem(("Name", "Type", "Thumbnail"))
         self.uiFilterManager = uiFilterManager
         self._loadTreeModel(self.rootItem)
 
     def index(self, row, column, parent):
         if not self.hasIndex(row, column, parent):
             return QModelIndex()
 
         if parent.isValid():
             parentItem = parent.internalPointer()
         else:
             parentItem = self.rootItem
 
         # It's a FilterManagerTreeItem
         childItem = parentItem.child(row)
         if childItem:
             return self.createIndex(row, column, childItem)
         else:
             return QModelIndex()
 
     def parent(self, index):
         if not index.isValid():
             return QModelIndex()
 
         childItem = index.internalPointer()
         parentItem = childItem.parent()
 
         if parentItem == self.rootItem:
             return QModelIndex()
 
         return self.createIndex(parentItem.row(), 0, parentItem)
 
     def rowCount(self, parent):
         if parent.column() > 0:
             return 0
 
         if not parent.isValid():
             parentItem = self.rootItem
         else:
             parentItem = parent.internalPointer()
         return parentItem.childCount()
 
     def columnCount(self, parent):
         if parent.isValid():
             return parent.internalPointer().columnCount()
         else:
             return self.rootItem.columnCount()
 
     def data(self, index, role):
         if not index.isValid():
             return None
 
         item = index.internalPointer()
 
         if role == Qt.UserRole + 1:
             return item.data(self.NODE_COLUMN)
 
         if role == Qt.UserRole + 2:
             return item.data(self.DOCUMENT_COLUMN)
 
         if role == Qt.UserRole + 3:
             return item.data(self.TYPE_COLUMN)
 
         if role != Qt.DisplayRole and role != Qt.DecorationRole:
             return None
 
         return item.data(index.column())
 
     def flags(self, index):
         if not index.isValid():
             return Qt.NoItemFlags
 
         return Qt.ItemIsEnabled | Qt.ItemIsSelectable
 
     def headerData(self, section, orientation, role):
         if orientation == Qt.Horizontal and role == Qt.DisplayRole:
             return self.rootItem.data(section)
 
         return None
 
     def _loadTreeModel(self, parent):
         for index, document in enumerate(self.uiFilterManager.documents):
             rootNode = document.rootNode()
             columnData = (document.fileName(),
                           "Document",
                           QPixmap.fromImage(document.thumbnail(30, 30)),
                           rootNode, index)
             item = filtermanagertreeitem.FilterManagerTreeItem(columnData, parent)
             parent.appendChild(item)
 
             childNodes = rootNode.childNodes()
             if len(childNodes):
                 self._addSubNodes(childNodes[::-1], item, index)
 
     def _addSubNodes(self, nodes, parent, documentIndex):
         for node in nodes:
             nodeName = node.name()
             nodeType = node.type()
             columnData = ("Unnamed" if nodeName == '' else nodeName,
                           "Untyped" if nodeType == '' else nodeType,
                           QPixmap.fromImage(node.thumbnail(30, 30)),
                           node, documentIndex)
             item = filtermanagertreeitem.FilterManagerTreeItem(columnData, parent)
             parent.appendChild(item)
 
             childNodes = node.childNodes()
             if len(childNodes):
                 self._addSubNodes(childNodes[::-1], item, documentIndex)
diff --git a/plugins/python/filtermanager/filtermanager.py b/plugins/python/filtermanager/filtermanager.py
index 0e9e3fd8d5..63ea46f32b 100644
--- a/plugins/python/filtermanager/filtermanager.py
+++ b/plugins/python/filtermanager/filtermanager.py
@@ -1,34 +1,34 @@
 '''
 This script is licensed CC 0 1.0, so that you can learn from it.
 
 ------ CC 0 1.0 ---------------
 
 The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
 
 You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.
 
 https://creativecommons.org/publicdomain/zero/1.0/legalcode
 '''
 import krita
-from filtermanager import uifiltermanager
+from . import uifiltermanager
 
 
 class FilterManagerExtension(krita.Extension):
 
     def __init__(self, parent):
         super(FilterManagerExtension, self).__init__(parent)
 
     def setup(self):
         pass
-    
+
     def createActions(self, window):
         action = window.createAction("filter_manager", "Filter Manager")
         action.setToolTip("Plugin to filters management")
         action.triggered.connect(self.initialize)
 
     def initialize(self):
         self.uifiltermanager = uifiltermanager.UIFilterManager()
         self.uifiltermanager.initialize()
 
 
 Scripter.addExtension(FilterManagerExtension(krita.Krita.instance()))
diff --git a/plugins/python/filtermanager/kritapykrita_filtermanager.desktop b/plugins/python/filtermanager/kritapykrita_filtermanager.desktop
index fbe35a8100..ac62400059 100644
--- a/plugins/python/filtermanager/kritapykrita_filtermanager.desktop
+++ b/plugins/python/filtermanager/kritapykrita_filtermanager.desktop
@@ -1,41 +1,41 @@
 [Desktop Entry]
 Type=Service
 ServiceTypes=Krita/PythonPlugin
 X-KDE-Library=filtermanager
-X-Python-2-Compatible=false
+X-Python-2-Compatible=true
 X-Krita-Manual=Manual.html
 Name=Filter Manager
 Name[ca]=Gestor de filtres
 Name[ca@valencia]=Gestor de filtres
 Name[cs]=Správce filtrů
 Name[de]=Filterverwaltung
 Name[en_GB]=Filter Manager
 Name[es]=Gestor de filtros
 Name[gl]=Xestor de filtros
 Name[it]=Gestore dei filtri
 Name[nl]=Filterbeheerder
 Name[pl]=Zarządzanie filtrami
 Name[pt]=Gestor de Filtros
 Name[sv]=Filterhantering
 Name[tr]=Süzgeç Yöneticisi
 Name[uk]=Керування фільтрами
 Name[x-test]=xxFilter Managerxx
 Name[zh_CN]=滤镜管理器
 Name[zh_TW]=濾鏡管理器
 Comment=Plugin to filters management
 Comment[ca]=Un connector per gestionar filtres
 Comment[ca@valencia]=Un connector per gestionar filtres
 Comment[cs]=Modul pro správu filtrů
 Comment[en_GB]=Plugin to filters management
 Comment[es]=Complemento para la gestión de filtros
 Comment[gl]=Complemento para a xestión de filtros.
 Comment[it]=Estensione per la gestione dei filtri
 Comment[nl]=Plug-in om filters te beheren
 Comment[pl]=Wtyczka do zarządzania filtrami
 Comment[pt]='Plugin' para a gestão de filtros
 Comment[sv]=Insticksprogram för filterhantering
 Comment[tr]=Süzgeç yönetimi için eklenti
 Comment[uk]=Додаток для керування фільтрами
 Comment[x-test]=xxPlugin to filters managementxx
 Comment[zh_CN]=滤镜管理插件
 Comment[zh_TW]=用於濾鏡管理的外掛程式
diff --git a/plugins/python/filtermanager/uifiltermanager.py b/plugins/python/filtermanager/uifiltermanager.py
index 9e137e35a5..fa6b794686 100644
--- a/plugins/python/filtermanager/uifiltermanager.py
+++ b/plugins/python/filtermanager/uifiltermanager.py
@@ -1,107 +1,107 @@
 '''
 This script is licensed CC 0 1.0, so that you can learn from it.
 
 ------ CC 0 1.0 ---------------
 
 The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
 
 You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.
 
 https://creativecommons.org/publicdomain/zero/1.0/legalcode
 '''
-from filtermanager import filtermanagerdialog
-from filtermanager.components import (filtercombobox, filtermanagertreemodel)
+from . import filtermanagerdialog
+from .components import (filtercombobox, filtermanagertreemodel)
 from PyQt5.QtCore import Qt
 from PyQt5.QtWidgets import (QFormLayout, QAbstractItemView, QDialogButtonBox,
                              QVBoxLayout, QFrame, QAbstractScrollArea, QWidget,
                              QTreeView)
 import krita
 
 
 class UIFilterManager(object):
 
     def __init__(self):
         self.mainDialog = filtermanagerdialog.FilterManagerDialog()
         self.mainLayout = QVBoxLayout(self.mainDialog)
         self.formLayout = QFormLayout()
         self.buttonBox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
 
         self.kritaInstance = krita.Krita.instance()
         self._filters = sorted(self.kritaInstance.filters())
         self._documents = self.kritaInstance.documents()
         self.treeModel = filtermanagertreemodel.FilterManagerTreeModel(self)
 
         self.documentsTreeView = QTreeView()
         self.filterComboBox = filtercombobox.FilterComboBox(self)
 
         self.buttonBox.accepted.connect(self.confirmButton)
         self.buttonBox.rejected.connect(self.mainDialog.close)
 
         self.documentsTreeView.setSelectionMode(QAbstractItemView.SingleSelection)
         self.mainDialog.setWindowModality(Qt.NonModal)
 
     def initialize(self):
         self.documentsTreeView.setModel(self.treeModel)
         self.documentsTreeView.setWindowTitle("Document Tree Model")
         self.documentsTreeView.resizeColumnToContents(0)
         self.documentsTreeView.resizeColumnToContents(1)
         self.documentsTreeView.resizeColumnToContents(2)
 
         self.formLayout.addRow("Filters", self.filterComboBox)
 
         self.line = QFrame()
         self.line.setFrameShape(QFrame.HLine)
         self.line.setFrameShadow(QFrame.Sunken)
 
         self.mainLayout.addWidget(self.documentsTreeView)
         self.mainLayout.addLayout(self.formLayout)
         self.mainLayout.addWidget(self.line)
         self.mainLayout.addWidget(self.buttonBox)
 
         self.mainDialog.resize(500, 300)
         self.mainDialog.setWindowTitle("Filter Manager")
         self.mainDialog.setSizeGripEnabled(True)
         self.mainDialog.show()
         self.mainDialog.activateWindow()
 
     def confirmButton(self):
         documentsIndexes = []
 
         selectionModel = self.documentsTreeView.selectionModel()
         for index in selectionModel.selectedRows():
             node = self.treeModel.data(index, Qt.UserRole + 1)
             documentIndex = self.treeModel.data(index, Qt.UserRole + 2)
             _type = self.treeModel.data(index, Qt.UserRole + 3)
 
             if _type == 'Document':
                 self.applyFilterOverDocument(self.documents[documentIndex])
             else:
                 self.applyFilterOverNode(node, self.documents[documentIndex])
 
             documentsIndexes.append(documentIndex)
 
         self.refreshDocumentsProjections(set(documentsIndexes))
 
     def refreshDocumentsProjections(self, indexes):
         for index in indexes:
             document = self.documents[index]
             document.refreshProjection()
 
     def applyFilterOverNode(self, node, document):
         _filter = self.kritaInstance.filter(self.filterComboBox.currentText())
         _filter.apply(node, 0, 0, document.width(), document.height())
 
     def applyFilterOverDocument(self, document):
         """ This method applies the selected filter just to topLevelNodes, then
             if topLevelNodes are GroupLayers, that filter will not be applied. """
 
         for node in document.topLevelNodes():
             self.applyFilterOverNode(node, document)
 
     @property
     def filters(self):
         return self._filters
 
     @property
     def documents(self):
         return self._documents
diff --git a/plugins/python/hello/hello.py b/plugins/python/hello/hello.py
index bd31a90068..677d85af87 100644
--- a/plugins/python/hello/hello.py
+++ b/plugins/python/hello/hello.py
@@ -1,88 +1,88 @@
 '''
 This script is licensed CC 0 1.0, so that you can learn from it.
 
 ------ CC 0 1.0 ---------------
 
 The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
 
 You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.
 
 https://creativecommons.org/publicdomain/zero/1.0/legalcode
 '''
-"""
-This is a simple example of a Python script for Krita.
-It demonstrates how to set up a custom extension and a custom docker!
-"""
+#
+# This is a simple example of a Python script for Krita.
+# It demonstrates how to set up a custom extension and a custom docker!
+#
 
-from PyQt5.QtCore import qDebug
 from PyQt5.QtWidgets import QWidget, QLabel, QMessageBox
-from krita import Krita, Extension, DockWidget, DockWidgetFactory, DockWidgetFactoryBase
+from krita import (Krita, Extension, DockWidget,
+                   DockWidgetFactory, DockWidgetFactoryBase)
 
 
 def hello():
     """
     Show a test message box.
     """
     QMessageBox.information(QWidget(), i18n("Test"), i18n("Hello! This is Krita version %s") % Application.version())
 
 
 class HelloExtension(Extension):
     """
     HelloExtension is a small example extension demonstrating basic Python scripting support in Krita!
     """
 
     def __init__(self, parent):
         """
         Standard Krita Python extension constructor.
         Most of the initialization happens in :func:`setup`
 
         :param parent: Parent widget
         :type parent: :class:`QWidget` or None
         """
-        super().__init__(parent)
+        super(HelloExtension, self).__init__(parent)
 
     def setup(self):
         pass
 
     def createActions(self, window):
         """
         This is where most of the setup takes place!
         """
         action = window.createAction("hello_python", "hello")
         action.triggered.connect(hello)
 
 
 # Initialize and add the extension
 Scripter.addExtension(HelloExtension(Krita.instance()))
 
 
 class HelloDocker(DockWidget):
     """
     The HelloDocker is an example of a simple Python-based docker.
     """
 
     def __init__(self):
         """
         Constructs an instance of HelloDocker and the widget it contains
         """
-        super().__init__()
+        super(HelloDocker, self).__init__()
 
         # The window title is also used in the Docker menu,
         # so it should be set to something sensible!
         self.setWindowTitle("HelloDocker")
         label = QLabel("Hello", self)
         self.setWidget(label)
         self._label = label
 
     def canvasChanged(self, canvas):
         """
         Override canvasChanged from :class:`DockWidget`.
         This gets called when the canvas changes.
         You can also access the active canvas via :func:`DockWidget.canvas`
         Parameter `canvas` can be null if the last document is closed
         """
         self._label.setText("HelloDocker: canvas changed")
 
 
 # Register the docker so Krita can use it!
 Application.addDockWidgetFactory(DockWidgetFactory("hello", DockWidgetFactoryBase.DockRight, HelloDocker))
diff --git a/plugins/python/hello/kritapykrita_hello.desktop b/plugins/python/hello/kritapykrita_hello.desktop
index 015757a3d1..db7810b099 100644
--- a/plugins/python/hello/kritapykrita_hello.desktop
+++ b/plugins/python/hello/kritapykrita_hello.desktop
@@ -1,41 +1,41 @@
 [Desktop Entry]
 Type=Service
 ServiceTypes=Krita/PythonPlugin
 X-KDE-Library=hello
 X-Krita-Manual=Manual.html
-X-Python-2-Compatible=false
+X-Python-2-Compatible=true
 Name=Hello World
 Name[ca]=Hola món
 Name[ca@valencia]=Hola món
 Name[cs]=Hello World
 Name[en_GB]=Hello World
 Name[es]=Hola mundo
 Name[fr]=Bonjour tout le monde
 Name[gl]=Ola mundo
 Name[it]=Ciao mondo
 Name[nl]=Hallo wereld
 Name[pl]=Witaj świecie
 Name[pt]=Olá Mundo
 Name[sv]=Hello World
 Name[tr]=Merhaba Dünya
 Name[uk]=Привіт, світе
 Name[x-test]=xxHello Worldxx
 Name[zh_CN]=Hello World
 Name[zh_TW]=你好，世界
 Comment=Basic plugin to test PyKrita
 Comment[ca]=Connector bàsic per provar el PyKrita
 Comment[ca@valencia]=Connector bàsic per provar el PyKrita
 Comment[cs]=Základní modul pro testování PyKrita
 Comment[en_GB]=Basic plugin to test PyKrita
 Comment[es]=Complemento básico para probar PyKrita
 Comment[gl]=Complemento básico para probar PyKrita.
 Comment[it]=Estensione di base per provare PyKrita
 Comment[nl]=Basisplug-in om PyKrita te testen
 Comment[pl]=Podstawowa wtyczka do wypróbowania PyKrity
 Comment[pt]='Plugin' básico para testar o PyKrita
 Comment[sv]=Enkelt insticksprogram för att utprova PyKrita
 Comment[tr]=PyKrita'yı test etmek için temel eklenti
 Comment[uk]=Базовий додаток для тестування PyKrita
 Comment[x-test]=xxBasic plugin to test PyKritaxx
 Comment[zh_CN]=测试 PyKrita 的基本插件
 Comment[zh_TW]=測試 PyKrita 的基本外掛程式
diff --git a/plugins/python/lastdocumentsdocker/lastdocumentsdocker.py b/plugins/python/lastdocumentsdocker/lastdocumentsdocker.py
index 5f14d3d1eb..449a4ba278 100644
--- a/plugins/python/lastdocumentsdocker/lastdocumentsdocker.py
+++ b/plugins/python/lastdocumentsdocker/lastdocumentsdocker.py
@@ -1,47 +1,47 @@
 '''
 This script is licensed CC 0 1.0, so that you can learn from it.
 
 ------ CC 0 1.0 ---------------
 
 The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
 
 You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.
 
 https://creativecommons.org/publicdomain/zero/1.0/legalcode
 '''
 from PyQt5.QtWidgets import QWidget, QVBoxLayout, QListView, QPushButton
 import krita
-from lastdocumentsdocker import lastdocumentslistmodel
+from . import lastdocumentslistmodel
 
 
 class LastDocumentsDocker(krita.DockWidget):
 
     def __init__(self):
         super(LastDocumentsDocker, self).__init__()
 
         self.baseWidget = QWidget()
         self.layout = QVBoxLayout()
         self.listView = QListView()
         self.loadButton = QPushButton("Refresh")
         self.listModel = lastdocumentslistmodel.LastDocumentsListModel()
 
         self.listView.setModel(self.listModel)
         self.listView.setFlow(QListView.LeftToRight)
 
         self.layout.addWidget(self.listView)
         self.layout.addWidget(self.loadButton)
 
         self.baseWidget.setLayout(self.layout)
         self.setWidget(self.baseWidget)
 
         self.loadButton.clicked.connect(self.refreshRecentDocuments)
         self.setWindowTitle("Last Documents Docker")
 
     def canvasChanged(self, canvas):
         pass
 
     def refreshRecentDocuments(self):
         self.listModel.loadRecentDocuments()
 
 
 Application.addDockWidgetFactory(krita.DockWidgetFactory("lastdocumentsdocker", krita.DockWidgetFactoryBase.DockRight, LastDocumentsDocker))
diff --git a/plugins/python/palette_docker/kritapykrita_palette_docker.desktop b/plugins/python/palette_docker/kritapykrita_palette_docker.desktop
index 016c5f376c..3487b693bc 100644
--- a/plugins/python/palette_docker/kritapykrita_palette_docker.desktop
+++ b/plugins/python/palette_docker/kritapykrita_palette_docker.desktop
@@ -1,40 +1,40 @@
 [Desktop Entry]
 Type=Service
 ServiceTypes=Krita/PythonPlugin
 X-KDE-Library=palette_docker
-X-Python-2-Compatible=false
+X-Python-2-Compatible=true
 X-Krita-Manual=Manual.html
 Name=Palette docker
 Name[ca]=Acoblador de paletes
 Name[ca@valencia]=Acoblador de paletes
 Name[cs]=Dok palet
 Name[de]=Paletten-Docker
 Name[en_GB]=Palette docker
 Name[es]=Panel de paleta
 Name[gl]=Doca de paleta
 Name[it]=Area di aggancio della tavolozza
 Name[nl]=Vastzetter van palet
 Name[pl]=Dok palety
 Name[pt]=Área da Paleta
 Name[sv]=Dockningsfönster för palett
 Name[tr]=Palet doku
 Name[uk]=Панель палітри
 Name[x-test]=xxPalette dockerxx
 Name[zh_CN]=调色板坞窗
 Name[zh_TW]=「調色盤」面板
 Comment=A Python-based docker to edit color palettes.
 Comment[ca]=Un acoblador basant en el Python per editar paletes de colors.
 Comment[ca@valencia]=Un acoblador basant en el Python per editar paletes de colors.
 Comment[en_GB]=A Python-based docker to edit colour palettes.
 Comment[es]=Un panel basado en Python para editar paletas de colores.
 Comment[gl]=Unha doca baseada en Python para editar paletas de cores.
 Comment[it]=Un'area di aggancio per modificare le tavolozze di colori basata su Python.
 Comment[nl]=Een op Python gebaseerde vastzetter om kleurpaletten te bewerken.
 Comment[pl]=Dok oparty na Pythonie do edytowania palet kolorów.
 Comment[pt]=Um área acoplável em Python para editar as paletas de cores.
 Comment[sv]=Ett Python-baserat dockningsfönster för att redigera färgpaletter.
 Comment[tr]=Renk paletlerini düzenlemek için Python-tabanlı bir dok.
 Comment[uk]=Бічна панель для редагування палітр кольорів на основі Python.
 Comment[x-test]=xxA Python-based docker to edit color palettes.xx
 Comment[zh_CN]=基于 Python 的调色板编辑坞窗
 Comment[zh_TW]=基於 Python 的面板，用於編輯調色盤。
diff --git a/plugins/python/palette_docker/palette_docker.py b/plugins/python/palette_docker/palette_docker.py
index 09485281d3..8ccbb248fd 100644
--- a/plugins/python/palette_docker/palette_docker.py
+++ b/plugins/python/palette_docker/palette_docker.py
@@ -1,259 +1,259 @@
 '''
 Description: A Python based docker that allows you to edit KPL color palettes.
 
 By Wolthera(originally)
 
 This script is licensed CC 0 1.0, so that you can learn from it.
 
 ------ CC 0 1.0 ---------------
 
 The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
 
 You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.
 
 https://creativecommons.org/publicdomain/zero/1.0/legalcode
 
 @package palette_docker
 '''
 
 # Importing the relevant dependencies:
 import sys
 from PyQt5.QtGui import QPixmap, QIcon, QImage, QPainter, QBrush, QPalette
 from PyQt5.QtWidgets import QWidget, QVBoxLayout, QHBoxLayout, QComboBox, QAction, QTabWidget, QLineEdit, QSpinBox, QDialogButtonBox, QToolButton, QDialog, QPlainTextEdit, QCompleter, QMenu
 from PyQt5.Qt import Qt, pyqtSignal, pyqtSlot
 import math
 from krita import *
 
 # import the exporters
 from . import palette_exporter_gimppalette, palette_exporter_inkscapeSVG, palette_sortColors
 
 
 class Palette_Docker(DockWidget):
     # Init the docker
 
     def __init__(self):
-        super().__init__()
+        super(Palette_Docker, self).__init__()
         # make base-widget and layout
         widget = QWidget()
         layout = QVBoxLayout()
         buttonLayout = QHBoxLayout()
         widget.setLayout(layout)
         self.setWindowTitle("Python Palette Docker")
 
         # Make a combobox and add palettes
         self.cmb_palettes = QComboBox()
         allPalettes = Application.resources("palette")
         for palette_name in allPalettes:
             self.cmb_palettes.addItem(palette_name)
             self.cmb_palettes.model().sort(0)
 
         if len(allPalettes.keys()) > 0:
             self.currentPalette = Palette(allPalettes[list(allPalettes.keys())[0]])
         else:
             self.currentPalette = None
 
         self.cmb_palettes.currentTextChanged.connect(self.slot_paletteChanged)
         layout.addWidget(self.cmb_palettes)  # add combobox to the layout
         self.paletteView = PaletteView()
         self.paletteView.setPalette(self.currentPalette)
         layout.addWidget(self.paletteView)
         self.paletteView.entrySelectedForeGround.connect(self.slot_swatchSelected)
 
         self.colorComboBox = QComboBox()
         self.colorList = list()
         buttonLayout.addWidget(self.colorComboBox)
         self.addEntry = QAction(self)
         self.addEntry.setIconText("+")
         self.addEntry.triggered.connect(self.slot_add_entry)
         self.addGroup = QAction(self)
         self.addGroup.triggered.connect(self.slot_add_group)
         self.addGroup.setText("Add Group")
         self.addGroup.setIconText(str("\U0001F4C2"))
         self.removeEntry = QAction(self)
         self.removeEntry.setText("Remove Entry")
         self.removeEntry.setIconText("-")
         self.removeEntry.triggered.connect(self.slot_remove_entry)
         addEntryButton = QToolButton()
         addEntryButton.setDefaultAction(self.addEntry)
         buttonLayout.addWidget(addEntryButton)
         addGroupButton = QToolButton()
         addGroupButton.setDefaultAction(self.addGroup)
         buttonLayout.addWidget(addGroupButton)
         removeEntryButton = QToolButton()
         removeEntryButton.setDefaultAction(self.removeEntry)
         buttonLayout.addWidget(removeEntryButton)
 
         # QActions
         self.extra = QToolButton()
         self.editPaletteData = QAction(self)
         self.editPaletteData.setText("Edit Palette Settings")
         self.editPaletteData.triggered.connect(self.slot_edit_palette_data)
         self.extra.setDefaultAction(self.editPaletteData)
         buttonLayout.addWidget(self.extra)
         self.actionMenu = QMenu()
         self.exportToGimp = QAction(self)
         self.exportToGimp.setText("Export as GIMP palette file.")
         self.exportToGimp.triggered.connect(self.slot_export_to_gimp_palette)
         self.exportToInkscape = QAction(self)
         self.exportToInkscape.setText("Export as Inkscape SVG with swatches.")
         self.exportToInkscape.triggered.connect(self.slot_export_to_inkscape_svg)
         self.sortColors = QAction(self)
         self.sortColors.setText("Sort colors")
         self.sortColors.triggered.connect(self.slot_sort_colors)
         self.actionMenu.addAction(self.editPaletteData)
         self.actionMenu.addAction(self.exportToGimp)
         self.actionMenu.addAction(self.exportToInkscape)
         # self.actionMenu.addAction(self.sortColors)
 
         self.extra.setMenu(self.actionMenu)
 
         layout.addLayout(buttonLayout)
         self.slot_fill_combobox()
         self.setWidget(widget)        # add widget to the docker
 
     def slot_paletteChanged(self, name):
         allPalettes = Application.resources("palette")
         if len(allPalettes) > 0 and name in allPalettes:
             self.currentPalette = Palette(Application.resources("palette")[name])
             self.paletteView.setPalette(self.currentPalette)
             self.slot_fill_combobox()
 
     @pyqtSlot('KoColorSetEntry')
     def slot_swatchSelected(self, entry):
         print("entry " + entry.name)
         if (self.canvas()) is not None:
             if (self.canvas().view()) is not None:
                 name = entry.name
                 if len(entry.id) > 0:
                     name = entry.id + " - " + entry.name
                 if len(name) > 0:
                     if name in self.colorList:
                         self.colorComboBox.setCurrentIndex(self.colorList.index(name))
                 color = self.currentPalette.colorForEntry(entry)
                 self.canvas().view().setForeGroundColor(color)
     '''
     A function for making a combobox with the available colors. We use QCompleter on the colorComboBox so that people
     can type in the name of a color to select it. This is useful for people with carefully made palettes where the colors
     are named properly, which makes it easier for them to find colors.
     '''
 
     def slot_fill_combobox(self):
         if self.currentPalette is None:
             pass
         palette = self.currentPalette
         self.colorComboBox.clear()
-        self.colorList.clear()
+        self.colorList = list()
         for i in range(palette.colorsCountTotal()):
             entry = palette.colorSetEntryByIndex(i)
             color = palette.colorForEntry(entry).colorForCanvas(self.canvas())
             colorSquare = QPixmap(12, 12)
             if entry.spotColor is True:
                 img = colorSquare.toImage()
                 circlePainter = QPainter()
                 img.fill(self.colorComboBox.palette().color(QPalette.Base))
                 circlePainter.begin(img)
                 brush = QBrush(Qt.SolidPattern)
                 brush.setColor(color)
                 circlePainter.setBrush(brush)
                 circlePainter.pen().setWidth(0)
                 circlePainter.drawEllipse(0, 0, 11, 11)
                 circlePainter.end()
                 colorSquare = QPixmap.fromImage(img)
             else:
                 colorSquare.fill(color)
             name = entry.name
             if len(entry.id) > 0:
                 name = entry.id + " - " + entry.name
             self.colorList.append(name)
             self.colorComboBox.addItem(QIcon(colorSquare), name)
         self.colorComboBox.setEditable(True)
         self.colorComboBox.setInsertPolicy(QComboBox.NoInsert)
         self.colorComboBox.completer().setCompletionMode(QCompleter.PopupCompletion)
         self.colorComboBox.completer().setCaseSensitivity(False)
         self.colorComboBox.completer().setFilterMode(Qt.MatchContains)
         self.colorComboBox.currentIndexChanged.connect(self.slot_get_color_from_combobox)
 
     def slot_get_color_from_combobox(self):
         if self.currentPalette is not None:
             entry = self.currentPalette.colorSetEntryByIndex(self.colorComboBox.currentIndex())
             self.slot_swatchSelected(entry)
 
     def slot_add_entry(self):
         if (self.canvas()) is not None:
             if (self.canvas().view()) is not None:
                 color = self.canvas().view().foregroundColor()
                 success = self.paletteView.addEntryWithDialog(color)
                 if success is True:
                     self.slot_fill_combobox()
 
     def slot_add_group(self):
         success = self.paletteView.addGroupWithDialog()
         if success is True:
             self.slot_fill_combobox()
 
     def slot_remove_entry(self):
         success = self.paletteView.removeSelectedEntryWithDialog()
         if success is True:
             self.slot_fill_combobox()
 
     '''
     A function for giving a gui to edit palette metadata... I also want this to be the way to edit the settings of the
     palette docker.
     '''
 
     def slot_edit_palette_data(self):
         dialog = QDialog(self)
         tabWidget = QTabWidget()
         dialog.setWindowTitle("Edit Palette Data")
         dialog.setLayout(QVBoxLayout())
         dialog.layout().addWidget(tabWidget)
         paletteWidget = QWidget()
         paletteWidget.setLayout(QVBoxLayout())
         tabWidget.addTab(paletteWidget, "Palette Data")
         paletteName = QLineEdit()
         paletteName.setText(self.cmb_palettes.currentText())
         paletteWidget.layout().addWidget(paletteName)
         paletteColumns = QSpinBox()
         paletteColumns.setValue(self.currentPalette.columnCount())
         paletteWidget.layout().addWidget(paletteColumns)
         paletteComment = QPlainTextEdit()
         paletteComment.appendPlainText(self.currentPalette.comment())
         paletteWidget.layout().addWidget(paletteComment)
         buttons = QDialogButtonBox(QDialogButtonBox.Ok)
         dialog.layout().addWidget(buttons)
         buttons.accepted.connect(dialog.accept)
         # buttons.rejected.connect(dialog.reject())
 
         if dialog.exec_() == QDialog.Accepted:
             Resource = Application.resources("palette")[self.cmb_palettes.currentText()]
             Resource.setName(paletteName.text())
             self.currentPalette = Palette(Resource)
             print(paletteColumns.value())
             self.currentPalette.setColumnCount(paletteColumns.value())
             self.paletteView.setPalette(self.currentPalette)
             self.slot_fill_combobox()
             self.currentPalette.setComment(paletteComment.toPlainText())
             self.currentPalette.save()
 
     def slot_export_to_gimp_palette(self):
         palette_exporter_gimppalette.gimpPaletteExporter(self.cmb_palettes.currentText())
 
     def slot_export_to_inkscape_svg(self):
         palette_exporter_inkscapeSVG.inkscapeSVGExporter(self.cmb_palettes.currentText())
 
     def slot_sort_colors(self):
         colorSorter = palette_sortColors.sortColors(self.cmb_palettes.currentText())
         self.paletteView.setPalette(colorSorter.palette())
 
     def canvasChanged(self, canvas):
         self.cmb_palettes.clear()
         allPalettes = Application.resources("palette")
         for palette_name in allPalettes:
             self.cmb_palettes.addItem(palette_name)
             self.cmb_palettes.model().sort(0)
 
         if self.currentPalette == None and len(allPalettes.keys()) > 0:
             self.currentPalette = Palette(allPalettes[list(allPalettes.keys())[0]])
 
 # Add docker to the application :)
 Application.addDockWidgetFactory(DockWidgetFactory("palette_docker", DockWidgetFactoryBase.DockRight, Palette_Docker))
diff --git a/plugins/python/palette_docker/palette_sortColors.py b/plugins/python/palette_docker/palette_sortColors.py
index 78bad6a946..d497a09d46 100644
--- a/plugins/python/palette_docker/palette_sortColors.py
+++ b/plugins/python/palette_docker/palette_sortColors.py
@@ -1,80 +1,78 @@
 '''
 A script that sorts the colors in the group.
 
 By Wolthera(originally)
 
 This script is licensed CC 0 1.0, so that you can learn from it.
 
 ------ CC 0 1.0 ---------------
 
 The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
 
 You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.
 
 https://creativecommons.org/publicdomain/zero/1.0/legalcode
 
 @package palette_docker
 '''
 
 
 # Importing the relevant dependencies:
-import sys
-import math
 from krita import *
 
 
-class sortColors:
+class sortColors(object):
 
     def __init__(self, name):
         # We want people to select a palette...
         allPalettes = Application.resources("palette")
         self.paletteName = name
         self.currentPalette = Palette(allPalettes[self.paletteName])
         self.sort_all_groups()
 
     def sort_all_groups(self):
         self.sort_color_by_name(str())
         groupNames = self.currentPalette.groupNames()
         for groupName in groupNames:
             self.sort_color_by_name(groupName)
 
     def sort_color_by_name(self, groupName):
         l = {}
         colorCount = self.currentPalette.colorsCountGroup(groupName)
         for i in range(colorCount - 1, -1, -1):
             entry = self.currentPalette.colorSetEntryFromGroup((i), groupName)
             l[entry.name + str(i)] = entry
             self.currentPalette.removeEntry((i), groupName)
 
         for s in sorted(l):
             self.currentPalette.addEntry(l[s], groupName)
 
     def sort_color_by_id(self, groupName):
         l = {}
         colorCount = self.currentPalette.colorsCountGroup(groupName)
         for i in range(colorCount - 1, -1, -1):
             entry = self.currentPalette.colorSetEntryFromGroup((i), groupName)
             l[entry.id + " " + str(i)] = entry
             self.currentPalette.removeEntry((i), groupName)
 
         for s in sorted(l):
             self.currentPalette.addEntry(l[s], groupName)
 
     def sort_by_value(self, groupName):
         l = {}
         colorCount = self.currentPalette.colorsCountGroup(groupName)
         for i in range(colorCount - 1, -1, -1):
             entry = self.currentPalette.colorSetEntryFromGroup((i), groupName)
             color = self.currentPalette.colorForEntry(entry)
             color.setColorSpace("RGBA", "U8", "sRGB built-in")
             l[color.components()[0] + color.components()[1] + color.components()[2]] = entry
             self.currentPalette.removeEntry((i), groupName)
 
         for s in sorted(l):
             self.currentPalette.addEntry(l[s], groupName)
 
     def sort_by_hue(self, stepsize, groupName):
         pass
 
     def palette(self):
         return self.currentPalette
diff --git a/plugins/python/quick_settings_docker/kritapykrita_quick_settings_docker.desktop b/plugins/python/quick_settings_docker/kritapykrita_quick_settings_docker.desktop
index b84a4f59f9..51a5f4256b 100644
--- a/plugins/python/quick_settings_docker/kritapykrita_quick_settings_docker.desktop
+++ b/plugins/python/quick_settings_docker/kritapykrita_quick_settings_docker.desktop
@@ -1,39 +1,39 @@
 [Desktop Entry]
 Type=Service
 ServiceTypes=Krita/PythonPlugin
 X-KDE-Library=quick_settings_docker
-X-Python-2-Compatible=false
+X-Python-2-Compatible=true
 X-Krita-Manual=Manual.html
 Name=Quick Settings Docker
 Name[ca]=Acoblador d'arranjament ràpid
 Name[ca@valencia]=Acoblador d'arranjament ràpid
 Name[cs]=Dok pro rychlé nastavení
 Name[en_GB]=Quick Settings Docker
 Name[es]=Panel de ajustes rápidos
 Name[gl]=Doca de configuración rápida
 Name[it]=Area di aggancio delle impostazioni rapide
 Name[nl]=Vastzetter voor snelle instellingen
 Name[pl]=Dok szybkich ustawień
 Name[pt]=Área de Configuração Rápida
 Name[sv]=Dockningspanel med snabbinställningar
 Name[tr]=Hızlı Ayarlar Doku
 Name[uk]=Панель швидких параметрів
 Name[x-test]=xxQuick Settings Dockerxx
 Name[zh_CN]=快速设置坞窗
 Name[zh_TW]=「快速設定」面板
 Comment=A Python-based docker for quickly changing brush size and opacity.
 Comment[ca]=Un acoblador basant en el Python per canviar ràpidament la mida del pinzell i l'opacitat.
 Comment[ca@valencia]=Un acoblador basant en el Python per canviar ràpidament la mida del pinzell i l'opacitat.
 Comment[en_GB]=A Python-based docker for quickly changing brush size and opacity.
 Comment[es]=Un panel basado en Python para cambiar rápidamente el tamaño y la opacidad del pincel.
 Comment[gl]=Unha doca baseada en Python para cambiar rapidamente a opacidade e o tamaño dos pinceis.
 Comment[it]=Un'area di aggancio basata su Python per cambiare rapidamente la dimensione del pennello e l'opacità.
 Comment[nl]=Een op Python gebaseerde vastzetter om snel penseelgrootte en dekking te wijzigen.
 Comment[pl]=Dok oparty na Pythonie do szybkiej zmiany rozmiaru i nieprzezroczystości pędzli.
 Comment[pt]=Um área acoplável em Python para mudar rapidamente o tamanho e opacidade do pincel.
 Comment[sv]=En Python-baserad dockningspanel för att snabbt ändra penselstorlek och ogenomskinlighet.
 Comment[tr]=Fırça boyutunu ve matlığını hızlıca değiştirmek için Python-tabanlı bir dok.
 Comment[uk]=Панель на основі мови програмування Python для швидкої зміни розміру та непрозорості пензля.
 Comment[x-test]=xxA Python-based docker for quickly changing brush size and opacity.xx
 Comment[zh_CN]=基于 Python 的坞窗，用于快速更改笔刷尺寸和透明度。
 Comment[zh_TW]=基於 Python 的面板，用於快速變更筆刷尺寸和不透明度。
diff --git a/plugins/python/quick_settings_docker/quick_settings_docker.py b/plugins/python/quick_settings_docker/quick_settings_docker.py
index 24312be815..1add2d6a18 100644
--- a/plugins/python/quick_settings_docker/quick_settings_docker.py
+++ b/plugins/python/quick_settings_docker/quick_settings_docker.py
@@ -1,175 +1,175 @@
 '''
 Description: A Python based docker for quickly choosing the brushsize like similar dockers in other drawing programs.
 
 By Wolthera(originally)
 
 This script is licensed CC 0 1.0, so that you can learn from it.
 
 ------ CC 0 1.0 ---------------
 
 The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
 
 You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.
 
 https://creativecommons.org/publicdomain/zero/1.0/legalcode
 
 @package quick_settings_docker
 '''
 
 # Importing the relevant dependencies:
 import sys
 from PyQt5.QtCore import pyqtSlot, Qt, QPointF
 from PyQt5.QtGui import QStandardItem, QStandardItemModel, QPainter, QPalette, QPixmap, QImage, QBrush, QPen, QIcon
 from PyQt5.QtWidgets import QWidget, QTabWidget, QListView, QVBoxLayout
 from krita import *
 
 
 class QuickSettingsDocker(DockWidget):
     # Init the docker
 
     def __init__(self):
-        super().__init__()
+        super(QuickSettingsDocker, self).__init__()
         # make base-widget and layout
         widget = QWidget()
         layout = QVBoxLayout()
         widget.setLayout(layout)
         self.setWindowTitle("Quick Settings Docker")
         tabWidget = QTabWidget()
 
         self.brushSizeTableView = QListView()
         self.brushSizeTableView.setViewMode(QListView.IconMode)
         self.brushSizeTableView.setMovement(QListView.Static)
         self.brushSizeTableView.setResizeMode(QListView.Adjust)
         self.brushSizeTableView.setUniformItemSizes(True)
         self.brushSizeTableView.setSelectionMode(QListView.SingleSelection)
 
         self.brushOpacityTableView = QListView()
         self.brushOpacityTableView.setViewMode(QListView.IconMode)
         self.brushOpacityTableView.setMovement(QListView.Static)
         self.brushOpacityTableView.setResizeMode(QListView.Adjust)
         self.brushOpacityTableView.setUniformItemSizes(True)
         self.brushOpacityTableView.setSelectionMode(QListView.SingleSelection)
 
         self.brushFlowTableView = QListView()
         self.brushFlowTableView.setViewMode(QListView.IconMode)
         self.brushFlowTableView.setMovement(QListView.Static)
         self.brushFlowTableView.setResizeMode(QListView.Adjust)
         self.brushFlowTableView.setUniformItemSizes(True)
         self.brushFlowTableView.setSelectionMode(QListView.SingleSelection)
 
         tabWidget.addTab(self.brushSizeTableView, "Size")
         tabWidget.addTab(self.brushOpacityTableView, "Opacity")
         tabWidget.addTab(self.brushFlowTableView, "Flow")
         layout.addWidget(tabWidget)
         self.setWidget(widget)  # Add the widget to the docker.
 
         # amount of columns in each row for all the tables.
 
         # We want a grid with possible options to select.
         # To do this, we'll make a ListView widget and use a standarditemmodel for the entries.
         # The entries are filled out based on the sizes and opacity lists.
 
         # Sizes and opacity lists. The former is half-way copied from ptsai, the latter is based on personal experience of useful opacities.
         self.sizesList = [0.7, 1.0, 1.5, 2, 2.5, 3, 3.5, 4, 5, 6, 7, 8, 9, 10, 12, 14, 16, 20, 25, 30, 35, 40, 50, 60, 70, 80, 100, 120, 160, 200, 250, 300, 350, 400, 450, 500]
         self.opacityList = [0.1, 0.5, 1, 5, 10, 15, 20, 30, 40, 50, 60, 70, 80, 90, 100]
         self.brushSizeModel = QStandardItemModel()
         self.brushOpacityModel = QStandardItemModel()
         self.brushFlowModel = QStandardItemModel()
         self.fillSizesModel()
         self.fillOpacityModel()
 
         # Now we're done filling out our tables, we connect the views to the functions that'll change the settings.
         self.brushSizeTableView.clicked.connect(self.setBrushSize)
         self.brushOpacityTableView.clicked.connect(self.setBrushOpacity)
         self.brushFlowTableView.clicked.connect(self.setBrushFlow)
 
     def fillSizesModel(self):
         # First we empty the old model. We might wanna use this function in the future to fill it with the brushmask of the selected brush, but there's currently no API for recognising changes in the current brush nor is there a way to get its brushmask.
         self.brushSizeModel.clear()
         for s in range(len(self.sizesList)):
             # we're gonna itterate over our list, and make a new item for each entry.
             # We need to disable a bunch of stuff to make sure people won't do funny things to our entries.
             item = QStandardItem()
             item.setCheckable(False)
             item.setEditable(False)
             item.setDragEnabled(False)
             item.setText(str(self.sizesList[s])+" px")
             # And from here on we'll make an icon.
             brushImage = QPixmap(64, 64)
             img = QImage(64, 64, QImage.Format_RGBA8888)
             circlePainter = QPainter()
             img.fill(Qt.transparent)
             circlePainter.begin(img)
             brush = QBrush(Qt.SolidPattern)
             brush.setColor(self.brushSizeTableView.palette().color(QPalette.Text))
             circlePainter.setBrush(brush)
             circlePainter.setPen(QPen(QBrush(Qt.transparent), 0))
             brushSize = max(min(self.sizesList[s], 64), 1)
             brushSize = brushSize * 0.5
             circlePainter.drawEllipse(QPointF(32, 32), brushSize, brushSize)
             circlePainter.end()
             brushImage = QPixmap.fromImage(img)
             # now we're done with drawing the icon, so we set it on the item.
             item.setIcon(QIcon(brushImage))
             self.brushSizeModel.appendRow(item)
         self.brushSizeTableView.setModel(self.brushSizeModel)
 
     def fillOpacityModel(self):
         self.brushOpacityModel.clear()
         self.brushFlowModel.clear()
         for s in range(len(self.opacityList)):
             # we're gonna itterate over our list, and make a new item for each entry.
             item = QStandardItem()
             item.setCheckable(False)
             item.setEditable(False)
             item.setDragEnabled(False)
             item.setText(str(self.opacityList[s])+" %")
             brushImage = QPixmap(64, 64)
             img = QImage(64, 64, QImage.Format_RGBA8888)
             circlePainter = QPainter()
             img.fill(Qt.transparent)
             circlePainter.begin(img)
             brush = QBrush(Qt.SolidPattern)
             brush.setColor(self.brushSizeTableView.palette().color(QPalette.Text))
             circlePainter.setBrush(brush)
             circlePainter.setPen(QPen(QBrush(Qt.transparent), 0))
-            circlePainter.setOpacity(self.opacityList[s] / 100)
+            circlePainter.setOpacity(float(self.opacityList[s]) / 100.0)
             circlePainter.drawEllipse(QPointF(32, 32), 32, 32)
             circlePainter.end()
             brushImage = QPixmap.fromImage(img)
             item.setIcon(QIcon(brushImage))
             # the flow and opacity models will use virtually the same items, but Qt would like us to make sure we understand
             # these are not really the same items, so hence the clone.
             itemFlow = item.clone()
             self.brushOpacityModel.appendRow(item)
             self.brushFlowModel.appendRow(itemFlow)
         self.brushOpacityTableView.setModel(self.brushOpacityModel)
         self.brushFlowTableView.setModel(self.brushFlowModel)
 
     def canvasChanged(self, canvas):
         pass
 
     @pyqtSlot('QModelIndex')
     def setBrushSize(self, index):
         i = index.row()
         brushSize = self.sizesList[i]
         if Application.activeWindow() and len(Application.activeWindow().views()) > 0:
             Application.activeWindow().views()[0].setBrushSize(brushSize)
 
     @pyqtSlot('QModelIndex')
     def setBrushOpacity(self, index):
         i = index.row()
-        brushOpacity = self.opacityList[i] / 100
+        brushOpacity = float(self.opacityList[i]) / 100.0
         if Application.activeWindow() and len(Application.activeWindow().views()) > 0:
             Application.activeWindow().views()[0].setPaintingOpacity(brushOpacity)
 
     @pyqtSlot('QModelIndex')
     def setBrushFlow(self, index):
         i = index.row()
-        brushOpacity = self.opacityList[i] / 100
+        brushOpacity = float(self.opacityList[i]) / 100.0
         if Application.activeWindow() and len(Application.activeWindow().views()) > 0:
             Application.activeWindow().views()[0].setPaintingFlow(brushOpacity)
 
 
 # Add docker to the application :)
 Application.addDockWidgetFactory(DockWidgetFactory("quick_settings_docker", DockWidgetFactoryBase.DockRight, QuickSettingsDocker))
diff --git a/plugins/python/scripter/debugcontroller.py b/plugins/python/scripter/debugcontroller.py
index b53a804be7..b497d7aa1d 100644
--- a/plugins/python/scripter/debugcontroller.py
+++ b/plugins/python/scripter/debugcontroller.py
@@ -1,99 +1,104 @@
 """
 Copyright (c) 2017 Eliakin Costa <eliakim170@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU 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 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.
 """
-from scripter.debugger_scripter import debugger
-import asyncio
+from .debugger_scripter import debugger
+import sys
+if sys.version_info[0] > 2:
+    import asyncio
+else:
+    # trollius is a port of asyncio for python2.
+    import trollius as asyncio
 
 
 class DebugController (object):
 
     def __init__(self, scripter):
         self._debugger = None
         self._cmd = None
         self.scripter = scripter
 
     def start(self, document):
         self.setCmd(compile(document.data, document.filePath, "exec"))
         self._debugger = debugger.Debugger(self.scripter, self._cmd)
         self._debugger.debugprocess.start()
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._debugger.start())
         self.updateUIDebugger()
 
     def step(self):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._debugger.step())
         self.scripter.uicontroller.setStepped(True)
         self.updateUIDebugger()
 
     def stop(self):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._debugger.stop())
         self.updateUIDebugger()
         self._debugger = None
 
     def setCmd(self, cmd):
         self._cmd = cmd
 
     @property
     def isActive(self):
         try:
             if self._debugger:
                 return self._debugger.debugprocess.is_alive()
             return False
         except Exception:
             return False
 
     @property
     def currentLine(self):
         try:
             if self._debugger:
                 return int(self.debuggerData['code']['lineNumber'])
         except Exception:
             return 0
 
     def updateUIDebugger(self):
         widget = self.scripter.uicontroller.findTabWidget('Debugger')
         exception = self._debuggerException()
 
         if exception:
             self.scripter.uicontroller.showException(exception)
         if not self.isActive or self._quitDebugger():
             widget.disableToolbar(True)
 
         self.scripter.uicontroller.repaintDebugArea()
         widget.updateWidget()
 
     @property
     def debuggerData(self):
         try:
             if self._debugger:
                 return self._debugger.application_data
         except Exception:
             return
 
     def _quitDebugger(self):
         try:
             return self.debuggerData['quit']
         except Exception:
             return False
 
     def _debuggerException(self):
         try:
             return self.debuggerData['exception']
         except Exception:
             return False
diff --git a/plugins/python/scripter/debugger_scripter/debugger.py b/plugins/python/scripter/debugger_scripter/debugger.py
index 85d192ae28..2ccdde60dc 100644
--- a/plugins/python/scripter/debugger_scripter/debugger.py
+++ b/plugins/python/scripter/debugger_scripter/debugger.py
@@ -1,120 +1,126 @@
 """
 Copyright (c) 2017 Eliakin Costa <eliakim170@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU 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 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.
 """
 import bdb
 import multiprocessing
-import asyncio
+import sys
+if sys.version_info[0] > 2:
+    import asyncio
+else:
+    import trollius as asyncio
 from . import debuggerformatter
 
 
 class Debugger(bdb.Bdb):
 
     def __init__(self, scripter, cmd):
         bdb.Bdb.__init__(self)
 
         self.quit = False
         self.debugq = multiprocessing.Queue()
         self.scripter = scripter
         self.applicationq = multiprocessing.Queue()
         self.filePath = self.scripter.documentcontroller.activeDocument.filePath
         self.application_data = {}
         self.exception_data = {}
         self.debugprocess = multiprocessing.Process(target=self._run, args=(self.filePath,))
         self.currentLine = 0
 
         bdb.Bdb.reset(self)
 
     def _run(self, filename):
         try:
             self.mainpyfile = self.canonic(filename)
             with open(filename, "rb") as fp:
                 statement = "exec(compile(%r, %r, 'exec'))" % \
                             (fp.read(), self.mainpyfile)
             self.run(statement)
         except Exception as e:
             raise e
 
     def user_call(self, frame, args):
         name = frame.f_code.co_name or "<unknown>"
 
     def user_line(self, frame):
         """Handler that executes with every line of code"""
         co = frame.f_code
 
         if self.filePath != co.co_filename:
             return
 
         self.currentLine = frame.f_lineno
         self.applicationq.put({"code": {"file": co.co_filename,
                                         "name": co.co_name,
                                         "lineNumber": str(frame.f_lineno)
                                         },
                                "frame": {"firstLineNumber": co.co_firstlineno,
                                          "locals": debuggerformatter.format_data(frame.f_locals),
                                          "globals": debuggerformatter.format_data(frame.f_globals)
                                          },
                                "trace": "line"
                                })
 
         if self.quit:
             return self.set_quit()
         if self.currentLine == 0:
             return
         else:
             cmd = self.debugq.get()
 
             if cmd == "step":
                 return
             if cmd == "stop":
                 return self.set_quit()
 
     def user_return(self, frame, value):
         name = frame.f_code.co_name or "<unknown>"
 
         if name == '<module>':
             self.applicationq.put({"quit": True})
 
     def user_exception(self, frame, exception):
         self.applicationq.put({"exception": str(exception[1])})
 
     @asyncio.coroutine
     def display(self):
         """Coroutine for updating the UI"""
 
         while True:
             if self.applicationq.empty():
-                yield from asyncio.sleep(0.3)
+                # 'yield from' is not available in Python 2.
+                for i in asyncio.sleep(0.3):
+                    yield i
             else:
                 while not self.applicationq.empty():
                     self.application_data.update(self.applicationq.get())
                     self.scripter.uicontroller.repaintDebugArea()
                     return
 
     @asyncio.coroutine
     def start(self):
-        yield from self.display()
+        yield self.display()
 
     @asyncio.coroutine
     def step(self):
         self.debugq.put("step")
-        yield from self.display()
+        yield self.display()
 
     @asyncio.coroutine
     def stop(self):
         self.debugq.put("stop")
         self.applicationq.put({"quit": True})
-        yield from self.display()
+        yield self.display()
diff --git a/plugins/python/scripter/documentcontroller.py b/plugins/python/scripter/documentcontroller.py
index 6d5f14ae9f..85f7667de6 100644
--- a/plugins/python/scripter/documentcontroller.py
+++ b/plugins/python/scripter/documentcontroller.py
@@ -1,57 +1,57 @@
 """
 Copyright (c) 2017 Eliakin Costa <eliakim170@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU 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 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.
 """
-from scripter.document_scripter import document
+from .document_scripter import document
 
 
 class DocumentController(object):
 
     def __init__(self):
         self._activeDocument = None
 
     @property
     def activeDocument(self):
         return self._activeDocument
 
     def openDocument(self, filePath):
         if filePath:
             newDocument = document.Document(filePath)
             newDocument.open()
             self._activeDocument = newDocument
             return newDocument
 
     def saveDocument(self, data, filePath, save_as=False):
         """
         data - data to be written
         filePath - file path to write data to
         save_as = boolean, is this call made from save_as functionality. If so, do not compare data
         against existing document before save.
         """
 
         if save_as or not self._activeDocument:
             self._activeDocument = document.Document(filePath)
 
         text = str(data)
         if save_as or not self._activeDocument.compare(text):
             # compare is not evaluated if save_as is True
             self._activeDocument.data = text
             self._activeDocument.save()
 
         return self._activeDocument
 
     def clearActiveDocument(self):
         self._activeDocument = None
diff --git a/plugins/python/scripter/kritapykrita_scripter.desktop b/plugins/python/scripter/kritapykrita_scripter.desktop
index 89cced7c58..20e5931dfe 100644
--- a/plugins/python/scripter/kritapykrita_scripter.desktop
+++ b/plugins/python/scripter/kritapykrita_scripter.desktop
@@ -1,39 +1,39 @@
 [Desktop Entry]
 Type=Service
 ServiceTypes=Krita/PythonPlugin
 X-KDE-Library=scripter
-X-Python-2-Compatible=false
+X-Python-2-Compatible=true
 X-Krita-Manual=Manual.html
 Name=Scripter
 Name[ca]=Scripter
 Name[ca@valencia]=Scripter
 Name[de]=Scripter
 Name[en_GB]=Scripter
 Name[es]=Guionador
 Name[gl]=Executor de scripts
 Name[it]=Scripter
 Name[nl]=Scriptmaker
 Name[pl]=Skrypter
 Name[pt]=Programador
 Name[sv]=Skriptgenerator
 Name[tr]=Betik yazarı
 Name[uk]=Скриптер
 Name[x-test]=xxScripterxx
 Name[zh_CN]=脚本编写者
 Name[zh_TW]=腳本編寫者
 Comment=Plugin to execute ad-hoc Python code
 Comment[ca]=Connector per executar codi Python ad hoc
 Comment[ca@valencia]=Connector per executar codi Python ad hoc
 Comment[en_GB]=Plugin to execute ad-hoc Python code
 Comment[es]=Complemento para ejecutar código Python a medida
 Comment[gl]=Complemento para executar código de Python escrito no momento.
 Comment[it]=Estensione per eseguire ad-hoc codice Python
 Comment[nl]=Plug-in om ad-hoc Python code uit te voeren
 Comment[pl]=Wtyczka do wykonywania kodu Pythona ad-hoc
 Comment[pt]='Plugin' para executar código em Python arbitrário
 Comment[sv]=Insticksprogram för att köra godtycklig Python-kod
 Comment[tr]=Geçici Python kodu çalıştırmak için eklenti
 Comment[uk]=Додаток для виконання апріорного коду Python
 Comment[x-test]=xxPlugin to execute ad-hoc Python codexx
 Comment[zh_CN]=执行特定 Python 代码的插件
 Comment[zh_TW]=外掛程式，用於執行特定 Python 程式碼
diff --git a/plugins/python/scripter/scripter.py b/plugins/python/scripter/scripter.py
index 2653fe788e..35b63d1bd9 100644
--- a/plugins/python/scripter/scripter.py
+++ b/plugins/python/scripter/scripter.py
@@ -1,45 +1,44 @@
 """
 Copyright (c) 2017 Eliakin Costa <eliakim170@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU 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 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.
 """
-from PyQt5.QtWidgets import QDialog
 from PyQt5.QtCore import QSettings, QStandardPaths
-from krita import *
-from scripter import uicontroller, documentcontroller, debugcontroller
+from krita import Krita, Extension
+from . import uicontroller, documentcontroller, debugcontroller
 
 
 class ScripterExtension(Extension):
 
     def __init__(self, parent):
-        super().__init__(parent)
+        super(ScripterExtension, self).__init__(parent)
 
     def setup(self):
         pass
-    
+
     def createActions(self, window):
         action = window.createAction("python_scripter", "Scripter")
         action.triggered.connect(self.initialize)
 
     def initialize(self):
         configPath = QStandardPaths.writableLocation(QStandardPaths.GenericConfigLocation)
         self.settings = QSettings(configPath + '/krita-scripterrc', QSettings.IniFormat)
         self.uicontroller = uicontroller.UIController()
         self.documentcontroller = documentcontroller.DocumentController()
         self.debugcontroller = debugcontroller.DebugController(self)
         self.uicontroller.initialize(self)
 
 
 Krita.instance().addExtension(ScripterExtension(Krita.instance()))
diff --git a/plugins/python/scripter/ui_scripter/actions/closeaction/closeaction.py b/plugins/python/scripter/ui_scripter/actions/closeaction/closeaction.py
index 65b9e07788..064a889f53 100644
--- a/plugins/python/scripter/ui_scripter/actions/closeaction/closeaction.py
+++ b/plugins/python/scripter/ui_scripter/actions/closeaction/closeaction.py
@@ -1,54 +1,54 @@
 """
 Copyright (c) 2017 Eliakin Costa <eliakim170@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU 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 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.
 """
 from PyQt5.QtWidgets import QAction, QMessageBox
 from PyQt5.QtGui import QKeySequence
 from PyQt5.QtCore import Qt
 
 
 class CloseAction(QAction):
 
     def __init__(self, scripter, parent=None):
         super(CloseAction, self).__init__(parent)
         self.scripter = scripter
 
         self.triggered.connect(self.close)
 
         self.setText('Close')
         self.setObjectName('close')
         self.setShortcut(QKeySequence(Qt.CTRL + Qt.Key_Q))
 
     @property
     def parent(self):
         return 'File'
 
     def close(self):
         msgBox = QMessageBox(self.scripter.uicontroller.mainWidget)
 
         msgBox.setInformativeText("Do you want to save the current document?")
         msgBox.setStandardButtons(QMessageBox.Save | QMessageBox.Discard | QMessageBox.Cancel)
         msgBox.setDefaultButton(QMessageBox.Save)
 
-        ret = msgBox.exec()
+        ret = msgBox.exec_()
 
         if ret == QMessageBox.Cancel:
             return
         if ret == QMessageBox.Save:
             if not self.scripter.uicontroller.invokeAction('save'):
                 return
 
         self.scripter.uicontroller.closeScripter()
diff --git a/plugins/python/scripter/ui_scripter/actions/newaction/newaction.py b/plugins/python/scripter/ui_scripter/actions/newaction/newaction.py
index df7749bf5b..e5761f2b7e 100644
--- a/plugins/python/scripter/ui_scripter/actions/newaction/newaction.py
+++ b/plugins/python/scripter/ui_scripter/actions/newaction/newaction.py
@@ -1,56 +1,56 @@
 """
 Copyright (c) 2017 Eliakin Costa <eliakim170@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU 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 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.
 """
 from PyQt5.QtWidgets import QAction, QMessageBox
 from PyQt5.QtGui import QKeySequence
 from PyQt5.QtCore import Qt
 
 
 class NewAction(QAction):
 
     def __init__(self, scripter, parent=None):
         super(NewAction, self).__init__(parent)
         self.scripter = scripter
 
         self.triggered.connect(self.new)
 
         self.setText('New')
         self.setObjectName('new')
         self.setShortcut(QKeySequence(Qt.CTRL + Qt.Key_N))
 
     @property
     def parent(self):
         return 'File'
 
     def new(self):
         msgBox = QMessageBox(self.scripter.uicontroller.mainWidget)
 
         msgBox.setText("The document has been modified.")
         msgBox.setInformativeText("Do you want to save your changes?")
         msgBox.setStandardButtons(QMessageBox.Save | QMessageBox.Discard | QMessageBox.Cancel)
         msgBox.setDefaultButton(QMessageBox.Save)
 
-        ret = msgBox.exec()
+        ret = msgBox.exec_()
 
         if ret == QMessageBox.Cancel:
             return
         if ret == QMessageBox.Save:
             self.scripter.uicontroller.invokeAction('save')
 
         self.scripter.documentcontroller.clearActiveDocument()
         self.scripter.uicontroller.setStatusBar()
         self.scripter.uicontroller.clearEditor()
diff --git a/plugins/python/scripter/ui_scripter/actions/openaction/openaction.py b/plugins/python/scripter/ui_scripter/actions/openaction/openaction.py
index 5baa4a6d14..209b371185 100644
--- a/plugins/python/scripter/ui_scripter/actions/openaction/openaction.py
+++ b/plugins/python/scripter/ui_scripter/actions/openaction/openaction.py
@@ -1,56 +1,57 @@
 """
 Copyright (c) 2017 Eliakin Costa <eliakim170@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU 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 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.
 """
 from PyQt5.QtWidgets import QAction, QFileDialog, QMessageBox
 from PyQt5.QtGui import QKeySequence
 from PyQt5.QtCore import Qt
 
+import os
+
 
 class OpenAction(QAction):
 
     def __init__(self, scripter, parent=None):
         super(OpenAction, self).__init__(parent)
         self.scripter = scripter
 
         self.triggered.connect(self.open)
 
         self.setText('Open')
         self.setObjectName('open')
         self.setShortcut(QKeySequence(Qt.CTRL + Qt.Key_O))
 
     @property
     def parent(self):
         return 'File'
 
     def open(self):
         dialog = QFileDialog(self.scripter.uicontroller.mainWidget)
         dialog.setNameFilter('Python files (*.py)')
 
-        if dialog.exec():
+        if dialog.exec_():
             try:
                 selectedFile = dialog.selectedFiles()[0]
-                fileExtension = selectedFile.rsplit('.', maxsplit=1)[1]
+                _, fileExtension = os.path.splitext(selectedFile)
 
-                if fileExtension == 'py':
+                if fileExtension == '.py':
                     document = self.scripter.documentcontroller.openDocument(selectedFile)
                     self.scripter.uicontroller.setDocumentEditor(document)
                     self.scripter.uicontroller.setStatusBar(document.filePath)
-                    print("open is run")
             except Exception:
                 QMessageBox.information(self.scripter.uicontroller.mainWidget,
                                         'Invalid File',
                                         'Open files with .py extension')
diff --git a/plugins/python/scripter/ui_scripter/actions/reloadaction/reloadaction.py b/plugins/python/scripter/ui_scripter/actions/reloadaction/reloadaction.py
index 6b3a57cc2b..7b6ebbb0e3 100644
--- a/plugins/python/scripter/ui_scripter/actions/reloadaction/reloadaction.py
+++ b/plugins/python/scripter/ui_scripter/actions/reloadaction/reloadaction.py
@@ -1,46 +1,62 @@
-from PyQt5.QtWidgets import QAction, QFileDialog, QMessageBox
+"""
+Copyright (c) 2017 Eliakin Costa <eliakim170@gmail.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU 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 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.
+"""
+from PyQt5.QtWidgets import QAction, QMessageBox
 from PyQt5.QtGui import QKeySequence
 from PyQt5.QtCore import Qt
 
 
 class ReloadAction(QAction):
 
     def __init__(self, scripter, parent=None):
         super(ReloadAction, self).__init__(parent)
         self.scripter = scripter
         self.editor = self.scripter.uicontroller.editor
 
         self.triggered.connect(self.reloadFile)
 
         self.setText('Reload File')
         self.setObjectName('reloadfile')
         self.setShortcut(QKeySequence(Qt.ALT + Qt.Key_R))
 
     @property
     def parent(self):
         return 'File'
 
     def reloadFile(self):
         # get the currently open document's path
         curr_doc_fpath = ''
         document = self.scripter.documentcontroller._activeDocument
         if document is None:
             QMessageBox.critical(self.scripter.uicontroller.mainWidget,
                                  'No existing document',
                                  'Please specify a document by opening it before reloading')
             return
         else:
             curr_doc_fpath = document.filePath
 
         # clear the editor
         self.scripter.documentcontroller.clearActiveDocument()
         self.scripter.uicontroller.setStatusBar()
         self.scripter.uicontroller.clearEditor()
 
         # reload the document
         document = self.scripter.documentcontroller.openDocument(curr_doc_fpath)
         self.scripter.uicontroller.setDocumentEditor(document)
         self.scripter.uicontroller.setStatusBar(document.filePath)
-        print("reload is run")
 
         return document
diff --git a/plugins/python/scripter/ui_scripter/actions/runaction/docwrapper.py b/plugins/python/scripter/ui_scripter/actions/runaction/docwrapper.py
index 4709bcab79..a5519fbbb1 100644
--- a/plugins/python/scripter/ui_scripter/actions/runaction/docwrapper.py
+++ b/plugins/python/scripter/ui_scripter/actions/runaction/docwrapper.py
@@ -1,30 +1,30 @@
 """
 Copyright (c) 2017 Eliakin Costa <eliakim170@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU 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 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.
 """
 from PyQt5.QtGui import QTextCursor
 
 
-class DocWrapper:
+class DocWrapper(object):
 
     def __init__(self, textdocument):
         self.textdocument = textdocument
 
     def write(self, text, view=None):
         cursor = QTextCursor(self.textdocument)
         cursor.clearSelection()
         cursor.movePosition(QTextCursor.End)
         cursor.insertText(text)
diff --git a/plugins/python/scripter/ui_scripter/actions/runaction/runaction.py b/plugins/python/scripter/ui_scripter/actions/runaction/runaction.py
index b607d5a403..66f2d909d1 100644
--- a/plugins/python/scripter/ui_scripter/actions/runaction/runaction.py
+++ b/plugins/python/scripter/ui_scripter/actions/runaction/runaction.py
@@ -1,132 +1,155 @@
 """
 Copyright (c) 2017 Eliakin Costa <eliakim170@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU 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 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.
 """
 from PyQt5.QtWidgets import QAction
 from PyQt5.QtGui import QIcon, QKeySequence
 from PyQt5.QtCore import Qt
 import sys
-from . import docwrapper
-import importlib
-from importlib.machinery import SourceFileLoader
 import traceback
+import inspect
+from . import docwrapper
 
+if sys.version_info[0] > 2:
+    import importlib
+    from importlib.machinery import SourceFileLoader
+else:
+    import imp
 
+PYTHON27 = sys.version_info.major == 2 and sys.version_info.minor == 7
 PYTHON33 = sys.version_info.major == 3 and sys.version_info.minor == 3
 PYTHON34 = sys.version_info.major == 3 and sys.version_info.minor == 4
 EXEC_NAMESPACE = "__main__"  # namespace that user scripts will run in
 
 
 class RunAction(QAction):
 
     def __init__(self, scripter, parent=None):
         super(RunAction, self).__init__(parent)
         self.scripter = scripter
 
         self.editor = self.scripter.uicontroller.editor
         self.output = self.scripter.uicontroller.findTabWidget('OutPut', 'OutPutTextEdit')
 
         self.triggered.connect(self.run)
 
         self.setText('Run')
         self.setToolTip('Run Ctrl+R')
         self.setIcon(QIcon(':/icons/run.svg'))
         self.setShortcut(QKeySequence(Qt.CTRL + Qt.Key_R))
 
     @property
     def parent(self):
         return 'toolBar'
 
     def run(self):
         """ This method execute python code from an activeDocument (file) or direct
             from editor (ui_scripter/editor/pythoneditor.py). When executing code
             from a file, we use importlib to load this module/file and with
             "users_script" name. That's implementation seeks for a "main()" function in the script.
             When executing code from editor without creating a file, we compile
             this script to bytecode and we execute this in an empty scope. That's
             faster than use exec directly and cleaner, because we are using an empty scope. """
 
         self.scripter.uicontroller.setActiveWidget('OutPut')
         stdout = sys.stdout
         stderr = sys.stderr
         output = docwrapper.DocWrapper(self.output.document())
         if (self.editor._documentModified is True):
             output.write("==== Warning: Script not saved! ====\n")
         else:
             output.write("======================================\n")
         sys.stdout = output
         sys.stderr = output
 
         script = self.editor.document().toPlainText()
         document = self.scripter.documentcontroller.activeDocument
 
         try:
             if document and self.editor._documentModified is False:
-                spec = importlib.util.spec_from_file_location(EXEC_NAMESPACE, document.filePath)
-                try:
-                    users_module = importlib.util.module_from_spec(spec)
-                    spec.loader.exec_module(users_module)
-
-                except AttributeError as e:  # no module from spec
-                    if PYTHON34 or PYTHON33:
-                        loader = SourceFileLoader(EXEC_NAMESPACE, document.filePath)
-                        users_module = loader.load_module()
-                    else:
-                        raise e
-
-                try:
-                    # maybe script is to be execed, maybe main needs to be invoked
-                    # if there is a main() then execute it, otherwise don't worry...
+                if PYTHON27:
+                    users_module = self.run_py2_document(document)
+                else:
+                    users_module = self.run_py3_document(document)
+
+                # maybe script is to be execed, maybe main needs to be invoked
+                # if there is a main() then execute it, otherwise don't worry...
+                if hasattr(users_module, "main") and inspect.isfunction(users_module.main):
                     users_module.main()
-                except AttributeError:
-                    pass
-
             else:
                 code = compile(script, '<string>', 'exec')
                 globals_dict = {"__name__": EXEC_NAMESPACE}
                 exec(code, globals_dict)
 
-        except Exception as e:
-            """Provide context (line number and text) for an error that is caught.
-            Ordinarily, syntax and Indent errors are caught during initial
-            compilation in exec(), and the traceback traces back to this file.
-            So these need to be treated separately.
-            Other errors trace back to the file/script being run.
-            """
+        except Exception:
+            # Provide context (line number and text) for an error that is caught.
+            # Ordinarily, syntax and Indent errors are caught during initial
+            # compilation in exec(), and the traceback traces back to this file.
+            # So these need to be treated separately.
+            # Other errors trace back to the file/script being run.
             type_, value_, traceback_ = sys.exc_info()
             if type_ == SyntaxError:
                 errorMessage = "%s\n%s" % (value_.text.rstrip(), " " * (value_.offset - 1) + "^")
                 # rstrip to remove trailing \n, output needs to be fixed width font for the ^ to align correctly
                 errorText = "Syntax Error on line %s" % value_.lineno
             elif type_ == IndentationError:
                 # (no offset is provided for an IndentationError
                 errorMessage = value_.text.rstrip()
                 errorText = "Unexpected Indent on line %s" % value_.lineno
             else:
                 errorText = traceback.format_exception_only(type_, value_)[0]
                 format_string = "In file: {0}\nIn function: {2} at line: {1}. Line with error:\n{3}"
                 tbList = traceback.extract_tb(traceback_)
                 tb = tbList[-1]
                 errorMessage = format_string.format(*tb)
             m = "\n**********************\n%s\n%s\n**********************\n" % (errorText, errorMessage)
             output.write(m)
 
         sys.stdout = stdout
         sys.stderr = stderr
 
         # scroll to bottom of output
         bottom = self.output.verticalScrollBar().maximum()
         self.output.verticalScrollBar().setValue(bottom)
+
+    def run_py2_document(self, document):
+        """ Loads and executes an external script using Python 2 specific operations
+        and returns the loaded module for further execution if needed.
+        """
+        try:
+            user_module = imp.load_source(EXEC_NAMESPACE, document.filePath)
+        except Exception as e:
+            raise e
+
+        return user_module
+
+    def run_py3_document(self, document):
+        """ Loads and executes an external script using Python 3 specific operations
+        and returns the loaded module for further execution if needed.
+        """
+        spec = importlib.util.spec_from_file_location(EXEC_NAMESPACE, document.filePath)
+        try:
+            users_module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(users_module)
+
+        except AttributeError as e:  # no module from spec
+            if PYTHON34 or PYTHON33:
+                loader = SourceFileLoader(EXEC_NAMESPACE, document.filePath)
+                users_module = loader.load_module()
+            else:
+                raise e
+
+        return users_module
diff --git a/plugins/python/scripter/ui_scripter/actions/settingsaction/settingsaction.py b/plugins/python/scripter/ui_scripter/actions/settingsaction/settingsaction.py
index b335a6e7b1..34f0f88b96 100644
--- a/plugins/python/scripter/ui_scripter/actions/settingsaction/settingsaction.py
+++ b/plugins/python/scripter/ui_scripter/actions/settingsaction/settingsaction.py
@@ -1,49 +1,49 @@
 """
 Copyright (c) 2017 Eliakin Costa <eliakim170@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU 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 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.
 """
 from PyQt5.QtWidgets import QAction
 from PyQt5.QtCore import Qt
 from . import settingsdialog
 
 
 class SettingsAction(QAction):
 
     def __init__(self, scripter, parent=None):
         super(SettingsAction, self).__init__(parent)
         self.scripter = scripter
 
         self.triggered.connect(self.openSettings)
 
         self.settingsDialog = settingsdialog.SettingsDialog(self.scripter)
         self.settingsDialog.setWindowModality(Qt.WindowModal)
         self.settingsDialog.setFixedSize(400, 250)
 
         self.setText('Settings')
 
     @property
     def parent(self):
         return 'File'
 
     def openSettings(self):
         self.settingsDialog.show()
-        self.settingsDialog.exec()
+        self.settingsDialog.exec_()
 
     def readSettings(self):
         self.settingsDialog.readSettings(self.scripter.settings)
 
     def writeSettings(self):
         self.settingsDialog.writeSettings(self.scripter.settings)
diff --git a/plugins/python/scripter/uicontroller.py b/plugins/python/scripter/uicontroller.py
index 27e18f3dd7..e02cabb330 100644
--- a/plugins/python/scripter/uicontroller.py
+++ b/plugins/python/scripter/uicontroller.py
@@ -1,262 +1,264 @@
 """
 Copyright (c) 2017 Eliakin Costa <eliakim170@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU 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 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.
 """
-from PyQt5.QtGui import QTextCursor, QPalette, QFontInfo
+from PyQt5.QtCore import Qt, QObject, QFileInfo, QRect
+from PyQt5.QtGui import QTextCursor, QPalette
 from PyQt5.QtWidgets import (QToolBar, QMenuBar, QTabWidget,
                              QLabel, QVBoxLayout, QMessageBox,
                              QSplitter, QSizePolicy)
-from PyQt5.QtCore import Qt, QObject, QFileInfo, pyqtSlot, QRect
-from scripter.ui_scripter.syntax import syntax, syntaxstyles
-from scripter.ui_scripter.editor import pythoneditor
-from scripter import scripterdialog
+from .ui_scripter.syntax import syntax, syntaxstyles
+from .ui_scripter.editor import pythoneditor
+from . import scripterdialog
 import importlib
 
 KEY_GEOMETRY = "geometry"
 DEFAULT_GEOMETRY = QRect(600, 200, 400, 500)
 # essentially randomly placed
 
 
 class Elided_Text_Label(QLabel):
     mainText = str()
 
     def __init__(self, parent=None):
         super(QLabel, self).__init__(parent)
         self.setMinimumWidth(self.fontMetrics().width("..."))
         self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
 
     def setMainText(self, text=str()):
         self.mainText = text
         self.elideText()
 
     def elideText(self):
         self.setText(self.fontMetrics().elidedText(self.mainText, Qt.ElideRight, self.width()))
 
     def resizeEvent(self, event):
         self.elideText()
 
 
 class UIController(object):
     documentModifiedText = ""
     documentStatusBarText = "untitled"
 
     def __init__(self):
         self.mainWidget = scripterdialog.ScripterDialog(self)
         self.actionToolbar = QToolBar('toolBar', self.mainWidget)
         self.menu_bar = QMenuBar(self.mainWidget)
 
         self.actionToolbar.setObjectName('toolBar')
         self.menu_bar.setObjectName('menuBar')
 
         self.actions = []
 
         self.mainWidget.setWindowModality(Qt.NonModal)
 
     def initialize(self, scripter):
         self.editor = pythoneditor.CodeEditor(scripter)
         self.tabWidget = QTabWidget()
         self.statusBar = Elided_Text_Label()
         self.statusBar.setMainText('untitled')
         self.splitter = QSplitter()
         self.splitter.setOrientation(Qt.Vertical)
         self.highlight = syntax.PythonHighlighter(self.editor.document(), syntaxstyles.DefaultSyntaxStyle())
         p = self.editor.palette()
         p.setColor(QPalette.Base, syntaxstyles.DefaultSyntaxStyle()['background'].foreground().color())
         p.setColor(QPalette.Text, syntaxstyles.DefaultSyntaxStyle()['foreground'].foreground().color())
         self.editor.setPalette(p)
 
         self.scripter = scripter
 
         self.loadMenus()
         self.loadWidgets()
         self.loadActions()
         self._readSettings()  # sets window size
 
         vbox = QVBoxLayout(self.mainWidget)
         vbox.addWidget(self.menu_bar)
         vbox.addWidget(self.actionToolbar)
         self.splitter.addWidget(self.editor)
         self.splitter.addWidget(self.tabWidget)
         vbox.addWidget(self.splitter)
         vbox.addWidget(self.statusBar)
 
         self.mainWidget.setWindowTitle("Scripter")
         self.mainWidget.setSizeGripEnabled(True)
         self.mainWidget.show()
         self.mainWidget.activateWindow()
 
         self.editor.undoAvailable.connect(self.setStatusModified)
 
     def loadMenus(self):
         self.addMenu('File', 'File')
 
     def addMenu(self, menuName, parentName):
         parent = self.menu_bar.findChild(QObject, parentName)
         self.newMenu = None
 
         if parent:
             self.newMenu = parent.addMenu(menuName)
         else:
             self.newMenu = self.menu_bar.addMenu(menuName)
 
         self.newMenu.setObjectName(menuName)
 
         return self.newMenu
 
     def loadActions(self):
         module_path = 'scripter.ui_scripter.actions'
         actions_module = importlib.import_module(module_path)
         modules = []
 
         for class_path in actions_module.action_classes:
-            _module, _klass = class_path.rsplit('.', maxsplit=1)
+            _module = class_path[:class_path.rfind(".")]
+            _klass = class_path[class_path.rfind(".") + 1:]
             modules.append(dict(module='{0}.{1}'.format(module_path, _module),
                                 klass=_klass))
 
         for module in modules:
             m = importlib.import_module(module['module'])
             action_class = getattr(m, module['klass'])
             obj = action_class(self.scripter)
             parent = self.mainWidget.findChild(QObject, obj.parent)
             self.actions.append(dict(action=obj, parent=parent))
 
         for action in self.actions:
             action['parent'].addAction(action['action'])
 
     def loadWidgets(self):
         modulePath = 'scripter.ui_scripter.tabwidgets'
         widgetsModule = importlib.import_module(modulePath)
         modules = []
 
-        for classPath in widgetsModule.widgetClasses:
-            _module, _klass = classPath.rsplit('.', maxsplit=1)
+        for class_path in widgetsModule.widgetClasses:
+            _module = class_path[:class_path.rfind(".")]
+            _klass = class_path[class_path.rfind(".") + 1:]
             modules.append(dict(module='{0}.{1}'.format(modulePath, _module),
                                 klass=_klass))
 
         for module in modules:
             m = importlib.import_module(module['module'])
             widgetClass = getattr(m, module['klass'])
             obj = widgetClass(self.scripter)
             self.tabWidget.addTab(obj, obj.objectName())
 
     def invokeAction(self, actionName):
         for action in self.actions:
             if action['action'].objectName() == actionName:
                 method = getattr(action['action'], actionName)
                 if method:
                     return method()
 
     def findTabWidget(self, widgetName, childName=''):
         for index in range(self.tabWidget.count()):
             widget = self.tabWidget.widget(index)
             if widget.objectName() == widgetName:
                 if childName:
                     widget = widget.findChild(QObject, childName)
                 return widget
 
     def showException(self, exception):
         QMessageBox.critical(self.editor, "Error running script", str(exception))
 
     def setDocumentEditor(self, document):
         self.editor.clear()
         self.editor.moveCursor(QTextCursor.Start)
         self.editor._documentModified = False
         self.editor.setPlainText(document.data)
         self.editor.moveCursor(QTextCursor.End)
 
     def setStatusBar(self, value='untitled'):
         self.documentStatusBarText = value
         self.statusBar.setMainText(self.documentStatusBarText + self.documentModifiedText)
 
     def setStatusModified(self):
         self.documentModifiedText = ""
         if (self.editor._documentModified is True):
             self.documentModifiedText = " [Modified]"
         self.statusBar.setMainText(self.documentStatusBarText + self.documentModifiedText)
 
     def setActiveWidget(self, widgetName):
         widget = self.findTabWidget(widgetName)
 
         if widget:
             self.tabWidget.setCurrentWidget(widget)
 
     def setStepped(self, status):
         self.editor.setStepped(status)
 
     def clearEditor(self):
         self.editor.clear()
 
     def repaintDebugArea(self):
         self.editor.repaintDebugArea()
 
     def closeScripter(self):
         self.mainWidget.close()
 
     def _writeSettings(self):
         """ _writeSettings is a method invoked when the scripter starts, making
             control inversion. Actions can implement a writeSettings method to
             save your own settings without this method to know about it. """
 
         self.scripter.settings.beginGroup('scripter')
 
         document = self.scripter.documentcontroller.activeDocument
         if document:
             self.scripter.settings.setValue('activeDocumentPath', document.filePath)
         else:
             self.scripter.settings.setValue('activeDocumentPath', '')
 
         self.scripter.settings.setValue('editorFontSize', self.editor.fontInfo().pointSize())
 
         for action in self.actions:
             writeSettings = getattr(action['action'], "writeSettings", None)
             if callable(writeSettings):
                 writeSettings()
 
         #  Window Geometry
         rect = self.mainWidget.geometry()
         self.scripter.settings.setValue(KEY_GEOMETRY, rect)
 
         self.scripter.settings.endGroup()
 
     def _readSettings(self):
         """ It's similar to _writeSettings, but reading the settings when the ScripterDialog is closed. """
 
         self.scripter.settings.beginGroup('scripter')
 
         activeDocumentPath = self.scripter.settings.value('activeDocumentPath', '')
 
         if activeDocumentPath:
             if QFileInfo(activeDocumentPath).exists():
                 document = self.scripter.documentcontroller.openDocument(activeDocumentPath)
                 self.setStatusBar(document.filePath)
                 self.setDocumentEditor(document)
 
         for action in self.actions:
             readSettings = getattr(action['action'], "readSettings", None)
             if callable(readSettings):
                 readSettings()
 
         pointSize = self.scripter.settings.value('editorFontSize', str(self.editor.fontInfo().pointSize()))
         self.editor.setFontSize(int(pointSize))
 
         # Window Geometry
         rect = self.scripter.settings.value(KEY_GEOMETRY, DEFAULT_GEOMETRY)
         self.mainWidget.setGeometry(rect)
 
         self.scripter.settings.endGroup()
 
     def _saveSettings(self):
         self.scripter.settings.sync()
diff --git a/plugins/python/tenbrushes/kritapykrita_tenbrushes.desktop b/plugins/python/tenbrushes/kritapykrita_tenbrushes.desktop
index 4f43928dfd..0bc9bf518d 100644
--- a/plugins/python/tenbrushes/kritapykrita_tenbrushes.desktop
+++ b/plugins/python/tenbrushes/kritapykrita_tenbrushes.desktop
@@ -1,39 +1,39 @@
 [Desktop Entry]
 Type=Service
 ServiceTypes=Krita/PythonPlugin
 X-KDE-Library=tenbrushes
-X-Python-2-Compatible=false
+X-Python-2-Compatible=true
 X-Krita-Manual=Manual.html
 Name=Ten Brushes
 Name[ca]=Deu pinzells
 Name[ca@valencia]=Deu pinzells
 Name[cs]=Deset štětců
 Name[en_GB]=Ten Brushes
 Name[es]=Diez pinceles
 Name[gl]=Dez pinceis
 Name[it]=Dieci pennelli
 Name[nl]=Tien penselen
 Name[pl]=Dziesięć pędzli
 Name[pt]=Dez Pincéis
 Name[sv]=Tio penslar
 Name[tr]=On Fırça
 Name[uk]=Десять пензлів
 Name[x-test]=xxTen Brushesxx
 Name[zh_CN]=十笔刷
 Name[zh_TW]=10 個筆刷
 Comment=Assign a preset to ctrl-1 to ctrl-0
 Comment[ca]=Assigna una predefinició des de Ctrl-1 a Ctrl-0
 Comment[ca@valencia]=Assigna una predefinició des de Ctrl-1 a Ctrl-0
 Comment[en_GB]=Assign a preset to ctrl-1 to ctrl-0
 Comment[es]=Asignar una preselección a Ctrl-1 hasta Ctrl-0
 Comment[gl]=Asigne unha predefinición do Ctrl+1 ao Ctrl+0.
 Comment[it]=Assegna una preimpostazione per ctrl-1 a ctrl-0
 Comment[nl]=Een voorinstelling aan ctrl-1 tot ctrl-0 toekennen
 Comment[pl]=Przypisz nastawę do ctrl-1 lub ctrl-0
 Comment[pt]=Atribuir uma predefinição de Ctrl-1 até Ctrl-8
 Comment[sv]=Tilldela en förinställning för Ctrl+1 till Ctrl+0
 Comment[tr]= ctrl-1 ve ctrl-0 için ayar atama
 Comment[uk]=Прив’язування наборів налаштувань до скорочень від ctrl-1 до ctrl-0
 Comment[x-test]=xxAssign a preset to ctrl-1 to ctrl-0xx
 Comment[zh_CN]=将预设分配给 Ctrl+1 到 Ctrl+0
 Comment[zh_TW]=將預設指定給 ctrl-1 至 ctrl-0
diff --git a/plugins/python/tenbrushes/tenbrushes.py b/plugins/python/tenbrushes/tenbrushes.py
index d21c66a6fb..0f296e8d69 100644
--- a/plugins/python/tenbrushes/tenbrushes.py
+++ b/plugins/python/tenbrushes/tenbrushes.py
@@ -1,69 +1,69 @@
 '''
 This script is licensed CC 0 1.0, so that you can learn from it.
 
 ------ CC 0 1.0 ---------------
 
 The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
 
 You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.
 
 https://creativecommons.org/publicdomain/zero/1.0/legalcode
 '''
 import krita
-from tenbrushes import uitenbrushes
+from . import uitenbrushes
 
 
 class TenBrushesExtension(krita.Extension):
 
     def __init__(self, parent):
         super(TenBrushesExtension, self).__init__(parent)
 
         self.actions = []
         self.buttons = []
         self.selectedPresets = []
 
     def setup(self):
         self.readSettings()
-        
+
     def createActions(self, window):
         action = window.createAction("ten_brushes", "Ten Brushes")
         action.setToolTip("Assign ten brush presets to ten shortcuts.")
         action.triggered.connect(self.initialize)
         self.loadActions(window)
 
     def initialize(self):
         self.uitenbrushes = uitenbrushes.UITenBrushes()
         self.uitenbrushes.initialize(self)
 
     def readSettings(self):
         self.selectedPresets = Application.readSetting("", "tenbrushes", "").split(',')
 
     def writeSettings(self):
         presets = []
 
         for index, button in enumerate(self.buttons):
             self.actions[index].preset = button.preset
             presets.append(button.preset)
         Application.writeSetting("", "tenbrushes", ','.join(map(str, presets)))
 
     def loadActions(self, window):
         allPresets = Application.resources("preset")
 
         for index, item in enumerate(['1', '2', '3', '4', '5', '6', '7', '8', '9', '0']):
             action = window.createAction("activate_preset_" + item, "Activate Brush Preset " + item, "")
             action.triggered.connect(self.activatePreset)
 
             if index < len(self.selectedPresets) and self.selectedPresets[index] in allPresets:
                 action.preset = self.selectedPresets[index]
             else:
                 action.preset = None
 
             self.actions.append(action)
 
     def activatePreset(self):
         allPresets = Application.resources("preset")
         if Application.activeWindow() and len(Application.activeWindow().views()) > 0 and self.sender().preset in allPresets:
             Application.activeWindow().views()[0].activateResource(allPresets[self.sender().preset])
 
 
 Scripter.addExtension(TenBrushesExtension(Application))
diff --git a/plugins/python/tenbrushes/uitenbrushes.py b/plugins/python/tenbrushes/uitenbrushes.py
index 8ad75f6103..72826374cc 100644
--- a/plugins/python/tenbrushes/uitenbrushes.py
+++ b/plugins/python/tenbrushes/uitenbrushes.py
@@ -1,76 +1,75 @@
 '''
 This script is licensed CC 0 1.0, so that you can learn from it.
 
 ------ CC 0 1.0 ---------------
 
 The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
 
 You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.
 
 https://creativecommons.org/publicdomain/zero/1.0/legalcode
 '''
 from PyQt5.QtCore import Qt, QSize
 from PyQt5.QtGui import QPixmap, QIcon
 from PyQt5.QtWidgets import (QDialogButtonBox, QLabel, QVBoxLayout, QHBoxLayout)
-from tenbrushes import tenbrushesdialog, dropbutton
+from . import tenbrushesdialog, dropbutton
 import krita
 
 
 class UITenBrushes(object):
 
     def __init__(self):
         self.kritaInstance = krita.Krita.instance()
         self.mainDialog = tenbrushesdialog.TenBrushesDialog(self, self.kritaInstance.activeWindow().qwindow())
 
         self.buttonBox = QDialogButtonBox(self.mainDialog)
         self.vbox = QVBoxLayout(self.mainDialog)
         self.hbox = QHBoxLayout(self.mainDialog)
 
         self.buttonBox.accepted.connect(self.mainDialog.accept)
         self.buttonBox.rejected.connect(self.mainDialog.reject)
 
         self.buttonBox.setOrientation(Qt.Horizontal)
         self.buttonBox.setStandardButtons(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
 
         self.presetChooser = krita.PresetChooser(self.mainDialog)
 
     def initialize(self, tenbrushes):
         self.tenbrushes = tenbrushes
 
         self.loadButtons()
 
         self.vbox.addLayout(self.hbox)
         self.vbox.addWidget(QLabel("Select the brush preset, then click on the button you want to use to select the preset"))
         self.vbox.addWidget(self.presetChooser)
         self.vbox.addWidget(self.buttonBox)
 
-
         self.mainDialog.show()
         self.mainDialog.activateWindow()
         self.mainDialog.exec_()
 
     def loadButtons(self):
         self.tenbrushes.buttons = []
 
         allPresets = Application.resources("preset")
 
         for index, item in enumerate(['1', '2', '3', '4', '5', '6', '7', '8', '9', '0']):
             buttonLayout = QVBoxLayout()
             button = dropbutton.DropButton(self.mainDialog)
             button.setObjectName(item)
             button.clicked.connect(button.selectPreset)
             button.presetChooser = self.presetChooser
 
             if self.tenbrushes.actions[index] and self.tenbrushes.actions[index].preset and self.tenbrushes.actions[index].preset in allPresets:
                 p = allPresets[self.tenbrushes.actions[index].preset]
                 button.preset = p.name()
                 button.setIcon(QIcon(QPixmap.fromImage(p.image())))
 
             buttonLayout.addWidget(button)
 
             label = QLabel(self.tenbrushes.actions[index].shortcut().toString())
             label.setAlignment(Qt.AlignHCenter)
             buttonLayout.addWidget(label)
 
             self.hbox.addLayout(buttonLayout)
             self.tenbrushes.buttons.append(button)
diff --git a/plugins/python/tenscripts/kritapykrita_tenscripts.desktop b/plugins/python/tenscripts/kritapykrita_tenscripts.desktop
index 281459cb8f..b75f520cd8 100644
--- a/plugins/python/tenscripts/kritapykrita_tenscripts.desktop
+++ b/plugins/python/tenscripts/kritapykrita_tenscripts.desktop
@@ -1,36 +1,36 @@
 [Desktop Entry]
 Type=Service
 ServiceTypes=Krita/PythonPlugin
 X-KDE-Library=tenscripts
-X-Python-2-Compatible=false
+X-Python-2-Compatible=true
 X-Krita-Manual=Manual.html
 Name=Ten Scripts
 Name[ca]=Deu scripts
 Name[ca@valencia]=Deu scripts
 Name[en_GB]=Ten Scripts
 Name[es]=Diez guiones
 Name[gl]=Dez scripts
 Name[it]=Dieci script
 Name[nl]=Tien scripts
 Name[pl]=Skrypty Ten
 Name[pt]=Dez Programas
 Name[sv]=Tio skript
 Name[uk]=Десять скриптів
 Name[x-test]=xxTen Scriptsxx
 Name[zh_CN]=十脚本
 Name[zh_TW]=10 個腳本
 Comment=A Python-based plugin for creating ten actions and assign them to Python scripts
 Comment[ca]=Un connector basant en el Python per crear deu accions i assignar-les a scripts del Python
 Comment[ca@valencia]=Un connector basant en el Python per crear deu accions i assignar-les a scripts del Python
 Comment[en_GB]=A Python-based plugin for creating ten actions and assign them to Python scripts
 Comment[es]=Un complemento basado en Python para crear diez acciones y asignarlas a guiones de Python
 Comment[gl]=Un complemento escrito en Python para crear dez accións e asignalas a scripts escritos en Python.
 Comment[it]=Un'estensione basata su Python per creare dieci azioni e assegnarle a script Python
 Comment[nl]=Een op Python gebaseerde plug-in om tien acties te maken en ze aan Python scripts toe te wijzen
 Comment[pl]=Dok oparty na Pythonie do tworzenia działań i przypisywania ich skryptom Pythona
 Comment[pt]=Um 'plugin' em Python para criar dez acções e atribuí-las a programas em Python
 Comment[sv]=Ett Python-baserat insticksprogram för att skapa tio åtgärder och tilldela dem till Python-skript
 Comment[uk]=Скрипт на основі Python для створення десяти дій і прив'язування до них скриптів Python
 Comment[x-test]=xxA Python-based plugin for creating ten actions and assign them to Python scriptsxx
 Comment[zh_CN]=用于创建十个操作并将它们分配给 Python 脚本的插件
 Comment[zh_TW]=基於 Python 的外掛程式，用於建立 10 個動作並且將它們指定給 Python 腳本
diff --git a/plugins/python/tenscripts/tenscripts.py b/plugins/python/tenscripts/tenscripts.py
index b556580aae..983b977721 100644
--- a/plugins/python/tenscripts/tenscripts.py
+++ b/plugins/python/tenscripts/tenscripts.py
@@ -1,84 +1,93 @@
 '''
 This script is licensed CC 0 1.0, so that you can learn from it.
 
 ------ CC 0 1.0 ---------------
 
 The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
 
 You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.
 
 https://creativecommons.org/publicdomain/zero/1.0/legalcode
 '''
+import sys
+
 from PyQt5.QtWidgets import QMessageBox
 import krita
-from tenscripts import uitenscripts
-import importlib
+from . import uitenscripts
+
+if sys.version_info[0] > 2:
+    import importlib
+else:
+    import imp
 
 
 class TenScriptsExtension(krita.Extension):
 
     def __init__(self, parent):
-       super(TenScriptsExtension, self).__init__(parent)
+        super(TenScriptsExtension, self).__init__(parent)
 
-       self.actions = []
-       self.scripts = []
+        self.actions = []
+        self.scripts = []
 
     def setup(self):
         self.readSettings()
-        
+
     def createActions(self, window):
         action = window.createAction("ten_scripts", "Ten Scripts")
         action.setToolTip("Assign ten scripts to ten shortcuts.")
         action.triggered.connect(self.initialize)
         self.loadActions(window)
 
     def initialize(self):
         self.uitenscripts = uitenscripts.UITenScripts()
         self.uitenscripts.initialize(self)
 
     def readSettings(self):
         self.scripts = Application.readSetting("tenscripts", "scripts", "").split(',')
 
     def writeSettings(self):
         saved_scripts = self.uitenscripts.saved_scripts()
 
         for index, script in enumerate(saved_scripts):
             self.actions[index].script = script
 
         Application.writeSetting("tenscripts", "scripts", ','.join(map(str, saved_scripts)))
 
     def loadActions(self, window):
         for index, item in enumerate(['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']):
             action = window.createAction("execute_script_" + item, "Execute Script " + item, "")
             action.script = None
             action.triggered.connect(self._executeScript)
 
             if index < len(self.scripts):
                 action.script = self.scripts[index]
 
             self.actions.append(action)
 
     def _executeScript(self):
         script = self.sender().script
         if script:
             try:
-                spec = importlib.util.spec_from_file_location("users_script", script)
-                users_module = importlib.util.module_from_spec(spec)
-                spec.loader.exec_module(users_module)
-                
+                if sys.version_info[0] > 2:
+                    spec = importlib.util.spec_from_file_location("users_script", script)
+                    users_module = importlib.util.module_from_spec(spec)
+                    spec.loader.exec_module(users_module)
+                else:
+                    users_module = imp.load_source("users_script", script)
+
                 if hasattr(users_module, 'main') and callable(users_module.main):
                     users_module.main()
 
                 self.showMessage('script {0} executed'.format(self.sender().script))
             except Exception as e:
                 self.showMessage(str(e))
         else:
             self.showMessage("You didn't assign a script to that action")
 
     def showMessage(self, message):
         self.msgBox  = QMessageBox(Application.activeWindow().qwindow())
         self.msgBox.setText(message)
         self.msgBox.exec_()
 
 
 Scripter.addExtension(TenScriptsExtension(Application))
diff --git a/plugins/python/tenscripts/uitenscripts.py b/plugins/python/tenscripts/uitenscripts.py
index b73d94670a..2eec3c15b6 100644
--- a/plugins/python/tenscripts/uitenscripts.py
+++ b/plugins/python/tenscripts/uitenscripts.py
@@ -1,109 +1,109 @@
 '''
 This script is licensed CC 0 1.0, so that you can learn from it.
 
 ------ CC 0 1.0 ---------------
 
 The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
 
 You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.
 
 https://creativecommons.org/publicdomain/zero/1.0/legalcode
 '''
 from PyQt5.QtCore import Qt
 from PyQt5.QtWidgets import (QWidget, QVBoxLayout, QHBoxLayout, QPushButton,
                              QLineEdit, QScrollArea, QGridLayout, QFileDialog,
                              QLabel, QDialogButtonBox)
-from tenscripts import tenscriptsdialog
+from . import tenscriptsdialog
 import krita
 
 
 class UITenScripts(object):
 
     def __init__(self):
         self.kritaInstance = krita.Krita.instance()
         self.mainDialog = tenscriptsdialog.TenScriptsDialog(self, self.kritaInstance.activeWindow().qwindow())
 
         self.buttonBox = QDialogButtonBox(self.mainDialog)
         self.layout = QVBoxLayout(self.mainDialog)
         self.baseWidget = QWidget()
         self.baseArea = QWidget()
-        self.scrollArea =  QScrollArea()
+        self.scrollArea = QScrollArea()
         self.scriptsLayout = QGridLayout()
 
         self.buttonBox.accepted.connect(self.mainDialog.accept)
         self.buttonBox.rejected.connect(self.mainDialog.reject)
 
         self.buttonBox.setOrientation(Qt.Horizontal)
         self.buttonBox.setStandardButtons(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
         self.scrollArea.setWidgetResizable(True)
 
     def initialize(self, tenscripts):
         self.tenscripts = tenscripts
 
         self._loadGridLayout()
         self._fillScripts()
 
         self.baseArea.setLayout(self.scriptsLayout)
         self.scrollArea.setWidget(self.baseArea)
 
         self.layout.addWidget(self.scrollArea)
         self.layout.addWidget(self.buttonBox)
 
         self.mainDialog.show()
         self.mainDialog.activateWindow()
         self.mainDialog.exec_()
 
     def addNewRow(self, key):
         rowPosition = self.scriptsLayout.rowCount()
         rowLayout = QHBoxLayout()
         label = QLabel()
         directoryTextField = QLineEdit()
         directoryDialogButton = QPushButton("...")
 
         directoryTextField.setReadOnly(True)
         label.setText(self.tenscripts.actions[key].shortcut().toString())
         directoryTextField.setToolTip("Selected Path")
         directoryDialogButton.setToolTip("Select the script")
         directoryDialogButton.clicked.connect(self._selectScript)
 
         self.scriptsLayout.addWidget(label, rowPosition, 0, Qt.AlignLeft|Qt.AlignTop)
         self.scriptsLayout.addWidget(directoryTextField, rowPosition, 1, Qt.AlignLeft|Qt.AlignTop)
         self.scriptsLayout.addWidget(directoryDialogButton, rowPosition, 2, Qt.AlignLeft|Qt.AlignTop)
 
     def saved_scripts(self):
         _saved_scripts = []
         index = 0
 
         for row in range(self.scriptsLayout.rowCount()-1):
             textField = self.scriptsLayout.itemAt(index + 1).widget()
             if textField.text():
                 _saved_scripts.append(textField.text())
             index += 3
 
         return _saved_scripts
 
     def _selectScript(self):
         dialog = QFileDialog(self.mainDialog)
         dialog.setNameFilter('Python files (*.py)')
 
-        if dialog.exec():
+        if dialog.exec_():
             selectedFile = dialog.selectedFiles()[0]
             obj = self.mainDialog.sender()
             textField = self.scriptsLayout.itemAt(self.scriptsLayout.indexOf(obj)-1).widget()
             textField.setText(selectedFile)
 
     def _loadGridLayout(self):
         for item in range(0, 10):
             self.addNewRow(item)
 
     def _fillScripts(self):
         scripts = self.tenscripts.scripts
         index = 0
 
         for row in range(self.scriptsLayout.rowCount()-1):
             if row >= len(scripts):
                 return
 
             textField = self.scriptsLayout.itemAt(index + 1).widget()
             textField.setText(scripts[row])
             index += 3