diff --git a/libs/image/KisAslStorage.cpp b/libs/image/KisAslStorage.cpp
index 5c1d6f95d2..136deafbd8 100644
--- a/libs/image/KisAslStorage.cpp
+++ b/libs/image/KisAslStorage.cpp
@@ -1,195 +1,201 @@
 /*
  * Copyright (C) 2018 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) 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 "KisAslStorage.h"
 #include <KisResourceStorage.h>
+#include <KisResourceLoaderRegistry.h>
+#include <KisResourceLoader.h>
+#include <kis_psd_layer_style.h>
 
 #include <QFileInfo>
 
 struct KisAslStorageStaticRegistrar {
     KisAslStorageStaticRegistrar() {
         KisStoragePluginRegistry::instance()->addStoragePluginFactory(KisResourceStorage::StorageType::AdobeStyleLibrary, new KisStoragePluginFactory<KisAslStorage>());
     }
 };
 static KisAslStorageStaticRegistrar s_registrar;
 
 
 class AslTagIterator : public KisResourceStorage::TagIterator
 {
 public:
 
     AslTagIterator(const QString &location, const QString &resourceType)
         : m_location(location)
         , m_resourceType(resourceType)
     {}
 
     bool hasNext() const override {return false; }
     void next() override {}
 
     QString url() const override { return QString(); }
     QString name() const override { return QString(); }
     QString comment() const override {return QString(); }
     KisTagSP tag() const override { return 0; }
 
 private:
 
     QString m_location;
     QString m_resourceType;
 
 };
 
 class AslIterator : public KisResourceStorage::ResourceIterator
 {
 
 private:
 
     QString m_filename;
     QSharedPointer<KisAslLayerStyleSerializer> m_aslSerializer;
     bool m_isLoaded;
     QHash<QString, KoPatternSP> m_patterns;
     QVector<KisPSDLayerStyleSP> m_styles;
     QScopedPointer<QHashIterator<QString, KoPatternSP>> m_patternsIterator;
     QScopedPointer<QVectorIterator<KisPSDLayerStyleSP>> m_stylesIterator;
     QString m_currentType;
     KoResourceSP m_currentResource;
     QString m_currentUuid;
 
 public:
 
     AslIterator(QSharedPointer<KisAslLayerStyleSerializer> aslSerializer, const QString& filename)
         : m_filename(filename)
         , m_aslSerializer(aslSerializer)
         , m_isLoaded(false)
     {
-
     }
 
     bool hasNext() const override
     {
         if (!m_isLoaded) {
             if (!m_aslSerializer->isInitialized()) {
                 m_aslSerializer->readFromFile(m_filename);
             }
 
             const_cast<AslIterator*>(this)->m_isLoaded = true;
             const_cast<AslIterator*>(this)->m_patterns = m_aslSerializer->patterns();
             const_cast<AslIterator*>(this)->m_styles = m_aslSerializer->styles();
 
             const_cast<AslIterator*>(this)->m_patternsIterator.reset(new QHashIterator<QString, KoPatternSP>(m_patterns));
             const_cast<AslIterator*>(this)->m_stylesIterator.reset(new QVectorIterator<KisPSDLayerStyleSP>(m_styles));
 
             QHash<QString, KisPSDLayerStyleSP> layerStyles = const_cast<AslIterator*>(this)->m_aslSerializer->stylesHash();
         }
         return m_patternsIterator->hasNext() ? true : m_stylesIterator->hasNext();
     }
     void next() override
     {
         if (m_patternsIterator->hasNext()) {
             m_currentType = ResourceType::Patterns;
             m_patternsIterator->next();
             KoPatternSP currentPattern = m_patternsIterator->value();
             m_currentResource = currentPattern;
             m_currentUuid = m_patternsIterator->value()->filename();
         }
         else if (m_stylesIterator->hasNext()) {
             m_currentType = ResourceType::LayerStyles;
             KisPSDLayerStyleSP currentLayerStyle = m_stylesIterator->next();
             m_currentResource = currentLayerStyle;
             m_currentUuid = currentLayerStyle->filename();
         }
     }
 
     QString url() const override
     {
         if (m_currentResource.isNull()) {
             return QString();
         }
         return m_currentUuid;
     }
 
     QString type() const override
     {
         return m_currentResource.isNull() ? QString() : m_currentType;
     }
 
     QDateTime lastModified() const override { return QDateTime(); }
 
 
     /// This only loads the resource when called
     KoResourceSP resource() const override
     {
         return m_currentResource;
     }
 };
 
 KisAslStorage::KisAslStorage(const QString &location)
     : KisStoragePlugin(location)
     , m_aslSerializer(new KisAslLayerStyleSerializer())
 {
+    KisResourceLoaderRegistry::instance()->add(new KisResourceLoader<KisPSDLayerStyle>(ResourceType::LayerStyles,
+                                                                                       "",
+                                                                                       "",
+                                                                                       QStringList() << "application/x-photoshop-style"));
 
 }
 
 KisAslStorage::~KisAslStorage()
 {
 
 }
 
 KisResourceStorage::ResourceItem KisAslStorage::resourceItem(const QString &url)
 {
     KisResourceStorage::ResourceItem item;
     item.url = url;
     item.folder = location();
     item.resourceType = url.contains("pattern") ? ResourceType::Patterns : ResourceType::LayerStyles;
     item.lastModified = QFileInfo(location()).lastModified();
     return item;
 }
 
 KoResourceSP KisAslStorage::resource(const QString &url)
 {
     if (!m_aslSerializer->isInitialized()) {
         m_aslSerializer->readFromFile(location());
     }
     int indexOfUnderscore = url.lastIndexOf("_");
     QString realUuid = url;
     realUuid.remove(indexOfUnderscore, url.length() - indexOfUnderscore); // remove _pattern or _style added in iterator
     if (url.contains("pattern")) {
         QHash<QString, KoPatternSP> patterns = m_aslSerializer->patterns();
 
         if (patterns.contains(realUuid)) {
             return patterns[realUuid];
         }
     }
     else {
         QHash<QString, KisPSDLayerStyleSP> styles = m_aslSerializer->stylesHash();
         if (styles.contains(realUuid)) {
             return styles[realUuid];
         }
     }
     return 0;
 }
 
 QSharedPointer<KisResourceStorage::ResourceIterator> KisAslStorage::resources(const QString &/*resourceType*/)
 {
     return QSharedPointer<KisResourceStorage::ResourceIterator>(new AslIterator(m_aslSerializer, location()));
 }
 
 QSharedPointer<KisResourceStorage::TagIterator> KisAslStorage::tags(const QString &resourceType)
 {
     return QSharedPointer<KisResourceStorage::TagIterator>(new AslTagIterator(location(), resourceType));
 }
