diff --git a/packaging/macos/osxbuild.sh b/packaging/macos/osxbuild.sh
index f04e5babf4..57279ffc49 100755
--- a/packaging/macos/osxbuild.sh
+++ b/packaging/macos/osxbuild.sh
@@ -1,650 +1,654 @@
 #!/usr/bin/env bash
 
 # osxbuild.sh automates building and installing of krita and krita dependencies
 # for OSX, the script only needs you to set BUILDROOT environment to work
 # properly.
 #
 
 # Run with no args for a short help about each command.
 
 # builddeps: Attempts to build krita dependencies in the necessary order,
 #     intermediate steps for creating symlinks and fixing rpath of some
 #     packages midway is also managed. Order goes from top to bottom, to add
 #     new steps just place them in the proper place.
 
 # rebuilddeps: This re-runs all make and make install of dependencies 3rdparty
 #     this was needed as deleting the entire install directory an rerunning build
 #     step for dependencies does not install if they are already built. This step
 #     forces installation. Have not tested it lately so it might not be needed anymore
 
 # build: Runs cmake build and make step for krita sources. It always run cmake step, so
 #     it might take a bit longer than a pure <make> on the source tree. The script tries
 #     to set the make flag -jN to a proper N.
 
 # install: Runs install step for krita sources.
 
 # fixboost: Search for all libraries using boost and sets a proper @rpath for boost as by
 #     default it fails to set a proper @rpath
 
 # buildinstall: Runs build, install and fixboost steps.#
 
 if test -z $BUILDROOT; then
     echo "ERROR: BUILDROOT env not set, exiting!"
     echo "\t Must point to the root of the buildfiles as stated in 3rdparty Readme"
     exit
 fi
 echo "BUILDROOT set to ${BUILDROOT}"
 
 # -- Parse input args
 for arg in "${@}"; do
     if [[ "${arg}" = --dirty ]]; then
         OSXBUILD_CLEAN="keep dirty"
     fi
 done
 
 export KIS_SRC_DIR=${BUILDROOT}/krita
 export KIS_TBUILD_DIR=${BUILDROOT}/depbuild
 export KIS_TDEPINSTALL_DIR=${BUILDROOT}/depinstall
 export KIS_DOWN_DIR=${BUILDROOT}/down
 export KIS_BUILD_DIR=${BUILDROOT}/kisbuild
 export KIS_INSTALL_DIR=${BUILDROOT}/i
 
 # flags for OSX environment
 # Qt only supports from 10.12 up, and https://doc.qt.io/qt-5/macos.html#target-platforms warns against setting it lower
 export MACOSX_DEPLOYMENT_TARGET=10.12
 export QMAKE_MACOSX_DEPLOYMENT_TARGET=10.12
 
 
 export PATH=${KIS_INSTALL_DIR}/bin:$PATH
 export PKG_CONFIG_PATH=${KIS_INSTALL_DIR}/share/pkgconfig:${KIS_INSTALL_DIR}/lib/pkgconfig
 export CMAKE_PREFIX_PATH=${KIS_INSTALL_DIR}
 export C_INCLUDE_PATH=${KIS_INSTALL_DIR}/include:/usr/include:${C_INCLUDE_PATH}
 export CPLUS_INCLUDE_PATH=${KIS_INSTALL_DIR}/include:/usr/include:${CPLUS_INCLUDE_PATH}
 export LIBRARY_PATH=${KIS_INSTALL_DIR}/lib:/usr/lib:${LIBRARY_PATH}
 # export CPPFLAGS=-I${KIS_INSTALL_DIR}/include
 # export LDFLAGS=-L${KIS_INSTALL_DIR}/lib
 export FRAMEWORK_PATH=${KIS_INSTALL_DIR}/lib/
 
 # export PYTHONHOME=${KIS_INSTALL_DIR}
 # export PYTHONPATH=${KIS_INSTALL_DIR}/sip:${KIS_INSTALL_DIR}/lib/python3.8/site-packages:${KIS_INSTALL_DIR}/lib/python3.8
 
 # This will make the debug output prettier
 export KDE_COLOR_DEBUG=1
 export QTEST_COLORED=1
 
 export OUPUT_LOG="${BUILDROOT}/osxbuild.log"
 printf "" > "${OUPUT_LOG}"
 
 # Build time variables
 if test -z $(which cmake); then
     echo "ERROR: cmake not found, exiting!"
     exit
 fi
 
 # configure max core for make compile
 ((MAKE_THREADS=1))
 if test ${OSTYPE} == "darwin*"; then
     ((MAKE_THREADS = $(sysctl -n hw.logicalcpu)))
 fi
 
 # Prints stderr and stdout to log files
 # >(tee) works but breaks sigint
 log_cmd () {
     "$@" 1>> ${OUPUT_LOG}
     osxbuild_error="${?}"
 }
 
 # Log messages to logfile
 log () {
     printf "%s\n" "${@}"  | tee -a ${OUPUT_LOG}
 }
 
 # if previous command gives error
 # print msg
 print_if_error() {
     if [ "${osxbuild_error}" -ne 0 ]; then
         printf "\nERROR: Printing last lines of log ouput\n\n"
         tail ${OUPUT_LOG}
         printf "\e[31m%s %s\e[0m\n" "Error:" "${1}"
     fi
 }
 
 # print status messages
 print_msg() {
     printf "\e[32m%s\e[0m\n" "${1}"
     printf "%s\n" "${1}" >> ${OUPUT_LOG}
 }
 
 check_dir_path () {
     printf "%s" "Checking if ${1} exists and is dir... "
     if test -d ${1}; then
         echo -e "OK"
 
     elif test -e ${1}; then
         echo -e "\n\tERROR: file ${1} exists but is not a directory!" >&2
         return 1
     else
         echo -e "Creating ${1}"
         mkdir ${1}
     fi
     return 0
 }
 
 waiting_fixed() {
     local message="${1}"
     local waitTime=${2}
 
     for i in $(seq ${waitTime}); do
         sleep 1
         printf -v dots '%*s' ${i}
         printf -v spaces '%*s' $((${waitTime} - $i))
         printf "\r%s [%s%s]" "${message}" "${dots// /.}" "${spaces}"
     done
     printf "\n"
 }
 
 dir_clean() {
     if [[ -d "${1}" ]]; then
         log "Default cleaning build dirs, use --dirty to keep them..."
         waiting_fixed "Erase of ${1} in 5 sec" 5
         rm -rf "${1}"
     fi
 }
 
 # builds dependencies for the first time
 cmake_3rdparty () {
     cd ${KIS_TBUILD_DIR}
 
     local build_pkgs=("${@}") # convert to array
     local error="false"
 
     if [[ ${2} = "1" ]]; then
         local nofix="true"
         local build_pkgs=(${build_pkgs[@]:0:1})
     fi
 
     for package in ${build_pkgs[@]} ; do
+        if [[ ${package:0:3} != "ext" ]]; then
+            continue
+        fi
         print_msg "Building ${package}"
         log_cmd cmake --build . --config RelWithDebInfo --target ${package}
         
         print_if_error "Failed build ${package}"
         if [[ ! ${osxbuild_error} -ne 0 ]]; then
             print_msg "Build Success! ${package}"
         else
             log "${pkg} build fail, attempting known fixes..."
             error="true"
         fi
         # fixes does not depend on failure
         if [[ ! ${nofix} ]]; then
             build_3rdparty_fixes ${package} ${error}
 
         elif [[ "${error}" = "true" ]]; then
             log "ERROR: ${pkg} failed a second time, time to check the logs"
             log "stoping..."
         fi
     done
 }
 
 build_3rdparty_fixes(){
     local pkg=${1}
     local error=${2}
+
     if [[ "${pkg}" = "ext_qt" && -e "${KIS_INSTALL_DIR}/bin/qmake" ]]; then
         ln -sf qmake "${KIS_INSTALL_DIR}/bin/qmake-qt5"
         # build macdeployqt
         log_cmd cd "${BUILDROOT}/depbuild/ext_qt/ext_qt-prefix/src/ext_qt/qttools/src"
         print_if_error "macdeployqt source dir was not found, it will be missing for deployment!"
 
         if [[ ! ${osxbuild_error} -ne 0 && ! -e "${KIS_INSTALL_DIR}/bin/macdeployqt" ]]; then
             make sub-macdeployqt-all
             make sub-macdeployqt-install_subtargets
             make install
         fi
         cd "${KIS_TBUILD_DIR}"
         error="false"
 
     elif [[ "${pkg}" = "ext_openexr" ]]; then
         # open exr will fail the first time is called
         # rpath needs to be fixed an build rerun
         log "Fixing rpath on openexr file: b44ExpLogTable"
         log "Fixing rpath on openexr file: dwaLookups"
         log_cmd install_name_tool -add_rpath ${KIS_INSTALL_DIR}/lib $(find ${KIS_TBUILD_DIR}/ext_openexr/ext_openexr-prefix/src/ext_openexr-build -name b44ExpLogTable)
         log_cmd install_name_tool -add_rpath ${KIS_INSTALL_DIR}/lib $(find ${KIS_TBUILD_DIR}/ext_openexr/ext_openexr-prefix/src/ext_openexr-build -name dwaLookups)
         # we must rerun build!
         cmake_3rdparty ext_openexr "1"
         error="false"
 
     elif [[ "${pkg}" = "ext_fontconfig" ]]; then
         log "fixing rpath on fc-cache"
         log_cmd install_name_tool -add_rpath ${KIS_INSTALL_DIR}/lib ${KIS_TBUILD_DIR}/ext_fontconfig/ext_fontconfig-prefix/src/ext_fontconfig-build/fc-cache/.libs/fc-cache
         # rerun rebuild
         cmake_3rdparty ext_fontconfig "1"
         error="false"
 
     elif [[ "${pkg}" = "ext_poppler" && "${error}" = "true" ]]; then
         log "re-running poppler to avoid possible glitch"
         cmake_3rdparty ext_poppler "1"
         error="false"
     fi
 
     if [[ "${error}" = "true" ]]; then
         log "Error building package ${pkg}, stopping..."
         exit
     fi
 }
 
 build_3rdparty () {
     print_msg "building in ${KIS_TBUILD_DIR}"
 
     log "$(check_dir_path ${KIS_TBUILD_DIR})"
     log "$(check_dir_path ${KIS_DOWN_DIR})"
     log "$(check_dir_path ${KIS_INSTALL_DIR})"
 
     cd ${KIS_TBUILD_DIR}
 
     log_cmd cmake ${KIS_SRC_DIR}/3rdparty/ \
         -DCMAKE_OSX_DEPLOYMENT_TARGET=10.12 \
         -DCMAKE_INSTALL_PREFIX=${KIS_INSTALL_DIR} \
         -DCMAKE_PREFIX_PATH:PATH=${KIS_INSTALL_DIR} \
         -DEXTERNALS_DOWNLOAD_DIR=${KIS_DOWN_DIR} \
         -DINSTALL_ROOT=${KIS_INSTALL_DIR}
 
         # -DCPPFLAGS=-I${KIS_INSTALL_DIR}/include \
         # -DLDFLAGS=-L${KIS_INSTALL_DIR}/lib
 
     print_msg "finished 3rdparty build setup"
     
     if [[ -n ${1} ]]; then
         cmake_3rdparty "${@}"
         # log "Syncing install backup..."
         # rsync -a --delete "${KIS_INSTALL_DIR}" "${KIS_INSTALL_DIR}.onlydeps"
         exit
     fi
 
     # build 3rdparty tools
     # The order must not be changed!
     cmake_3rdparty \
         ext_pkgconfig \
         ext_gettext \
         ext_openssl \
         ext_qt \
         ext_zlib \
         ext_boost \
         ext_eigen3 \
         ext_exiv2 \
         ext_fftw3 \
         ext_ilmbase \
         ext_jpeg \
         ext_lcms2 \
         ext_ocio \
         ext_openexr \
         ext_openjpeg
 
     cmake_3rdparty \
         ext_png \
         ext_tiff \
         ext_gsl \
         ext_vc \
         ext_libraw \
         ext_giflib \
         ext_freetype \
         ext_fontconfig \
         ext_poppler
 
     # Stop if qmake link was not created
     # this meant qt build fail and further builds will
     # also fail.
     log_cmd test -L "${KIS_INSTALL_DIR}/bin/qmake-qt5"
 
     print_if_error "qmake link missing!"
     if [[ ${osxbuild_error} -ne 0 ]]; then
         printf "
     link: ${KIS_INSTALL_DIR}/bin/qmake-qt5 missing!
     It probably means ext_qt failed!!
     check, fix and rerun!\n"
         exit
     fi
 
     # for python
     cmake_3rdparty \
         ext_python \
         ext_sip \
         ext_pyqt
 
     cmake_3rdparty ext_libheif
 
     cmake_3rdparty \
         ext_extra_cmake_modules \
         ext_kconfig \
         ext_kwidgetsaddons \
         ext_kcompletion \
         ext_kcoreaddons \
         ext_kguiaddons \
         ext_ki18n \
         ext_kitemmodels \
         ext_kitemviews \
         ext_kimageformats \
         ext_kwindowsystem \
         ext_quazip
 
 
     ## All builds done, creating a new install onlydeps install dir
     dir_clean "${KIS_INSTALL_DIR}.onlydeps"
     log "Copying ${KIS_INSTALL_DIR} to ${KIS_INSTALL_DIR}.onlydeps"
     cp -aP "${KIS_INSTALL_DIR}" "${KIS_INSTALL_DIR}.onlydeps"
     print_msg "Build Finished!"
 }
 
 # Recall cmake for all 3rd party packages
 # make is only on target first run
 # subsequent runs only call make install
 rebuild_3rdparty () {
     print_msg "starting rebuild of 3rdparty packages"
     build_install_ext() {
         for pkg in ${@:1:${#@}}; do
             {
                 cd ${KIS_TBUILD_DIR}/${pkg}/${pkg}-prefix/src/${pkg}-stamp
             } || {
                 cd ${KIS_TBUILD_DIR}/ext_frameworks/${pkg}-prefix/src/${pkg}-stamp
             } || {
                 cd ${KIS_TBUILD_DIR}/ext_heif/${pkg}-prefix/src/${pkg}-stamp
             }
             log "Installing ${pkg} files..."
             rm ${pkg}-configure ${pkg}-build ${pkg}-install
 
             cmake_3rdparty ${pkg}
 
             cd ${KIS_TBUILD_DIR}
         done
     }
     # Do not process complete list only pkgs given.
     if ! test -z ${1}; then
         build_install_ext ${@}
         exit
     fi
 
     build_install_ext \
         ext_pkgconfig \
         ext_iconv \
         ext_gettext \
         ext_openssl \
         ext_qt \
         ext_zlib \
         ext_boost \
         ext_eigen3 \
         ext_expat \
         ext_exiv2 \
         ext_fftw3 \
         ext_ilmbase \
         ext_jpeg \
         ext_patch \
         ext_lcms2 \
         ext_ocio \
         ext_ilmbase \
         ext_openexr
         #ext_openjpeg
 
     build_install_ext \
         ext_png \
         ext_tiff \
         ext_gsl \
         ext_vc \
         ext_libraw \
         ext_giflib \
         ext_fontconfig \
         ext_freetype \
         ext_poppler \
         ext_python \
         ext_sip \
         ext_pyqt \
 
     build_install_ext \
         ext_nasm \
         ext_libx265 \
         ext_libde265 \
         ext_libheif
 
     # Build kde_frameworks
     build_install_ext \
         ext_extra_cmake_modules \
         ext_kconfig \
         ext_kwidgetsaddons \
         ext_kcompletion \
         ext_kcoreaddons \
         ext_kguiaddons \
         ext_ki18n \
         ext_kitemmodels \
         ext_kitemviews \
         ext_kimageformats \
         ext_kwindowsystem \
         ext_quazip
 }
 
 #not tested
 set_krita_dirs() {
     if [[ -n ${1} ]]; then
         KIS_BUILD_DIR=${BUILDROOT}/b_${1}
         KIS_INSTALL_DIR=${BUILDROOT}/i_${1}
         KIS_SRC_DIR=${BUILDROOT}/src_${1}
     fi
 }
 # build_krita
 # run cmake krita
 build_krita () {
     if [[ -z ${OSXBUILD_CLEAN} ]]; then
         log "Deleting ${KIS_BUILD_DIR}"
         dir_clean "${KIS_BUILD_DIR}"
     else
         if [[ -e "${KIS_INSTALL_DIR}.onlydeps" && -d "${KIS_INSTALL_DIR}.onlydeps" ]]; then
             print_msg "Found ${KIS_INSTALL_DIR}.onlydeps"
             log "==== manually copy onlydeps to ${KIS_INSTALL_DIR} if you need a fresh build"
         fi
     fi
 
     export DYLD_FRAMEWORK_PATH=${FRAMEWORK_PATH}
     echo ${KIS_BUILD_DIR}
     echo ${KIS_INSTALL_DIR}
     log_cmd check_dir_path ${KIS_BUILD_DIR}
     cd ${KIS_BUILD_DIR}
 
     cmake ${KIS_SRC_DIR} \
         -DFOUNDATION_BUILD=ON \
         -DBoost_INCLUDE_DIR=${KIS_INSTALL_DIR}/include \
         -DCMAKE_INSTALL_PREFIX=${KIS_INSTALL_DIR} \
         -DCMAKE_PREFIX_PATH=${KIS_INSTALL_DIR} \
         -DDEFINE_NO_DEPRECATED=1 \
         -DBUILD_TESTING=OFF \
         -DHIDE_SAFE_ASSERTS=ON \
         -DKDE_INSTALL_BUNDLEDIR=${KIS_INSTALL_DIR}/bin \
         -DPYQT_SIP_DIR_OVERRIDE=${KIS_INSTALL_DIR}/share/sip/ \
         -DCMAKE_BUILD_TYPE=RelWithDebInfo \
         -DCMAKE_OSX_DEPLOYMENT_TARGET=10.12 \
         -DPYTHON_INCLUDE_DIR=${KIS_INSTALL_DIR}/lib/Python.framework/Headers
 
     # copiling phase
     make -j${MAKE_THREADS}
 
     # compile integrations
     if test ${OSTYPE} == "darwin*"; then
         cd ${KIS_BUILD_DIR}/krita/integration/kritaquicklook
         make -j${MAKE_THREADS}
     fi
 }
 
 build_krita_tarball () {
     filename="$(basename ${1})"
     KIS_CUSTOM_BUILD="${BUILDROOT}/releases/${filename%.tar.gz}"
     print_msg "Tarball BUILDROOT is ${KIS_CUSTOM_BUILD}"
 
     filename_dir=$(dirname "${1}")
     cd "${filename_dir}"
     file_abspath="$(pwd)/${1##*/}"
 
     mkdir "${KIS_CUSTOM_BUILD}" 2> /dev/null
     cd "${KIS_CUSTOM_BUILD}"
 
     mkdir "src" "build" 2> /dev/null
     log_cmd tar -xzf "${file_abspath}" --strip-components=1 --directory "src"
 
     print_if_error "Failed untar of ${filename}"
     if [[ ${osxbuild_error} -ne 0 ]]; then
         exit
     fi
 
     KIS_BUILD_DIR="${KIS_CUSTOM_BUILD}/build"
     KIS_SRC_DIR="${KIS_CUSTOM_BUILD}/src"
 
     build_krita
 
     print_msg "Build done!"
     print_msg "to install run
 osxbuild.sh install ${KIS_BUILD_DIR}"
 
 }
 
 install_krita () {
     # custom install provided
     if [[ -n "${1}" ]]; then
         KIS_BUILD_DIR="${1}"
     fi
 
     # Delete any "krita" named file in install
     # this helps avoid double versioned libraries
     log "About to delete krita libs from ${KIS_INSTALL_DIR}"
     waiting_fixed "Deleting files in 5 seconds" 5
     find ${KIS_INSTALL_DIR} -type d -name "*krita*" | xargs -I FILE  rm -rf FILE
     find ${KIS_INSTALL_DIR}  \( -type f -or -type l \) -name "*krita*" | xargs -P4 -I FILE rm FILE
 
     print_msg "Install krita from ${KIS_BUILD_DIR}"
     log_cmd check_dir_path ${KIS_BUILD_DIR}
 
     cd "${KIS_BUILD_DIR}"
     osxbuild_error=$?
     print_if_error "could not cd to ${KIS_BUILD_DIR}"
     if [[ ${osxbuild_error} -ne 0 ]]; then
         exit
     fi
 
     make install
 
     # compile integrations
     if test ${OSTYPE} == "darwin*"; then
         cd ${KIS_BUILD_DIR}/krita/integration/kritaquicklook
         make install
     fi
 }
 
 # Runs all fixes for path and packages.
 # Historically only fixed boost @rpath
 fix_boost_rpath () {
     # helpers to define function only once
     fixboost_find () {
         for FILE in "${@}"; do
             if [[ -n "$(otool -L $FILE | grep boost)" ]]; then
                 log "Fixing -- $FILE"
                 log_cmd install_name_tool -change libboost_system.dylib @rpath/libboost_system.dylib $FILE
             fi
         done
     }
 
     batch_fixboost() {
         xargs -P4 -I FILE bash -c 'fixboost_find "FILE"'
     }
 
     export -f fixboost_find
     export -f log
     export -f log_cmd
 
     print_msg "Fixing boost in... ${KIS_INSTALL_DIR}"
     # install_name_tool -add_rpath ${KIS_INSTALL_DIR}/lib $BUILDROOT/$KRITA_INSTALL/bin/krita.app/Contents/MacOS/gmic_krita_qt
     log_cmd install_name_tool -add_rpath ${KIS_INSTALL_DIR}/lib ${KIS_INSTALL_DIR}/bin/krita.app/Contents/MacOS/krita
     # echo "Added rpath ${KIS_INSTALL_DIR}/lib to krita bin"
     # install_name_tool -add_rpath ${BUILDROOT}/deps/lib ${KIS_INSTALL_DIR}/bin/krita.app/Contents/MacOS/krita
     log_cmd install_name_tool -change libboost_system.dylib @rpath/libboost_system.dylib ${KIS_INSTALL_DIR}/bin/krita.app/Contents/MacOS/krita
 
     find -L "${KIS_INSTALL_DIR}" -name '*so' -o -name '*dylib' | batch_fixboost
 
     log "Fixing boost done!"
 }
 
 print_usage () {
     printf "USAGE: osxbuild.sh <buildstep> [pkg|file]\n"
     printf "BUILDSTEPS:\t\t"
     printf "\n builddeps \t\t Run cmake step for 3rd party dependencies, optionally takes a [pkg] arg"
     printf "\n rebuilddeps \t\t Rerun make and make install step for 3rd party deps, optionally takes a [pkg] arg
     \t\t\t useful for cleaning install directory and quickly reinstall all deps."
     printf "\n fixboost \t\t Fixes broken boost \@rpath on OSX"
     printf "\n build \t\t\t Builds krita"
     printf "\n buildtarball \t\t Builds krita from provided [file] tarball"
     printf "\n clean \t\t\t Removes build and install directories to start fresh"
     printf "\n install \t\t Installs krita. Optionally accepts a [build dir] as argument
     \t\t\t this will install krita from given directory"
     printf "\n buildinstall \t\t Build and Installs krita, running fixboost after installing"
     printf "\n"
     printf "OPTIONS:\t\t"
     printf "\n \t --dirty \t [build] (old default) Keep old build directories before build to start fresh"
     printf "\n"
 }
 
 if [[ ${#} -eq 0 ]]; then
     echo "ERROR: No option given!"
     print_usage
     exit 1
 fi
 
 if [[ ${1} = "builddeps" ]]; then
     if [[ -z ${OSXBUILD_CLEAN} ]]; then
         dir_clean "${KIS_INSTALL_DIR}"
         dir_clean "${KIS_TBUILD_DIR}"
     fi
     build_3rdparty "${@:2}"
     exit
 
 elif [[ ${1} = "rebuilddeps" ]]; then
     rebuild_3rdparty "${@:2}"
     exit
 
 elif [[ ${1} = "fixboost" ]]; then
     if [[ -d ${1} ]]; then
         KIS_BUILD_DIR="${1}"
     fi
     fix_boost_rpath
 
 elif [[ ${1} = "build" ]]; then
     build_krita ${2}
     exit
 
 elif [[ ${1} = "buildtarball" ]]; then
     # uncomment line to optionally change
     # install directory providing a third argument
     # This is not on by default as build success requires all
     # deps installed in the given dir beforehand.
     # KIS_INSTALL_DIR=${3}
     build_krita_tarball ${2}
 
 elif [[ ${1} = "clean" ]]; then
     # remove all build and install directories to start
     # a fresh install. this no different than using rm directly
     dir_clean "${KIS_TBUILD_DIR}"
     dir_clean "${$KIS_BUILD_DIR}"
     dir_clean "${KIS_INSTALL_DIR}"
     exit
 
 elif [[ ${1} = "install" ]]; then
     install_krita ${2}
     fix_boost_rpath
 
 elif [[ ${1} = "buildinstall" ]]; then
     build_krita ${2}
     install_krita ${2}
     fix_boost_rpath ${2}
 
 elif [[ ${1} = "test" ]]; then
     ${KIS_INSTALL_DIR}/bin/krita.app/Contents/MacOS/krita
 
 else
     echo "Option ${1} not supported"
     print_usage
     exit 1
 fi
 
 # after finishig sometimes it complains about missing matching quotes.
diff --git a/packaging/macos/osxdeploy.sh b/packaging/macos/osxdeploy.sh
index 6911887a4d..c95a19dd8a 100755
--- a/packaging/macos/osxdeploy.sh
+++ b/packaging/macos/osxdeploy.sh
@@ -1,767 +1,768 @@
 #!/usr/bin/env bash
 
 # Krita tool to create dmg from installed source
 # Copies all files to a folder to be converted into the final dmg
 
 # osxdeploy.sh automates the creation of the release DMG.
 #       default background and style are used if none provided
 
 # A short explanation of what it does:
 
 # - Copies krita.app contents to kritadmg folder
 # - Copies i/share to Contents/Resources excluding unnecessary files
 # - Copies translations, qml and quicklook PlugIns
 # - Copies i/plugins and i/lib/plugins to Contents/PlugIns
 
 # - Runs macdeployqt: macdeployqt is not built by default in ext_qt
 #     build by:
 #       cd ${BUILDROOT}/depbuild/ext_qt/ext_qt-prefix/src/ext_qt/qttools/src
 #       make sub-macdeployqt-all
 #       make sub-macdeployqt-install_subtargets
 #       make install
 
 #     the script changes dir to installation/bin to run macdeployqt as it can be buggy
 #     if not run from the same folder as the binary is on.
 
 # - Fix rpath from krita bin
 # - Find missing libraries from plugins and copy to Frameworks or plugins.
 #     This uses oTool iterative to find all unique libraries, then it searches each
 #     library fond in <kritadmg> folder, and if not found attempts to copy contents
 #     to the appropriate folder, either Frameworks (if frameworks is in namefile, or
 #         library has plugin isnot in path), or plugin if otherwise.
 
 # - Builds DMG
 #     Building DMG creates a new dmg with the contents of <kritadmg>
 #     mounts the dmg and sets the style for dmg.
 #     unmount
 #     Compress resulting dmg into krita_nightly-<gitsha>.dmg
 #     deletes temporary files.
 
 if test -z ${BUILDROOT}; then
     echo "ERROR: BUILDROOT env not set!"
     echo "\t Must point to the root of the buildfiles as stated in 3rdparty Readme"
     echo "exiting..."
     exit
 fi
 
 # print status messages
 print_msg() {
     printf "\e[32m${1}\e[0m\n" "${@:2}"
     # printf "%s\n" "${1}" >> ${OUPUT_LOG}
 }
 
 # print error
 print_error() {
     printf "\e[31m%s %s\e[0m\n" "Error:" "${1}"
 }
 
 get_script_dir() {
     script_source="${BASH_SOURCE[0]}"
     # go to target until finding root.
     while [ -L "${script_source}" ]; do
         script_target="$(readlink ${script_source})"
         if [[ "${script_source}" = /* ]]; then
             script_source="$script_target"
         else
             script_dir="$(dirname "${script_source}")"
             script_source="${script_dir}/${script_target}"
         fi
     done
     echo "$(dirname ${script_source})"
 }
 
 DMG_title="krita" #if changed krita.temp.dmg must be deleted manually
 SCRIPT_SOURCE_DIR="$(get_script_dir)"
 
 # There is some duplication between build and deploy scripts
 # a config env file could would be a nice idea.
 KIS_SRC_DIR=${BUILDROOT}/krita
 KIS_INSTALL_DIR=${BUILDROOT}/i
 KIS_BUILD_DIR=${BUILDROOT}/kisbuild # only used for getting git sha number
 KRITA_DMG=${BUILDROOT}/kritadmg
 KRITA_DMG_TEMPLATE=${BUILDROOT}/kritadmg-template
 
 export PATH=${KIS_INSTALL_DIR}/bin:$PATH
 
 # flags for OSX environment
 # We only support from 10.11 up
 export MACOSX_DEPLOYMENT_TARGET=10.11
 export QMAKE_MACOSX_DEPLOYMENT_TARGET=10.11
 
 
 print_usage () {
     printf "USAGE: 
   osxdeploy.sh [-s=<identity>] [-notarize-ac=<apple-account>] [-style=<style.txt>] [-bg=<background-image>]
 
     -s \t\t\t Code sign identity for codesign
 
     -notarize-ac \t Apple account name for notarization purposes
 \t\t\t script will attempt to get password from keychain, if fails provide one with
 \t\t\t the -notarize-pass option: To add a password run 
 
 \t\t\t   security add-generic-password -a \"AC_USERNAME\" -w <secret_password> -s \"AC_PASSWORD\"
 
     -notarize-pass \t If given, the Apple account password. Otherwise an attempt will be macdeployqt_exists
 \t\t\t to get the password from keychain using the account given in <notarize-ac> option.
 
     -asc-provider \t some AppleIds might need this option pass the <shortname>
 
     -style \t\t Style file defined from 'dmgstyle.sh' output
 
     -bg \t\t Set a background image for dmg folder.
 
     -name \t\t Set the DMG name output.
 
 \t\t\t osxdeploy needs an input image to attach to the dmg background
 \t\t\t image recommended size is at least 950x500
 "
 }
 
 # Attempt to detach previous mouted DMG
 if [[ -d "/Volumes/${DMG_title}" ]]; then
     echo "WARNING: Another Krita DMG is mounted!"
     echo "Attempting eject…"
     hdiutil detach "/Volumes/${DMG_title}"
     if [ $? -ne 0  ]; then
         exit
     fi
     echo "Success!"
 fi
 
 # -- Parse input args
 for arg in "${@}"; do
     if [ "${arg}" = -bg=* -a -f "${arg#*=}" ]; then
         DMG_validBG=0
         bg_filename=${arg#*=}
         echo "attempting to check background is valid jpg or png..."
         BG_FORMAT=$(sips --getProperty format ${bg_filename} | awk '{printf $2}')
 
         if [[ "png" = ${BG_FORMAT} || "jpeg" = ${BG_FORMAT} ]];then
             echo "valid image file"
             DMG_background=$(cd "$(dirname "${bg_filename}")"; pwd -P)/$(basename "${bg_filename}")
             DMG_validBG=1
             # check imageDPI
             BG_DPI=$(sips --getProperty dpiWidth ${DMG_background} | grep dpi | awk '{print $2}')
             if [[ $(echo "${BG_DPI} > 150" | bc -l) -eq 1 ]]; then
             printf "WARNING: image dpi has an effect on apparent size!
     Check dpi is adequate for screen display if image appears very small
     Current dpi is: %s\n" ${BG_DPI}
             fi
         fi
     fi
     # If string starts with -sign
     if [[ ${arg} = -s=* ]]; then
         CODE_SIGNATURE="${arg#*=}"
     fi
 
     if [[ ${arg} = -name=* ]]; then
         DMG_NAME="${arg#*=}"
     fi
 
     if [[ ${arg} = -notarize-ac=* ]]; then
         NOTARIZE_ACC="${arg#*=}"
     fi
 
     if [[ ${arg} = -notarize-pass=* ]]; then
         NOTARIZE_PASS="${arg#*=}"
     fi
 
     if [[ ${arg} = -style=* ]]; then
         style_filename="${arg#*=}"
         if [[ -f "${style_filename}" ]]; then
             DMG_STYLE="${style_filename}"
         fi
     fi
 
     if [[ ${arg} = -asc-provider=* ]]; then
         ASC_PROVIDER="${arg#*=}"
     fi
 
     if [[ ${arg} = "-h" || ${arg} = "--help" ]]; then
         print_usage
         exit
     fi
 done
 
 # -- Checks and messages
 
 ### PYTHONAttempt to find python_version
 local_PY_MAYOR_VERSION=$(python -c "import sys; print(sys.version_info[0])")
 local_PY_MINOR_VERSION=$(python -c "import sys; print(sys.version_info[1])")
 PY_VERSION="${local_PY_MAYOR_VERSION}.${local_PY_MINOR_VERSION}"
 
 print_msg "Detected Python %s" "${PY_VERSION}"
 
 ### Code Signature & NOTARIZATION
 NOTARIZE="false"
 if [[ -z "${CODE_SIGNATURE}" ]]; then
     echo "WARNING: No code signature provided, Code will not be signed"
 else
     print_msg "Code will be signed with %s" "${CODE_SIGNATURE}"
     ### NOTARIZATION
 
     if [[ -n "${NOTARIZE_ACC}" ]]; then
 
         ASC_PROVIDER_OP=""
         if [[ -n "${ASC_PROVIDER}" ]]; then
             ASC_PROVIDER_OP="--asc-provider ${ASC_PROVIDER}"
         fi
 
         if [[ -z "${NOTARIZE_PASS}" ]]; then
             NOTARIZE_PASS="@keychain:AC_PASSWORD"
         fi
 
         # check if we can perform notarization
-        xcrun altool --notarization-history 0 --username "${NOTARIZE_ACC}" --password "${NOTARIZE_PASS}" ${ASC_PROVIDER_OP}
+        xcrun altool --notarization-history 0 --username "${NOTARIZE_ACC}" --password "${NOTARIZE_PASS}" ${ASC_PROVIDER_OP} 1> /dev/null
 
         if [[ ${?} -eq 0 ]]; then
             NOTARIZE="true"
         else
             echo "No password given for notarization or AC_PASSWORD missig in keychain"
         fi
     fi
 fi
 
 if [[ ${NOTARIZE} = "true" ]]; then
     print_msg "Notarization checks complete, This build will be notarized"
 else
     echo "WARNING: Account information missing, Notarization will not be performed"
 fi
 
 ### STYLE for DMG
 if [[ ! ${DMG_STYLE} ]]; then
     DMG_STYLE="${SCRIPT_SOURCE_DIR}/default.style"
 fi
 
 print_msg "Using style from: %s" "${DMG_STYLE}"
 
 ### Background for DMG
 if [[ ${DMG_validBG} -eq 0 ]]; then
     echo "No jpg or png valid file detected!!"
     echo "Using default style"
     DMG_background="${SCRIPT_SOURCE_DIR}/krita_dmgBG.jpg"
 fi
 
 
 
 # Helper functions
 countArgs () {
     echo "${#}"
 }
 
 stringContains () {
     echo "$(grep "${2}" <<< "${1}")"
 }
 
 waiting_fixed() {
     local message="${1}"
     local waitTime=${2}
 
     for i in $(seq ${waitTime}); do
         sleep 1
         printf -v dots '%*s' ${i}
         printf -v spaces '%*s' $((${waitTime} - $i))
         printf "\r%s [%s%s]" "${message}" "${dots// /.}" "${spaces}"
     done
     printf "\n"
 }
 
 add_lib_to_list() {
     local llist=${2}
     if test -z "$(grep ${1##*/} <<< ${llist})" ; then
         local llist="${llist} ${1##*/} "
     fi
     echo "${llist}"
 }
 
 # Find all @rpath and Absolute to buildroot path libs
 # Add to libs_used
 # converts absolute buildroot path to @rpath
 find_needed_libs () {
     # echo "Analyzing libraries with oTool..." >&2
     local libs_used="" # input lib_lists founded
 
     for libFile in ${@}; do
         if test -z "$(file ${libFile} | grep 'Mach-O')" ; then
             # echo "skipping ${libFile}" >&2
             continue
         fi
 
         oToolResult=$(otool -L ${libFile} | awk '{print $1}')
         resultArray=(${oToolResult}) # convert to array
 
         for lib in ${resultArray[@]:1}; do
             if test "${lib:0:1}" = "@"; then
                 local libs_used=$(add_lib_to_list "${lib}" "${libs_used}")
             fi
             if [[ "${lib:0:${#BUILDROOT}}" = "${BUILDROOT}" ]]; then
                 printf "Fixing %s: %s\n" "${libFile#${KRITA_DMG}/}" "${lib##*/}" >&2
                 if [[ "${lib##*/}" = "${libFile##*/}" ]]; then
                     install_name_tool -id ${lib##*/} "${libFile}"
                 else
                     install_name_tool -change ${lib} "@rpath/${lib##*${BUILDROOT}/i/lib/}" "${libFile}"
                     local libs_used=$(add_lib_to_list "${lib}" "${libs_used}")
                 fi
             fi
         done
     done
     echo "${libs_used}" # return updated list
 }
 
 find_missing_libs (){
     # echo "Searching for missing libs on deployment folders…" >&2
     local libs_missing=""
     for lib in ${@}; do
         if test -z "$(find ${KRITA_DMG}/krita.app/Contents/ -name ${lib})"; then
             # echo "Adding ${lib} to missing libraries." >&2
             libs_missing="${libs_missing} ${lib}"
         fi
     done
     echo "${libs_missing}"
 }
 
 copy_missing_libs () {
     for lib in ${@}; do
         result=$(find -L "${BUILDROOT}/i" -name "${lib}")
 
         if test $(countArgs ${result}) -eq 1; then
             if [ "$(stringContains "${result}" "plugin")" ]; then
                 cp -pv ${result} ${KRITA_DMG}/krita.app/Contents/PlugIns/
                 krita_findmissinglibs "${KRITA_DMG}/krita.app/Contents/PlugIns/${result##*/}"
             else
                 cp -pv ${result} ${KRITA_DMG}/krita.app/Contents/Frameworks/
                 krita_findmissinglibs "${KRITA_DMG}/krita.app/Contents/Frameworks/${result##*/}"
             fi
         else
             echo "${lib} might be a missing framework"
             if [ "$(stringContains "${result}" "framework")" ]; then
                 echo "copying framework ${BUILDROOT}/i/lib/${lib}.framework to dmg"
                 # rsync only included ${lib} Resources Versions
                 rsync -priul ${BUILDROOT}/i/lib/${lib}.framework/${lib} ${KRITA_DMG}/krita.app/Contents/Frameworks/${lib}.framework/
                 rsync -priul ${BUILDROOT}/i/lib/${lib}.framework/Resources ${KRITA_DMG}/krita.app/Contents/Frameworks/${lib}.framework/
                 rsync -priul ${BUILDROOT}/i/lib/${lib}.framework/Versions ${KRITA_DMG}/krita.app/Contents/Frameworks/${lib}.framework/
                 krita_findmissinglibs "$(find "${KRITA_DMG}/krita.app/Contents/Frameworks/${lib}.framework/" -type f -perm 755)"
             fi
         fi
     done
 }
 
 krita_findmissinglibs() {
     neededLibs=$(find_needed_libs "${@}")
     missingLibs=$(find_missing_libs ${neededLibs})
 
     if test $(countArgs ${missingLibs}) -gt 0; then
         printf "Found missing libs: %s\n" "${missingLibs}"
         copy_missing_libs ${missingLibs}
     fi
 }
 
 strip_python_dmginstall() {
     # reduce size of framework python
     # Removes tests, installers, pyenv, distutils
     echo "Removing unnecessary files from Python.Framework to be packaged..."
     PythonFrameworkBase="${KRITA_DMG}/krita.app/Contents/Frameworks/Python.framework"
 
     cd "${PythonFrameworkBase}"
     find . -name "test*" -type d | xargs rm -rf
     find "${PythonFrameworkBase}/Versions/${PY_VERSION}/bin" -not -name "python*" \( -type f -or -type l \) | xargs rm -f
     cd "${PythonFrameworkBase}/Versions/${PY_VERSION}/lib/python${PY_VERSION}"
     rm -rf distutils tkinter ensurepip venv lib2to3 idlelib turtledemo
 
     cd "${PythonFrameworkBase}/Versions/${PY_VERSION}/Resources"
     rm -rf Python.app
 }
 
 # Some libraries require r_path to be removed
 # we must not apply delete rpath globally
 delete_install_rpath() {
     xargs -P4 -I FILE install_name_tool -delete_rpath "${BUILDROOT}/i/lib" FILE 2> "${BUILDROOT}/deploy_error.log"
 }
 
 # Remove any missing rpath poiting to BUILDROOT
 libs_clean_rpath () {
     for libFile in ${@}; do
         rpath=$(otool -l "${libFile}" | grep "${BUILDROOT}/i/lib" | awk '{$1=$1;print $2}')
         if [[ -n "${rpath}" ]]; then
             echo "removed rpath _${rpath}_ from ${libFile}"
             install_name_tool -delete_rpath "${rpath}" "${libFile}"
         fi
     done
 }
 
 fix_python_framework() {
     # Fix python.framework rpath and slims down installation
     PythonFrameworkBase="${KRITA_DMG}/krita.app/Contents/Frameworks/Python.framework"
 
     # Fix permissions
     find "${PythonFrameworkBase}" -name "*.so" | xargs -P4 -I FILE chmod a+x FILE 2> "${BUILDROOT}/deploy_error.log"
     cd "${PythonFrameworkBase}/Versions/${PY_VERSION}/lib/python${PY_VERSION}"
     chmod a+x pydoc.py
 
     # Fix main library
     pythonLib="${PythonFrameworkBase}/Python"
     install_name_tool -id "${pythonLib##*/}" "${pythonLib}"
     install_name_tool -add_rpath @loader_path/../../../ "${pythonLib}" 2> /dev/null
     install_name_tool -change @loader_path/../../../../libintl.9.dylib @loader_path/../../../libintl.9.dylib "${pythonLib}"
 
     # Fix all executables
     install_name_tool -add_rpath @executable_path/../../../../../../../ "${PythonFrameworkBase}/Versions/Current/Resources/Python.app/Contents/MacOS/Python"
     install_name_tool -change "${KIS_INSTALL_DIR}/lib/Python.framework/Versions/${PY_VERSION}/Python" @executable_path/../../../../../../Python "${PythonFrameworkBase}/Versions/Current/Resources/Python.app/Contents/MacOS/Python"
     install_name_tool -add_rpath @executable_path/../../../../ "${PythonFrameworkBase}/Versions/Current/bin/python${PY_VERSION}"
     install_name_tool -add_rpath @executable_path/../../../../ "${PythonFrameworkBase}/Versions/Current/bin/python${PY_VERSION}m"
 
     # Fix rpaths from Python.Framework
-    find ${PythonFrameworkBase} -type f -perm 755 | delete_install_rpath
+    find "${PythonFrameworkBase}" -type f -perm 755 | delete_install_rpath
     find "${PythonFrameworkBase}/Versions/Current/site-packages/PyQt5" -type f -name "*.so" | delete_install_rpath
 }
 
 # Checks for macdeployqt
 # If not present attempts to install
 # If it fails shows an informatve message
 # (For now, macdeployqt is fundamental to deploy)
 macdeployqt_exists() {
     printf "Checking for macdeployqt...  "
 
     if [[ ! -e "${KIS_INSTALL_DIR}/bin/macdeployqt" ]]; then
         printf "Not Found!\n"
         printf "Attempting to install macdeployqt\n"
 
         cd ${BUILDROOT}/depbuild/ext_qt/ext_qt-prefix/src/ext_qt/qttools/src
         make sub-macdeployqt-all
         make sub-macdeployqt-install_subtargets
         make install
 
         if [[ ! -e "${KIS_INSTALL_DIR}/bin/macdeployqt" ]]; then
         printf "
 ERROR: Failed to install macdeployqt!
 
     Compile and install from qt source directory
     Source code to build could be located in qttools/src in qt source dir:
 
         ${BUILDROOT}/depbuild/ext_qt/ext_qt-prefix/src/ext_qt/qttools/src
 
     From the source dir, build and install:
 
         make sub-macdeployqt-all
         make sub-macdeployqt-install_subtargets
         make install
 "
         printf "\nexiting...\n"
         exit
         else
             echo "Done!"
         fi
     else
         echo "Found!"
     fi
 }
 
 krita_deploy () {
     # check for macdeployqt
     macdeployqt_exists
 
     cd ${BUILDROOT}
     # Update files in krita.app
     echo "Deleting previous kritadmg run..."
     rm -rf ./krita.dmg ${KRITA_DMG}
     # Copy new builtFiles
     echo "Preparing ${KRITA_DMG} for deployment..."
 
     echo "Copying krita.app..."
     mkdir "${KRITA_DMG}"
 
     rsync -prul ${KIS_INSTALL_DIR}/bin/krita.app ${KRITA_DMG}
 
     mkdir -p ${KRITA_DMG}/krita.app/Contents/PlugIns
     mkdir -p ${KRITA_DMG}/krita.app/Contents/Frameworks
 
     echo "Copying share..."
     # Deletes old copies of translation and qml to be recreated
     cd ${KIS_INSTALL_DIR}/share/
     rsync -prul --delete ./ \
             --exclude krita_SRCS.icns \
             --exclude aclocal \
             --exclude doc \
             --exclude ECM \
             --exclude eigen3 \
             --exclude emacs \
             --exclude gettext \
             --exclude gettext-0.19.8 \
             --exclude info \
             --exclude kf5 \
             --exclude kservices5 \
             --exclude man \
             --exclude ocio \
             --exclude pkgconfig \
             --exclude mime \
             --exclude translations \
             --exclude qml \
             ${KRITA_DMG}/krita.app/Contents/Resources
 
     cd ${BUILDROOT}
 
     echo "Copying translations..."
     rsync -prul ${KIS_INSTALL_DIR}/translations/ \
             ${KRITA_DMG}/krita.app/Contents/Resources/translations
 
     echo "Copying kritaquicklook..."
     mkdir -p ${KRITA_DMG}/krita.app/Contents/Library/QuickLook
     rsync -prul ${KIS_INSTALL_DIR}/plugins/kritaquicklook.qlgenerator ${KRITA_DMG}/krita.app/Contents/Library/QuickLook
 
     cd ${KRITA_DMG}/krita.app/Contents
     ln -shF Resources share
 
     echo "Copying qml..."
     rsync -prul ${KIS_INSTALL_DIR}/qml Resources/qml
 
     echo "Copying plugins..."
     # exclude kritaquicklook.qlgenerator/
     cd ${KIS_INSTALL_DIR}/plugins/
     rsync -prul --delete --delete-excluded ./ \
         --exclude kritaquicklook.qlgenerator \
         ${KRITA_DMG}/krita.app/Contents/PlugIns
 
     cd ${BUILDROOT}
     rsync -prul ${KIS_INSTALL_DIR}/lib/kritaplugins/ ${KRITA_DMG}/krita.app/Contents/PlugIns
     
     # rsync -prul {KIS_INSTALL_DIR}/lib/libkrita* Frameworks/
 
     # To avoid errors macdeployqt must be run from bin location
     # ext_qt will not build macdeployqt by default so it must be build manually
     #   cd ${BUILDROOT}/depbuild/ext_qt/ext_qt-prefix/src/ext_qt/qttools/src
     #   make sub-macdeployqt-all
     #   make sub-macdeployqt-install_subtargets
     #   make install
     echo "Running macdeployqt..."
     cd ${KIS_INSTALL_DIR}/bin
     ./macdeployqt ${KRITA_DMG}/krita.app \
         -verbose=0 \
         -executable=${KRITA_DMG}/krita.app/Contents/MacOS/krita \
         -libpath=${KIS_INSTALL_DIR}/lib \
         -qmldir=${KIS_INSTALL_DIR}/qml \
         # -extra-plugins=${KIS_INSTALL_DIR}/lib/kritaplugins \
         # -extra-plugins=${KIS_INSTALL_DIR}/lib/plugins \
         # -extra-plugins=${KIS_INSTALL_DIR}/plugins
 
     cd ${BUILDROOT}
     echo "macdeployqt done!"
 
     echo "Copying python..."
     # Copy this framework last!
     # It is best that macdeployqt does not modify Python.framework
     # folders with period in name are treated as Frameworks for codesign
     rsync -prul ${KIS_INSTALL_DIR}/lib/Python.framework ${KRITA_DMG}/krita.app/Contents/Frameworks/
     rsync -prul ${KIS_INSTALL_DIR}/lib/krita-python-libs ${KRITA_DMG}/krita.app/Contents/Frameworks/
     # change perms on Python to allow header change
     chmod +w ${KRITA_DMG}/krita.app/Contents/Frameworks/Python.framework/Python
     
     fix_python_framework
     strip_python_dmginstall
 
     # fix python pyc
     # precompile all pyc so the dont alter signature
     echo "Precompiling all python files..."
     cd ${KRITA_DMG}/krita.app
     ${KIS_INSTALL_DIR}/bin/python -m compileall . &> /dev/null
 
     install_name_tool -delete_rpath @loader_path/../../../../lib ${KRITA_DMG}/krita.app/Contents/MacOS/krita
     rm -rf ${KRITA_DMG}/krita.app/Contents/PlugIns/kf5/org.kde.kwindowsystem.platforms
 
     # Fix permissions
     find "${KRITA_DMG}/krita.app/Contents" -type f -name "*.dylib" -or -name "*.so" | xargs -P4 -I FILE chmod a+x FILE
     find "${KRITA_DMG}/krita.app/Contents/Resources/applications" -name "*.desktop" | xargs -P4 -I FILE chmod a-x FILE
 
     # repair krita for plugins
     printf "Searching for missing libraries\n"
     krita_findmissinglibs $(find ${KRITA_DMG}/krita.app/Contents -type f -perm 755 -or -name "*.dylib" -or -name "*.so")
 
     printf "removing absolute or broken linksys, if any\n"
     find "${KRITA_DMG}/krita.app/Contents" -type l \( -lname "/*" -or -not -exec test -e {} \; \) -print | xargs rm
 
     printf "clean any left over rpath\n"
     libs_clean_rpath $(find "${KRITA_DMG}/krita.app/Contents" -type f -perm 755 -or -name "*.dylib" -or -name "*.so")
+    find "${KRITA_DMG}/krita.app/Contents/Frameworks/" -type f -name "lib*" | delete_install_rpath
 
     echo "Done!"
 
 }
 
 
 # helper to define function only once
 batch_codesign() {
     xargs -P4 -I FILE codesign --options runtime --timestamp -f -s "${CODE_SIGNATURE}" --entitlements "${KIS_SRC_DIR}/packaging/macos/entitlements.plist" FILE
 }
 # Code sign must be done as recommended by apple "sign code inside out in individual stages"
 signBundle() {
     cd ${KRITA_DMG}
 
     # sign Frameworks and libs
     cd ${KRITA_DMG}/krita.app/Contents/Frameworks
     # remove debug version as both versions can't be signed.
     rm ${KRITA_DMG}/krita.app/Contents/Frameworks/QtScript.framework/Versions/Current/QtScript_debug
     find . -type f -perm 755 -or -name "*.dylib" -or -name "*.so" | batch_codesign
     find . -type d -name "*.framework" | xargs printf "%s/Versions/Current\n" | batch_codesign
 
     # Sign all other files in Framework (needed)
     # there are many files in python do we need to sign them all?
     find krita-python-libs -type f | batch_codesign
     # find python -type f | batch_codesign
 
     # Sign only libraries and plugins
     cd ${KRITA_DMG}/krita.app/Contents/PlugIns
     find . -type f | batch_codesign
 
     cd ${KRITA_DMG}/krita.app/Contents/Library/QuickLook
     printf "kritaquicklook.qlgenerator" | batch_codesign
 
     # It is recommended to sign every Resource file
     cd ${KRITA_DMG}/krita.app/Contents/Resources
     find . -type f | batch_codesign
 
     #Finally sign krita and krita.app
     printf "${KRITA_DMG}/krita.app/Contents/MacOS/krita" | batch_codesign
     printf "${KRITA_DMG}/krita.app" | batch_codesign
 }
 
 # Notarize build on macOS servers
 # based on https://github.com/Beep6581/RawTherapee/blob/6fa533c40b34dec527f1176d47cc6c683422a73f/tools/osx/macosx_bundle.sh#L225-L250
 notarize_build() {
     local NOT_SRC_DIR=${1}
     local NOT_SRC_FILE=${2}
 
     if [[ ${NOTARIZE} = "true" ]]; then
         printf "performing notarization of %s\n" "${2}"
         cd "${NOT_SRC_DIR}"
 
         ditto -c -k --sequesterRsrc --keepParent "${NOT_SRC_FILE}" "${BUILDROOT}/tmp_notarize/${NOT_SRC_FILE}.zip"
 
         # echo "xcrun altool --notarize-app --primary-bundle-id \"org.krita\" --username \"${NOTARIZE_ACC}\" --password \"${NOTARIZE_PASS}\" --file \"${BUILDROOT}/tmp_notarize/${NOT_SRC_FILE}.zip\""
         local altoolResponse="$(xcrun altool --notarize-app --primary-bundle-id "org.krita" --username "${NOTARIZE_ACC}" --password "${NOTARIZE_PASS}" ${ASC_PROVIDER_OP} --file "${BUILDROOT}/tmp_notarize/${NOT_SRC_FILE}.zip" 2>&1)"
 
         if [[ -n "$(grep 'Error' <<< ${altoolResponse})" ]]; then
             printf "ERROR: xcrun altool exited with the following error! \n\n%s\n\n" "${altoolResponse}"
             printf "This could mean there is an error in AppleID authentication!\n"
             printf "aborting notarization\n"
             NOTARIZE="false"
             return
         else
             printf "Response:\n\n%s\n\n" "${altoolResponse}"
         fi
 
         local uuid="$(grep 'RequestUUID' <<< ${altoolResponse} | awk '{ print $NF }')"
         echo "RequestUUID = ${uuid}" # Display identifier string
 
         waiting_fixed "Waiting to retrieve notarize status" 30
 
         while true ; do
             fullstatus=$(xcrun altool --notarization-info "${uuid}" --username "${NOTARIZE_ACC}" --password "${NOTARIZE_PASS}" ${ASC_PROVIDER_OP} 2>&1)  # get the status
             notarize_status=`echo "${fullstatus}" | grep 'Status\:' | awk '{ print $2 }'`
             echo "${fullstatus}"
             if [[ "${notarize_status}" = "success" ]]; then
                 xcrun stapler staple "${NOT_SRC_FILE}"   #staple the ticket
                 xcrun stapler validate -v "${NOT_SRC_FILE}"
                 print_msg "Notarization success!"
                 break
             elif [[ "${notarize_status}" = "in" ]]; then
                 waiting_fixed "Notarization still in progress, sleeping for 20 seconds and trying again" 20
             else
                 echo "Notarization failed! full status below"
                 echo "${fullstatus}"
                 exit 1
             fi
         done
     fi
 }
 
 createDMG () {
     printf "Creating of dmg with contents of %s...\n" "${KRITA_DMG}"
     cd ${BUILDROOT}
     DMG_size=700
 
     if [[ -z "${DMG_NAME}" ]]; then
         # Add git version number
         GIT_SHA=$(grep "#define KRITA_GIT_SHA1_STRING" ${KIS_BUILD_DIR}/libs/version/kritagitversion.h | awk '{gsub(/"/, "", $3); printf $3}')
         DMG_NAME="krita-nightly_${GIT_SHA}.dmg"
     else
         DMG_NAME="${DMG_NAME}.dmg"
     fi
 
     ## Build dmg from folder
 
     # create dmg on local system
     # usage of -fsargs minimze gaps at front of filesystem (reduce size)
     hdiutil create -srcfolder "${KRITA_DMG}" -volname "${DMG_title}" -fs HFS+ \
         -fsargs "-c c=64,a=16,e=16" -format UDRW -size ${DMG_size}m krita.temp.dmg
 
     # Next line is only useful if we have a dmg as a template!
     # previous hdiutil must be uncommented
     # cp krita-template.dmg krita.dmg
     device=$(hdiutil attach -readwrite -noverify -noautoopen "krita.temp.dmg" | egrep '^/dev/' | sed 1q | awk '{print $1}')
 
     # rsync -priul --delete ${KRITA_DMG}/krita.app "/Volumes/${DMG_title}"
 
     # Set style for dmg
     if [[ ! -d "/Volumes/${DMG_title}/.background" ]]; then
         mkdir "/Volumes/${DMG_title}/.background"
     fi
     cp -v ${DMG_background} "/Volumes/${DMG_title}/.background/"
 
     mkdir "/Volumes/${DMG_title}/Terms of Use"
     cp -v "${KIS_SRC_DIR}/packaging/macos/Terms_of_use.rtf" "/Volumes/${DMG_title}/Terms of Use/"
     ln -s "/Applications" "/Volumes/${DMG_title}/Applications"
 
     ## Apple script to set style
     style="$(<"${DMG_STYLE}")"
     printf "${style}" "${DMG_title}" "${DMG_background##*/}" | osascript
 
     #Set Icon for DMG
     cp -v "${SCRIPT_SOURCE_DIR}/KritaIcon.icns" "/Volumes/${DMG_title}/.VolumeIcon.icns"
     SetFile -a C "/Volumes/${DMG_title}"
     
     chmod -Rf go-w "/Volumes/${DMG_title}"
 
     # ensure all writing operations to dmg are over
     sync
 
     hdiutil detach $device
     hdiutil convert "krita.temp.dmg" -format UDZO -imagekey -zlib-level=9 -o krita-out.dmg
     
 
     mv krita-out.dmg ${DMG_NAME}
     echo "moved krita-out.dmg to ${DMG_NAME}"
     rm krita.temp.dmg
 
     if [[ -n "${CODE_SIGNATURE}" ]]; then
         printf "${DMG_NAME}" | batch_codesign
     fi
 
     notarize_build "${BUILDROOT}" "${DMG_NAME}"
 
     echo "dmg done!"
 }
 
 #######################
 # Program starts!!
 ########################
 # Run deploy command, installation is assumed to exist in BUILDROOT/i
 krita_deploy
 
 # Code sign krita.app if signature given
 if [[ -n "${CODE_SIGNATURE}" ]]; then
     signBundle
 fi
 
 # notarize app
 notarize_build "${KRITA_DMG}" krita.app
 
 # Create DMG from files inside ${KRITA_DMG} folder
 createDMG
 
 if [[ "${NOTARIZE}" = "false" ]]; then
     macosVersion="$(sw_vers | grep ProductVersion | awk '
        BEGIN { FS = "[ .\t]" }
              { print $3}
     ')"
     if (( ${macosVersion} == 15 )); then
         print_error "Build not notarized! Needed for macOS versions above 10.14"
     fi
 fi