diff --git a/libs/image/kis_psd_layer_style.cpp b/libs/image/kis_psd_layer_style.cpp
index 50e2d64b91..d9c80b41a3 100644
--- a/libs/image/kis_psd_layer_style.cpp
+++ b/libs/image/kis_psd_layer_style.cpp
@@ -1,325 +1,325 @@
 /*
  *  Copyright (c) 2014 Boudewijn Rempt <boud@valdyas.org>
  *
  *  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.
  */
 #include "kis_psd_layer_style.h"
 
 #include <QIODevice>
 #include <QUuid>
 
 #include <psd.h>
 #include <psd_utils.h>
 
 #include <klocalizedstring.h>
 
 #include "kis_global.h"
 
 
 struct Q_DECL_HIDDEN KisPSDLayerStyle::Private
 {
     Private()
         : version(-1)
         , effectEnabled(true)
     {}
 
     Private(const Private &rhs)
         : name(rhs.name),
           uuid(rhs.uuid),
           version(rhs.version),
           effectEnabled(rhs.effectEnabled),
           context(rhs.context),
           drop_shadow(rhs.drop_shadow),
           inner_shadow(rhs.inner_shadow),
           outer_glow(rhs.outer_glow),
           inner_glow(rhs.inner_glow),
           bevel_emboss(rhs.bevel_emboss),
           satin(rhs.satin),
           color_overlay(rhs.color_overlay),
           gradient_overlay(rhs.gradient_overlay),
           pattern_overlay(rhs.pattern_overlay),
           stroke(rhs.stroke)
     {}
 
     Private operator=(const Private &rhs)
     {
         if (this != &rhs) {
             name = rhs.name;
             uuid = rhs.uuid;
             version = rhs.version;
             effectEnabled = rhs.effectEnabled;
             context = rhs.context;
             drop_shadow = rhs.drop_shadow;
             inner_shadow = rhs.inner_shadow;
             outer_glow = rhs.outer_glow;
             inner_glow = rhs.inner_glow;
             bevel_emboss = rhs.bevel_emboss;
             satin = rhs.satin;
             color_overlay = rhs.color_overlay;
             gradient_overlay = rhs.gradient_overlay;
             pattern_overlay = rhs.pattern_overlay;
             stroke = rhs.stroke;
         }
 
         return *this;
     }
 
     QString name;
     QUuid uuid;
     quint16 version;
     bool effectEnabled;
     psd_layer_effects_context context;
     psd_layer_effects_drop_shadow drop_shadow;
     psd_layer_effects_inner_shadow inner_shadow;
     psd_layer_effects_outer_glow outer_glow;
     psd_layer_effects_inner_glow inner_glow;
     psd_layer_effects_bevel_emboss bevel_emboss;
     psd_layer_effects_satin satin;
     psd_layer_effects_color_overlay color_overlay;
     psd_layer_effects_gradient_overlay gradient_overlay;
     psd_layer_effects_pattern_overlay pattern_overlay;
     psd_layer_effects_stroke stroke;
 };
 
-KisPSDLayerStyle::KisPSDLayerStyle()
-    : KoResource(QString())
+KisPSDLayerStyle::KisPSDLayerStyle(const QString &name)
+    : KoResource(name)
     , d(new Private())
 {
     d->name = i18n("Unnamed");
     d->version = 7;
 }
 
 KisPSDLayerStyle::~KisPSDLayerStyle()
 {
     delete d;
 }
 
 KisPSDLayerStyle::KisPSDLayerStyle(const KisPSDLayerStyle &rhs)
     : KoResource(QString())
     , d(new Private(*rhs.d))
 {
     setValid(valid());
 }
 
 KisPSDLayerStyle KisPSDLayerStyle::operator=(const KisPSDLayerStyle &rhs)
 {
     if (this != &rhs) {
         *d = *rhs.d;
     }
     return *this;
 }
 
 bool KisPSDLayerStyle::isEnabled() const
 {
     return d->effectEnabled;
 }
 
 void KisPSDLayerStyle::setEnabled(bool value)
 {
     d->effectEnabled = value;
 }
 
 KoResourceSP KisPSDLayerStyle::clone() const
 {
     return toQShared(new KisPSDLayerStyle(*this)).dynamicCast<KoResource>();
 }
 
 void KisPSDLayerStyle::clear()
 {
     *d = Private();
 }
 
 bool KisPSDLayerStyle::isEmpty() const
 {
     return !(d->drop_shadow.effectEnabled() ||
              d->inner_shadow.effectEnabled() ||
              d->outer_glow.effectEnabled() ||
              d->inner_glow.effectEnabled() ||
              d->bevel_emboss.effectEnabled() ||
              d->satin.effectEnabled() ||
              d->color_overlay.effectEnabled() ||
              d->gradient_overlay.effectEnabled() ||
              d->pattern_overlay.effectEnabled() ||
              d->stroke.effectEnabled());
 }
 
 QString KisPSDLayerStyle::name() const
 {
     return d->name;
 }
 
 void KisPSDLayerStyle::setName(const QString &value)
 {
     d->name = value;
     dynamic_cast<KoResource*>(this)->setName(value);
 }
 
 QUuid KisPSDLayerStyle::uuid() const
 {
     if (d->uuid.isNull()) {
         d->uuid = QUuid::createUuid();
     }
 
     return d->uuid;
 }
 
 void KisPSDLayerStyle::setUuid(const QUuid &value) const
 {
     d->uuid = value;
 }
 
 QString KisPSDLayerStyle::psdUuid() const
 {
     return uuid().toString().mid(1, 36);
 }
 
 void KisPSDLayerStyle::setPsdUuid(const QString &value) const
 {
     setUuid(QUuid(QString("{%1}").arg(value)));
 }
 
 bool KisPSDLayerStyle::load()
 {
     return true;
 }
 
 bool KisPSDLayerStyle::loadFromDevice(QIODevice *dev)
 {
     Q_UNUSED(dev);
     return true;
 }
 
 bool KisPSDLayerStyle::save()
 {
     return true;
 }
 
 bool KisPSDLayerStyle::saveToDevice(QIODevice *dev) const
 {
     Q_UNUSED(dev);
     return true;
 }
 
 
 
 const psd_layer_effects_context* KisPSDLayerStyle::context() const
 {
     return &d->context;
 }
 
 const psd_layer_effects_drop_shadow* KisPSDLayerStyle::dropShadow() const
 {
     return &d->drop_shadow;
 }
 
 const psd_layer_effects_inner_shadow* KisPSDLayerStyle::innerShadow() const
 {
     return &d->inner_shadow;
 }
 
 const psd_layer_effects_outer_glow* KisPSDLayerStyle::outerGlow() const
 {
     return &d->outer_glow;
 }
 
 const psd_layer_effects_inner_glow* KisPSDLayerStyle::innerGlow() const
 {
     return &d->inner_glow;
 }
 
 const psd_layer_effects_satin* KisPSDLayerStyle::satin() const
 {
     return &d->satin;
 }
 
 const psd_layer_effects_color_overlay* KisPSDLayerStyle::colorOverlay() const
 {
     return &d->color_overlay;
 }
 
 const psd_layer_effects_gradient_overlay* KisPSDLayerStyle::gradientOverlay() const
 {
     return &d->gradient_overlay;
 }
 
 const psd_layer_effects_pattern_overlay* KisPSDLayerStyle::patternOverlay() const
 {
     return &d->pattern_overlay;
 }
 
 const psd_layer_effects_stroke* KisPSDLayerStyle::stroke() const
 {
     return &d->stroke;
 }
 
 const psd_layer_effects_bevel_emboss* KisPSDLayerStyle::bevelAndEmboss() const
 {
     return &d->bevel_emboss;
 }
 
 psd_layer_effects_context* KisPSDLayerStyle::context()
 {
     return &d->context;
 }
 
 psd_layer_effects_drop_shadow* KisPSDLayerStyle::dropShadow()
 {
     return &d->drop_shadow;
 }
 
 psd_layer_effects_inner_shadow* KisPSDLayerStyle::innerShadow()
 {
     return &d->inner_shadow;
 }
 
 psd_layer_effects_outer_glow* KisPSDLayerStyle::outerGlow()
 {
     return &d->outer_glow;
 }
 
 psd_layer_effects_inner_glow* KisPSDLayerStyle::innerGlow()
 {
     return &d->inner_glow;
 }
 
 psd_layer_effects_satin* KisPSDLayerStyle::satin()
 {
     return &d->satin;
 }
 
 psd_layer_effects_color_overlay* KisPSDLayerStyle::colorOverlay()
 {
     return &d->color_overlay;
 }
 
 psd_layer_effects_gradient_overlay* KisPSDLayerStyle::gradientOverlay()
 {
     return &d->gradient_overlay;
 }
 
 psd_layer_effects_pattern_overlay* KisPSDLayerStyle::patternOverlay()
 {
     return &d->pattern_overlay;
 }
 
 psd_layer_effects_stroke* KisPSDLayerStyle::stroke()
 {
     return &d->stroke;
 }
 
 psd_layer_effects_bevel_emboss* KisPSDLayerStyle::bevelAndEmboss()
 {
     return &d->bevel_emboss;
 }
diff --git a/libs/image/kis_psd_layer_style.h b/libs/image/kis_psd_layer_style.h
index ae75d8f0a3..7643090fff 100644
--- a/libs/image/kis_psd_layer_style.h
+++ b/libs/image/kis_psd_layer_style.h
@@ -1,118 +1,118 @@
 /*
  *  Copyright (c) 2014 Boudewijn Rempt <boud@valdyas.org>
  *
  *  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.
  */
 #ifndef KIS_PSD_LAYER_STYLE_H
 #define KIS_PSD_LAYER_STYLE_H
 
 class QIODevice;
 class QUuid;
 
 #include <QVector>
 
 #include <psd.h>
 
 #include "kis_types.h"
 #include "kritapsd_export.h"
 
 class KisPSDLayerStyle;
 typedef QSharedPointer<KisPSDLayerStyle> KisPSDLayerStyleSP;
 
 
 /**
  * @brief The KisPSDLayerStyle class implements loading, saving and applying
  * the PSD layer effects.
  *
  * See https://www.tonton-pixel.com/Photoshop%20Additional%20File%20Formats/styles-file-format.html
  *
  */
 class KRITAPSD_EXPORT KisPSDLayerStyle : public KoResource
 {
 
 public:
-    explicit KisPSDLayerStyle();
+    KisPSDLayerStyle(const QString& name = QString());
     virtual ~KisPSDLayerStyle();
     KisPSDLayerStyle(const KisPSDLayerStyle& rhs);
     KisPSDLayerStyle operator=(const KisPSDLayerStyle& rhs);
 
     KoResourceSP clone() const;
 
     void clear();
 
     QString name() const;
     void setName(const QString &value);
 
 
 
     QUuid uuid() const;
     void setUuid(const QUuid &value) const;
 
     QString psdUuid() const;
     void setPsdUuid(const QString &value) const;
 
     /*
      * KoResource functions
      * they do nothing, just return true
      */
     bool load() override;
     bool loadFromDevice(QIODevice *dev) override;
     bool save() override;
     bool saveToDevice(QIODevice* dev) const override;
 
 
     QPair<QString, QString> resourceType() const override
     {
         return QPair<QString, QString>(ResourceType::LayerStyles, "");
     }
 
     /**
      * \return true if all the styles are disabled
      */
     bool isEmpty() const;
 
     bool isEnabled() const;
     void setEnabled(bool value);
 
     const psd_layer_effects_context* context() const;
     const psd_layer_effects_drop_shadow* dropShadow() const;
     const psd_layer_effects_inner_shadow* innerShadow() const;
     const psd_layer_effects_outer_glow* outerGlow() const;
     const psd_layer_effects_inner_glow* innerGlow() const;
     const psd_layer_effects_satin* satin() const;
     const psd_layer_effects_color_overlay* colorOverlay() const;
     const psd_layer_effects_gradient_overlay* gradientOverlay() const;
     const psd_layer_effects_pattern_overlay* patternOverlay() const;
     const psd_layer_effects_stroke* stroke() const;
     const psd_layer_effects_bevel_emboss* bevelAndEmboss() const;
 
     psd_layer_effects_context* context();
     psd_layer_effects_drop_shadow* dropShadow();
     psd_layer_effects_inner_shadow* innerShadow();
     psd_layer_effects_outer_glow* outerGlow();
     psd_layer_effects_inner_glow* innerGlow();
     psd_layer_effects_satin* satin();
     psd_layer_effects_color_overlay* colorOverlay();
     psd_layer_effects_gradient_overlay* gradientOverlay();
     psd_layer_effects_pattern_overlay* patternOverlay();
     psd_layer_effects_stroke* stroke();
     psd_layer_effects_bevel_emboss* bevelAndEmboss();
 
 private:
     struct Private;
     Private * const d;
 };
 
 #endif // KIS_PSD_LAYER_STYLE_H