diff --git a/engine/includes/editor/assetconverter.h b/engine/includes/editor/assetconverter.h
index 42cfb9ea1..ccb8a4c13 100644
--- a/engine/includes/editor/assetconverter.h
+++ b/engine/includes/editor/assetconverter.h
@@ -93,7 +93,7 @@ class ENGINE_EXPORT AssetConverterSettings : public Object {
     void setCurrentVersion(uint32_t version);
 
     const StringList subKeys() const;
-    TString subItem(const TString &key) const;
+    TString subItem(const TString &key, bool create = false) const;
     virtual Variant subItemData(const TString &key) const;
     TString subTypeName(const TString &key) const;
     int32_t subType(const TString &key) const;
@@ -103,8 +103,8 @@ class ENGINE_EXPORT AssetConverterSettings : public Object {
     void setSubItem(const TString &name, const TString &uuid, const TString &type);
     virtual void setSubItemData(const TString &name, const Variant &data);
 
-    AssetConverter::ReturnCode saveBinary(const Variant &data);
-    TString saveSubData(const Variant &data, const TString &path, const TString &type);
+    AssetConverter::ReturnCode saveBinary(const Variant &data, const TString &path);
+    AssetConverter::ReturnCode saveSubData(Resource *resource, const TString &name, const TString &type);
 
     bool loadSettings();
     void saveSettings();
diff --git a/engine/includes/editor/converters/assimpconverter.h b/engine/includes/editor/converters/assimpconverter.h
index 7ece42682..0166e63d7 100644
--- a/engine/includes/editor/converters/assimpconverter.h
+++ b/engine/includes/editor/converters/assimpconverter.h
@@ -73,8 +73,6 @@ class AssimpImportSettings : public AssetConverterSettings {
 
     Object::ObjectList m_renders;
 
-    StringList m_resources;
-
     BonesList m_bones;
 
     MeshMap m_meshes;
diff --git a/engine/includes/editor/viewport/tasks/gizmorender.h b/engine/includes/editor/viewport/tasks/gizmorender.h
index 69a0d9912..b2cf96727 100644
--- a/engine/includes/editor/viewport/tasks/gizmorender.h
+++ b/engine/includes/editor/viewport/tasks/gizmorender.h
@@ -55,7 +55,7 @@ class GizmoRender : public PipelineTask {
             m_solidCube->setColors(Vector4Vector(m_solidCube->vertices().size(), Vector4(0.0f, 0.46f, 0.74f, 0.25f)));
         }
 
-        Actor *cameraActor = Engine::composeActor("Camera", "Camera");
+        Actor *cameraActor = Engine::composeActor<Camera>("Camera");
         m_camera = cameraActor->getComponent<Camera>();
         m_camera->setFar(4.0f);
         m_camera->setNear(0.1f);
diff --git a/engine/includes/engine.h b/engine/includes/engine.h
index 0fa646561..3cf44df0a 100644
--- a/engine/includes/engine.h
+++ b/engine/includes/engine.h
@@ -107,12 +107,15 @@ class ENGINE_EXPORT Engine : public ObjectSystem {
 
     static TString organizationName();
 
-    static void setResource(Object *object, const TString &uuid);
-
     static bool setPlatformAdaptor(PlatformAdaptor *platform);
 
     static Actor *composeActor(const TString &component, const TString &name, Object *parent = nullptr);
 
+    template<typename T>
+    static Actor *composeActor(const TString &name, Object *parent = nullptr) {
+        return composeActor(T::metaClass()->name(), name, parent);
+    }
+
     Object::ObjectList getAllObjectsByType(const TString &type) const override;
 
     void addNativeBehaviour(NativeBehaviour *native);
diff --git a/engine/src/editor/assetconverter.cpp b/engine/src/editor/assetconverter.cpp
index 3e2cb6d52..3d142a82c 100644
--- a/engine/src/editor/assetconverter.cpp
+++ b/engine/src/editor/assetconverter.cpp
@@ -301,11 +301,14 @@ const StringList AssetConverterSettings::subKeys() const {
 /*!
     Returns UUID of a sub-item by \a key.
 */
-TString AssetConverterSettings::subItem(const TString &key) const {
+TString AssetConverterSettings::subItem(const TString &key, bool create) const {
     auto it = m_subItems.find(key);
     if(it != m_subItems.end()) {
         return it->second.uuid;
     }
+    if(create) {
+        return QUuid::createUuid().toString().toStdString();
+    }
     return TString();
 }
 /*!
@@ -357,8 +360,8 @@ void AssetConverterSettings::setSubItemData(const TString &name, const Variant &
     Q_UNUSED(data)
 }
 
-AssetConverter::ReturnCode AssetConverterSettings::saveBinary(const Variant &data) {
-    File file(absoluteDestination());
+AssetConverter::ReturnCode AssetConverterSettings::saveBinary(const Variant &data, const TString &path) {
+    File file(path);
     if(file.open(File::WriteOnly)) {
         std::set<TString> types;
         for(auto &it : data.toList()) {
@@ -376,25 +379,20 @@ AssetConverter::ReturnCode AssetConverterSettings::saveBinary(const Variant &dat
     return AssetConverter::InternalError;
 }
 /*!
-    Saves binary \a data as a sub-item with given destination \a path and asset \a type.
-    This method generated UUID id needed and registers a new sub-item.
+    Saves binary data of \a resource as a sub-item with given destination \a name and asset \a type.
     \sa AssetConverterSettings::setSubItem()
 */
-TString AssetConverterSettings::saveSubData(const Variant &data, const TString &path, const TString &type) {
-    TString uuid(subItem(path));
-    if(uuid.isEmpty()) {
-        uuid = QUuid::createUuid().toString().toStdString();
-    }
+AssetConverter::ReturnCode AssetConverterSettings::saveSubData(Resource *resource, const TString &name, const TString &type) {
+    TString uuid(subItem(name));
 
     Url dst(absoluteDestination());
-    File file(dst.absoluteDir() + "/" + uuid);
-    if(file.open(File::WriteOnly)) {
-        file.write(Bson::save(data));
-        file.close();
 
-        setSubItem(path, uuid, type);
+    AssetConverter::ReturnCode result = saveBinary(Engine::toVariant(resource), dst.absoluteDir() + "/" + uuid);
+    if(result == AssetConverter::Success) {
+        setSubItem(name, uuid, type);
     }
-    return uuid;
+
+    return result;
 }
 /*!
     Loads settings from metadata file ([source].set)
diff --git a/engine/src/editor/converters/animconverter.cpp b/engine/src/editor/converters/animconverter.cpp
index 4152d582d..4cd11f206 100644
--- a/engine/src/editor/converters/animconverter.cpp
+++ b/engine/src/editor/converters/animconverter.cpp
@@ -30,7 +30,7 @@ AssetConverter::ReturnCode AnimConverter::convertFile(AssetConverterSettings *se
     if(src.open(File::ReadOnly)) {
         AnimationClip *clip = Engine::loadResource<AnimationClip>(settings->destination());
         if(clip == nullptr) {
-            clip = Engine::objectCreate<AnimationClip>();
+            clip = Engine::objectCreate<AnimationClip>(settings->destination());
         }
 
         VariantMap map;
@@ -38,7 +38,7 @@ AssetConverter::ReturnCode AnimConverter::convertFile(AssetConverterSettings *se
         clip->loadUserData(map);
         src.close();
 
-        return settings->saveBinary(Engine::toVariant(clip));
+        return settings->saveBinary(Engine::toVariant(clip), settings->absoluteDestination());
     }
 
     return InternalError;
diff --git a/engine/src/editor/converters/assimpconverter.cpp b/engine/src/editor/converters/assimpconverter.cpp
index aa2b63b6e..3c5f3d73f 100644
--- a/engine/src/editor/converters/assimpconverter.cpp
+++ b/engine/src/editor/converters/assimpconverter.cpp
@@ -196,8 +196,8 @@ Actor *AssimpConverter::createActor(const AssetConverterSettings *settings, cons
     if(dynamic_cast<Prefab *>(resource) != nullptr) {
         return static_cast<Actor *>(static_cast<Prefab *>(resource)->actor()->clone());
     } else if(dynamic_cast<Mesh *>(resource) != nullptr) {
-        Actor *object = Engine::composeActor("MeshRender", "");
-        MeshRender *render = static_cast<MeshRender *>(object->component("MeshRender"));
+        Actor *object = Engine::composeActor<MeshRender>("");
+        MeshRender *render = object->getComponent<MeshRender>();
         if(render) {
             render->setMesh(static_cast<Mesh *>(resource));
         }
@@ -210,7 +210,6 @@ AssetConverter::ReturnCode AssimpConverter::convertFile(AssetConverterSettings *
     AssimpImportSettings *fbxSettings = static_cast<AssimpImportSettings *>(settings);
 
     fbxSettings->m_renders.clear();
-    fbxSettings->m_resources.clear();
     fbxSettings->m_bones.clear();
     fbxSettings->m_actors.clear();
     fbxSettings->m_meshes.clear();
@@ -247,8 +246,16 @@ AssetConverter::ReturnCode AssimpConverter::convertFile(AssetConverterSettings *
             }
         }
 
+        Prefab *prefab = Engine::loadResource<Prefab>(settings->destination());
+        if(prefab == nullptr) {
+            prefab = Engine::objectCreate<Prefab>(settings->destination());
+        }
+
+        /// \todo We need to reuse actors if possible
         Actor *root = importObject(scene, scene->mRootNode, nullptr, fbxSettings);
 
+        prefab->setActor(root);
+
         if(!fbxSettings->m_bones.empty()) {
             importPose(fbxSettings);
         } else {
@@ -266,12 +273,12 @@ AssetConverter::ReturnCode AssimpConverter::convertFile(AssetConverterSettings *
 
         aiReleaseImport(scene);
 
+        TString name(root->name());
+        root->setName(settings->destination()); // fixes the same name of root in the different files issue
         stabilizeUUID(root);
+        root->setName(name);
 
-        Prefab *prefab = Engine::objectCreate<Prefab>("");
-        prefab->setActor(root);
-
-        return settings->saveBinary(Engine::toVariant(prefab));
+        return settings->saveBinary(Engine::toVariant(prefab), settings->absoluteDestination());
     }
     return InternalError;
 }
@@ -374,7 +381,11 @@ Mesh *AssimpConverter::importMesh(const aiScene *scene, const aiNode *element, A
             const aiMesh *item = scene->mMeshes[element->mMeshes[index]];
 
             if(mesh == nullptr) {
-                mesh = Engine::objectCreate<Mesh>(item->mName.C_Str());
+                TString uuid = fbxSettings->subItem(actor->name(), true);
+                mesh = Engine::loadResource<Mesh>(uuid);
+                if(mesh == nullptr) {
+                    mesh = Engine::objectCreate<Mesh>(uuid);
+                }
             }
 
             count_v += item->mNumVertices;
@@ -509,18 +520,10 @@ Mesh *AssimpConverter::importMesh(const aiScene *scene, const aiNode *element, A
             total_i += indexCount;
         }
 
-        TString uuid = fbxSettings->saveSubData(Engine::toVariant(mesh), actor->name(), MetaType::name<Mesh>());
+        fbxSettings->saveSubData(mesh, actor->name(), MetaType::name<Mesh>());
+        fbxSettings->m_meshes[hash] = mesh;
 
-        Mesh *resource = Engine::loadResource<Mesh>(uuid);
-        if(resource == nullptr) {
-            Engine::setResource(mesh, uuid);
-            fbxSettings->m_resources.push_back(uuid);
-            resource = mesh;
-        }
-
-        fbxSettings->m_meshes[hash] = resource;
-
-        return resource;
+        return mesh;
     }
     return nullptr;
 }
@@ -614,7 +617,11 @@ void AssimpConverter::importAnimation(const aiScene *scene, AssimpImportSettings
     for(uint32_t a = 0; a < scene->mNumAnimations; a++) {
         aiAnimation *animation = scene->mAnimations[a];
 
-        AnimationClip clip;
+        TString uuid = fbxSettings->subItem(animation->mName.C_Str(), true);
+        AnimationClip *clip = Engine::loadResource<AnimationClip>(uuid);
+        if(clip == nullptr) {
+            clip = Engine::objectCreate<AnimationClip>(uuid);
+        }
 
         double animRate = (animation->mTicksPerSecond > 0) ? animation->mTicksPerSecond : 1;
 
@@ -660,7 +667,7 @@ void AssimpConverter::importAnimation(const aiScene *scene, AssimpImportSettings
                         optimizeVectorTrack(track, fbxSettings->positionError());
                     }
 
-                    clip.m_tracks.push_back(track);
+                    clip->m_tracks.push_back(track);
                 }
 
                 if(channel->mNumRotationKeys > 1) {
@@ -692,7 +699,7 @@ void AssimpConverter::importAnimation(const aiScene *scene, AssimpImportSettings
                         optimizeQuaternionTrack(track, fbxSettings->rotationError());
                     }
 
-                    clip.m_tracks.push_back(track);
+                    clip->m_tracks.push_back(track);
                 }
 
                 if(channel->mNumScalingKeys > 1) {
@@ -724,19 +731,23 @@ void AssimpConverter::importAnimation(const aiScene *scene, AssimpImportSettings
                         optimizeVectorTrack(track, fbxSettings->scaleError());
                     }
 
-                    clip.m_tracks.push_back(track);
+                    clip->m_tracks.push_back(track);
                 }
             }
         }
 
-        clip.m_tracks.sort(compare);
+        clip->m_tracks.sort(compare);
 
-        fbxSettings->saveSubData(Engine::toVariant(&clip), animation->mName.C_Str(), MetaType::name<AnimationClip>());
+        fbxSettings->saveSubData(clip, animation->mName.C_Str(), MetaType::name<AnimationClip>());
     }
 }
 
 void AssimpConverter::importPose(AssimpImportSettings *fbxSettings) {
-    Pose *pose = new Pose;
+    TString uuid = fbxSettings->subItem("Pose", true);
+    Pose *pose = Engine::loadResource<Pose>(uuid);
+    if(pose == nullptr) {
+        pose = Engine::objectCreate<Pose>(uuid);
+    }
 
     for(auto it : fbxSettings->m_bones) {
         aiVector3D scl, rot, pos;
@@ -755,20 +766,11 @@ void AssimpConverter::importPose(AssimpImportSettings *fbxSettings) {
         pose->addBone(&b);
     }
 
-    TString uuid = fbxSettings->saveSubData(Engine::toVariant(pose), "Pose", MetaType::name<Pose>());
-
-    Pose *resource = Engine::loadResource<Pose>(uuid);
-    if(resource == nullptr) {
-        Engine::setResource(pose, uuid);
-        fbxSettings->m_resources.push_back(uuid);
-        resource = pose;
-    }
-
-    fbxSettings->m_resources.push_back(uuid);
+    fbxSettings->saveSubData(pose, "Pose", MetaType::name<Pose>());
 
     if(fbxSettings->m_rootBone) {
         Armature *armature = static_cast<Armature *>(fbxSettings->m_rootBone->addComponent("Armature"));
-        armature->setBindPose(resource);
+        armature->setBindPose(pose);
 
         for(auto r : fbxSettings->m_renders) {
             SkinnedMeshRender *render = static_cast<SkinnedMeshRender *>(r);
diff --git a/engine/src/editor/converters/controlschemeconverter.cpp b/engine/src/editor/converters/controlschemeconverter.cpp
index 6e2b60937..ccd5a0bc1 100644
--- a/engine/src/editor/converters/controlschemeconverter.cpp
+++ b/engine/src/editor/converters/controlschemeconverter.cpp
@@ -22,7 +22,7 @@ AssetConverter::ReturnCode ControlSchemeConverter::convertFile(AssetConverterSet
     if(src.open(File::ReadOnly)) {
         ControlScheme *scheme = Engine::loadResource<ControlScheme>(settings->destination());
         if(scheme == nullptr) {
-            scheme = Engine::objectCreate<ControlScheme>();
+            scheme = Engine::objectCreate<ControlScheme>(settings->destination());
         }
 
         VariantMap map;
@@ -31,7 +31,7 @@ AssetConverter::ReturnCode ControlSchemeConverter::convertFile(AssetConverterSet
 
         src.close();
 
-        return settings->saveBinary(Engine::toVariant(scheme));
+        return settings->saveBinary(Engine::toVariant(scheme), settings->absoluteDestination());
     }
     return InternalError;
 }
diff --git a/engine/src/editor/converters/fontconverter.cpp b/engine/src/editor/converters/fontconverter.cpp
index 0f2c1f1b8..cce1a36e5 100644
--- a/engine/src/editor/converters/fontconverter.cpp
+++ b/engine/src/editor/converters/fontconverter.cpp
@@ -25,7 +25,7 @@ AssetConverter::ReturnCode FontConverter::convertFile(AssetConverterSettings *se
     if(src.open(File::ReadOnly)) {
         Font *font = Engine::loadResource<Font>(settings->destination());
         if(font == nullptr) {
-            font = Engine::objectCreate<Font>();
+            font = Engine::objectCreate<Font>(settings->destination());
         }
 
         VariantMap map;
@@ -34,7 +34,7 @@ AssetConverter::ReturnCode FontConverter::convertFile(AssetConverterSettings *se
 
         font->loadUserData(map);
 
-        return settings->saveBinary(Engine::toVariant(font));
+        return settings->saveBinary(Engine::toVariant(font), settings->absoluteDestination());
     }
     return InternalError;
 }
diff --git a/engine/src/editor/converters/prefabconverter.cpp b/engine/src/editor/converters/prefabconverter.cpp
index ff51d02a0..b9e2c7eb2 100644
--- a/engine/src/editor/converters/prefabconverter.cpp
+++ b/engine/src/editor/converters/prefabconverter.cpp
@@ -73,14 +73,13 @@ void PrefabConverter::createFromTemplate(const TString &destination) {
 void PrefabConverter::makePrefab(Actor *actor, AssetConverterSettings *settings) {
     File file(settings->source());
     if(file.open(File::WriteOnly)) {
-        Prefab *fab = Engine::objectCreate<Prefab>("");
+        Prefab *fab = Engine::objectCreate<Prefab>(settings->destination());
         fab->setActor(actor);
 
         file.write(Json::save(Engine::toVariant(fab), 0));
         file.close();
 
         settings->saveSettings();
-        Engine::setResource(fab, settings->destination());
     }
 }
 
@@ -104,7 +103,7 @@ AssetConverter::ReturnCode PrefabConverter::convertFile(AssetConverterSettings *
         Variant variant = readJson(src.readAll(), settings);
         src.close();
 
-        return settings->saveBinary(variant);
+        return settings->saveBinary(variant, settings->absoluteDestination());
     }
     return result;
 }
diff --git a/engine/src/editor/converters/textconverter.cpp b/engine/src/editor/converters/textconverter.cpp
index ac43f3ef5..69f0d118f 100644
--- a/engine/src/editor/converters/textconverter.cpp
+++ b/engine/src/editor/converters/textconverter.cpp
@@ -23,7 +23,7 @@ AssetConverter::ReturnCode TextConverter::convertFile(AssetConverterSettings *se
     if(src.open(File::ReadOnly)) {
         Text *text = Engine::loadResource<Text>(settings->destination());
         if(text == nullptr) {
-            text = Engine::objectCreate<Text>();
+            text = Engine::objectCreate<Text>(settings->destination());
         }
 
         TString content(src.readAll());
@@ -33,7 +33,7 @@ AssetConverter::ReturnCode TextConverter::convertFile(AssetConverterSettings *se
             memcpy(text->data(), content.data(), content.size());
         }
 
-        return settings->saveBinary(Engine::toVariant(text));
+        return settings->saveBinary(Engine::toVariant(text), settings->absoluteDestination());
     }
 
     return InternalError;
diff --git a/engine/src/editor/converters/translatorconverter.cpp b/engine/src/editor/converters/translatorconverter.cpp
index bcdf2a63f..de74da529 100644
--- a/engine/src/editor/converters/translatorconverter.cpp
+++ b/engine/src/editor/converters/translatorconverter.cpp
@@ -21,7 +21,7 @@ AssetConverter::ReturnCode TranslatorConverter::convertFile(AssetConverterSettin
     if(src.open(QIODevice::ReadOnly)) {
         Translator *loc = Engine::loadResource<Translator>(settings->destination());
         if(loc == nullptr) {
-            loc = Engine::objectCreate<Translator>();
+            loc = Engine::objectCreate<Translator>(settings->destination());
         }
 
         while(!src.atEnd()) {
@@ -31,7 +31,7 @@ AssetConverter::ReturnCode TranslatorConverter::convertFile(AssetConverterSettin
         }
         src.close();
 
-        return settings->saveBinary(Engine::toVariant(loc));
+        return settings->saveBinary(Engine::toVariant(loc), settings->absoluteDestination());
     }
 
     return InternalError;
diff --git a/engine/src/editor/viewport/cameracontroller.cpp b/engine/src/editor/viewport/cameracontroller.cpp
index 5b0454153..4433993b0 100644
--- a/engine/src/editor/viewport/cameracontroller.cpp
+++ b/engine/src/editor/viewport/cameracontroller.cpp
@@ -46,8 +46,8 @@ CameraController::CameraController() :
         m_activeRootObject(nullptr),
         m_zoomLimit(0.001f, 10000.0f) {
 
-    Actor *actor = Engine::composeActor(gCamera, gCamera, nullptr);
-    m_activeCamera = static_cast<Camera *>(actor->component(gCamera));
+    Actor *actor = Engine::composeActor<Camera>(gCamera);
+    m_activeCamera = actor->getComponent<Camera>();
     m_activeCamera->setFocal(10.0f);
     m_activeCamera->setOrthoSize(10.0f);
 
diff --git a/engine/src/engine.cpp b/engine/src/engine.cpp
index 9a0364f88..2230f96fa 100644
--- a/engine/src/engine.cpp
+++ b/engine/src/engine.cpp
@@ -254,7 +254,7 @@ void Engine::update() {
 
         if(camera == nullptr) {
             aDebug() << "Camera not found creating a new one.";
-            Actor *cameraActor = Engine::composeActor("Camera", "ActiveCamera", m_world);
+            Actor *cameraActor = Engine::composeActor<Camera>("ActiveCamera", m_world);
             camera = cameraActor->getComponent<Camera>();
         }
 
@@ -431,16 +431,6 @@ void Engine::reloadResource(const TString &path) {
 bool Engine::isResourceExist(const TString &path) {
     return m_resourceSystem->isResourceExist(path);
 }
-/*!
-    Register resource \a object by \a uuid path.
-
-    \sa setResource()
-*/
-void Engine::setResource(Object *object, const TString &uuid) {
-    PROFILE_FUNCTION();
-
-    m_resourceSystem->setResource(static_cast<Resource *>(object), uuid);
-}
 /*!
     Replaces a current \a platform adaptor with new one;
     Returns true if replacement been succeeded; otherwise returns false.
@@ -459,8 +449,6 @@ bool Engine::setPlatformAdaptor(PlatformAdaptor *platform) {
 }
 /*!
     Returns resource path for the provided resource \a object.
-
-    \sa setResource()
 */
 TString Engine::reference(Object *object) {
     PROFILE_FUNCTION();
diff --git a/engine/tests/tst_actor.h b/engine/tests/tst_actor.h
index 569b109b1..95497147c 100644
--- a/engine/tests/tst_actor.h
+++ b/engine/tests/tst_actor.h
@@ -323,7 +323,7 @@ TEST_F(ActorTest, Update_prefab_instance) {
     switchStatePrefab(*prefab, Resource::Ready);
 
     // Check instance state from Step 1
-    TestComponent *resultTestComponent = dynamic_cast<TestComponent *>(clone->component("TestComponent"));
+    TestComponent *resultTestComponent = clone->getComponent<TestComponent>();
     ASSERT_TRUE(resultTestComponent != nullptr);
     ASSERT_TRUE(resultTestComponent->parent()->name() == "Root");
 
diff --git a/modules/editor/grapheditor/editor/graph/graphnode.cpp b/modules/editor/grapheditor/editor/graph/graphnode.cpp
index 956a9e4b9..fc2a5dbf2 100644
--- a/modules/editor/grapheditor/editor/graph/graphnode.cpp
+++ b/modules/editor/grapheditor/editor/graph/graphnode.cpp
@@ -10,8 +10,6 @@
 #include "graphwidgets/nodewidget.h"
 
 namespace  {
-    const char *gNodeWidget("NodeWidget");
-
     const char *gType("type");
     const char *gName("name");
 
@@ -90,7 +88,7 @@ void GraphNode::setPosition(const Vector2 &position) {
 
 Widget *GraphNode::widget() {
     if(m_nodeWidget == nullptr) {
-        Actor *nodeActor = Engine::composeActor(gNodeWidget, name());
+        Actor *nodeActor = Engine::composeActor<NodeWidget>(name());
         if(nodeActor) {
             NodeWidget *nodeWidget = nodeActor->getComponent<NodeWidget>();
             nodeWidget->setGraphNode(this);
diff --git a/modules/editor/grapheditor/editor/graph/graphview.cpp b/modules/editor/grapheditor/editor/graph/graphview.cpp
index 07508ae6b..08207af89 100644
--- a/modules/editor/grapheditor/editor/graph/graphview.cpp
+++ b/modules/editor/grapheditor/editor/graph/graphview.cpp
@@ -134,12 +134,12 @@ void GraphView::setWorld(World *scene) {
     Viewport::setWorld(scene);
 
     m_scene = Engine::objectCreate<Scene>("Scene", m_world);
-    m_view = Engine::composeActor("Widget", "View", m_scene);
+    m_view = Engine::composeActor<Widget>("View", m_scene);
 
-    Actor *actor = Engine::composeActor(gLinksRender, gLinksRender, m_view);
+    Actor *actor = Engine::composeActor<LinksRender>(gLinksRender, m_view);
     m_linksRender = actor->getComponent<LinksRender>();
 
-    actor = Engine::composeActor(gFrame, gFrame, m_view);
+    actor = Engine::composeActor<Frame>(gFrame, m_view);
     m_rubberBand = actor->getComponent<Frame>();
     m_rubberBand->setColor(Vector4(0.376f, 0.376f, 0.376f, 0.3f));
     m_rubberBand->setBorderColor(Vector4(0.6f, 0.6f, 0.6f, 1.0f));
diff --git a/modules/editor/grapheditor/editor/graph/graphwidgets/groupwidget.cpp b/modules/editor/grapheditor/editor/graph/graphwidgets/groupwidget.cpp
index 0d6479232..9cb061d0a 100644
--- a/modules/editor/grapheditor/editor/graph/graphwidgets/groupwidget.cpp
+++ b/modules/editor/grapheditor/editor/graph/graphwidgets/groupwidget.cpp
@@ -142,9 +142,9 @@ void GroupWidget::composeComponent() {
 
     setColor(Vector4(1.0f, 1.0f, 1.0f, 0.5f));
 
-    Actor *title = Engine::composeActor("Frame", "Title", actor());
+    Actor *title = Engine::composeActor<Frame>("Title", actor());
     if(title) {
-        m_title = static_cast<Frame *>(title->component("Frame"));
+        m_title = title->getComponent<Frame>();
         if(m_title) {
             RectTransform *rect = m_title->rectTransform();
             rect->setAnchors(Vector2(0.0f, 1.0f), Vector2(1.0f, 1.0f));
diff --git a/modules/editor/grapheditor/editor/graph/graphwidgets/nodewidget.cpp b/modules/editor/grapheditor/editor/graph/graphwidgets/nodewidget.cpp
index 39de26750..0c12ed0e4 100644
--- a/modules/editor/grapheditor/editor/graph/graphwidgets/nodewidget.cpp
+++ b/modules/editor/grapheditor/editor/graph/graphwidgets/nodewidget.cpp
@@ -26,13 +26,6 @@
 
 const float row = 20.0f;
 
-namespace {
-    const char *gPortWidget("PortWidget");
-    const char *gImage("Image");
-    const char *gFrame("Frame");
-    const char *gToolButton("ToolButton");
-};
-
 NodeWidget::NodeWidget() :
         m_node(nullptr),
         m_label(nullptr),
@@ -162,7 +155,7 @@ void NodeWidget::composeComponent() {
     rect->setHorizontalPolicy(RectTransform::Fixed);
     rect->setBorder(2.0f);
 
-    Actor *title = Engine::composeActor(gFrame, "Title", actor());
+    Actor *title = Engine::composeActor<Frame>("Title", actor());
     if(title) {
         m_title = title->getComponent<Frame>();
         if(m_title) {
@@ -193,9 +186,9 @@ void NodeWidget::composeComponent() {
 }
 
 void NodeWidget::composePort(NodePort &port) {
-    Actor *portActor = Engine::composeActor(gPortWidget, port.m_name, actor());
+    Actor *portActor = Engine::composeActor<PortWidget>(port.m_name, actor());
     if(portActor) {
-        PortWidget *portWidget = static_cast<PortWidget *>(portActor->component(gPortWidget));
+        PortWidget *portWidget = portActor->getComponent<PortWidget>();
         if(portWidget) {
             RectTransform *portRect = portWidget->rectTransform();
             portRect->setSize(Vector2(0, row));
diff --git a/modules/editor/grapheditor/editor/graph/graphwidgets/portwidget.cpp b/modules/editor/grapheditor/editor/graph/graphwidgets/portwidget.cpp
index 9760a1f2f..a89f44b43 100644
--- a/modules/editor/grapheditor/editor/graph/graphwidgets/portwidget.cpp
+++ b/modules/editor/grapheditor/editor/graph/graphwidgets/portwidget.cpp
@@ -11,11 +11,6 @@
 
 #include <input.h>
 
-namespace {
-    const char *gLabel("Label");
-    const char *gWidget("Widget");
-};
-
 PortWidget::PortWidget() :
         m_port(nullptr),
         m_label(nullptr),
@@ -68,7 +63,7 @@ void PortWidget::setNodePort(NodePort *port) {
     // Create editor (only for inputs)
     if(!m_port->m_out) {
         if(m_editor) {
-            Widget *widget = static_cast<Widget *>(m_editor->component(gWidget));
+            Widget *widget = m_editor->getComponent<Widget>();
 
             RectTransform *widgetRect = widget->rectTransform();
             widgetRect->setMargin(Vector4(0.0f, 10.0f, 0.0f, 10.0f));
@@ -76,8 +71,8 @@ void PortWidget::setNodePort(NodePort *port) {
         }
     }
 
-    m_label = Engine::composeActor(gLabel, m_port->m_name, actor());
-    Label *label = static_cast<Label *>(m_label->component(gLabel));
+    m_label = Engine::composeActor<Label>(m_port->m_name, actor());
+    Label *label = m_label->getComponent<Label>();
 
     RectTransform *labelRect = label->rectTransform();
     labelRect->setSize(Vector2());
@@ -134,6 +129,6 @@ void PortWidget::composeComponent() {
         rect->setPivot(Vector2(0.0f, 1.0f));
     }
 
-    Actor *knob = Engine::composeActor("Frame", "Knob", actor());
-    m_knob = static_cast<Frame *>(knob->component("Frame"));
+    Actor *knob = Engine::composeActor<Frame>("Knob", actor());
+    m_knob = knob->getComponent<Frame>();
 }
diff --git a/modules/editor/grapheditor/editor/graph/nodegroup.cpp b/modules/editor/grapheditor/editor/graph/nodegroup.cpp
index c8c391eb1..c57204934 100644
--- a/modules/editor/grapheditor/editor/graph/nodegroup.cpp
+++ b/modules/editor/grapheditor/editor/graph/nodegroup.cpp
@@ -5,10 +5,6 @@
 #include <components/recttransform.h>
 #include <components/label.h>
 
-namespace {
-    const char *gGroupWidget("GroupWidget");
-}
-
 NodeGroup::NodeGroup() :
         m_color(Vector4(1.0f)),
         m_size(Vector2(400.0f, 200.0f)) {
@@ -53,7 +49,7 @@ Vector4 NodeGroup::color() const {
 
 Widget *NodeGroup::widget() {
     if(m_nodeWidget == nullptr) {
-        Actor *nodeActor = Engine::composeActor(gGroupWidget, name());
+        Actor *nodeActor = Engine::composeActor<GroupWidget>(name());
         if(nodeActor) {
             GroupWidget *nodeWidget = nodeActor->getComponent<GroupWidget>();
 
diff --git a/modules/editor/grapheditor/editor/graph/statenode.cpp b/modules/editor/grapheditor/editor/graph/statenode.cpp
index 4a9897a51..4a6d993ea 100644
--- a/modules/editor/grapheditor/editor/graph/statenode.cpp
+++ b/modules/editor/grapheditor/editor/graph/statenode.cpp
@@ -7,7 +7,7 @@
 
 Widget *StateNode::widget() {
     if(m_nodeWidget == nullptr) {
-        Actor *nodeActor = Engine::composeActor("NodeWidget", name());
+        Actor *nodeActor = Engine::composeActor<NodeWidget>(name());
         if(nodeActor) {
             NodeWidget *nodeWidget = nodeActor->getComponent<NodeWidget>();
 
diff --git a/modules/editor/motiontools/converter/animationbuilder.cpp b/modules/editor/motiontools/converter/animationbuilder.cpp
index 967abcc79..7a860f5ea 100644
--- a/modules/editor/motiontools/converter/animationbuilder.cpp
+++ b/modules/editor/motiontools/converter/animationbuilder.cpp
@@ -19,7 +19,7 @@ TString AnimationBuilderSettings::defaultIconPath(const TString &) const {
 AssetConverter::ReturnCode AnimationControllerBuilder::convertFile(AssetConverterSettings *settings) {
     m_model.load(settings->source());
 
-    return settings->saveBinary(m_model.object());
+    return settings->saveBinary(m_model.object(), settings->absoluteDestination());
 }
 
 AssetConverterSettings *AnimationControllerBuilder::createSettings() {
diff --git a/modules/editor/particletools/converter/effectbuilder.cpp b/modules/editor/particletools/converter/effectbuilder.cpp
index 60a62ffd6..56b5e8d2e 100644
--- a/modules/editor/particletools/converter/effectbuilder.cpp
+++ b/modules/editor/particletools/converter/effectbuilder.cpp
@@ -19,8 +19,6 @@ Q_DECLARE_METATYPE(Vector3)
 Q_DECLARE_METATYPE(Vector4)
 
 namespace  {
-    const char *gEffectRender("EffectRender");
-
     // Old file format
     const char *gName("Name");
     const char *gMesh("Mesh");
@@ -79,7 +77,7 @@ AssetConverter::ReturnCode EffectBuilder::convertFile(AssetConverterSettings *se
         m_graph.load(settings->source());
     }
 
-    return settings->saveBinary(m_graph.object());
+    return settings->saveBinary(m_graph.object(), settings->absoluteDestination());
 }
 
 AssetConverterSettings *EffectBuilder::createSettings() {
@@ -87,12 +85,12 @@ AssetConverterSettings *EffectBuilder::createSettings() {
 }
 
 Actor *EffectBuilder::createActor(const AssetConverterSettings *settings, const TString &guid) const {
-    const EffectBuilderSettings *s = static_cast<const EffectBuilderSettings *>(settings);
-    Actor *actor = Engine::composeActor(gEffectRender, "");
-    EffectRender *effect = static_cast<EffectRender *>(actor->component(gEffectRender));
+    Actor *actor = Engine::composeActor<EffectRender>("");
+    EffectRender *effect = actor->getComponent<EffectRender>();
     if(effect) {
+        const EffectBuilderSettings *effectSettings = static_cast<const EffectBuilderSettings *>(settings);
         effect->setEffect(Engine::loadResource<VisualEffect>(guid));
-        float warmup = s->thumbnailWarmup();
+        float warmup = effectSettings->thumbnailWarmup();
         const float frameStep = 1.0f / 60.0f;
 
         while(warmup > 0.0f) {
diff --git a/modules/editor/particletools/converter/effectrootnode.cpp b/modules/editor/particletools/converter/effectrootnode.cpp
index 159371519..0c6a9dd36 100644
--- a/modules/editor/particletools/converter/effectrootnode.cpp
+++ b/modules/editor/particletools/converter/effectrootnode.cpp
@@ -86,7 +86,7 @@ void EffectRootNode::fromXml(const pugi::xml_node &element) {
 }
 
 Foldout *EffectRootNode::createFold(const TString &name, Actor *parent) {
-    Actor *spawnActor = Engine::composeActor("Foldout", name, parent);
+    Actor *spawnActor = Engine::composeActor<Foldout>(name, parent);
     Foldout *result = spawnActor->getComponent<Foldout>();
     result->setText(name);
 
diff --git a/modules/editor/particletools/converter/modules/effectmodule.cpp b/modules/editor/particletools/converter/modules/effectmodule.cpp
index 81a3c26ad..3f89d4587 100644
--- a/modules/editor/particletools/converter/modules/effectmodule.cpp
+++ b/modules/editor/particletools/converter/modules/effectmodule.cpp
@@ -14,8 +14,6 @@
 #include "effectgraph.h"
 
 namespace {
-    const char *gCheckBoxWidget("CheckBox");
-
     const char *gValue("value");
     const char *gMin("min");
     const char *gMax("max");
@@ -38,7 +36,7 @@ Widget *EffectModule::widget(Object *parent) {
     if(m_checkBoxWidget == nullptr) {
         TString moduleName = name();
 
-        Actor *function = Engine::composeActor(gCheckBoxWidget, moduleName, parent);
+        Actor *function = Engine::composeActor<CheckBox>(moduleName, parent);
         m_checkBoxWidget = function->getComponent<CheckBox>();
         RectTransform *checkBoxRect = m_checkBoxWidget->rectTransform();
         checkBoxRect->setAnchors(Vector2(0.0f, 0.5f), Vector2(1.0f, 0.5f));
diff --git a/modules/editor/particletools/editor/particleedit.cpp b/modules/editor/particletools/editor/particleedit.cpp
index 9602388b4..86c1c09e3 100644
--- a/modules/editor/particletools/editor/particleedit.cpp
+++ b/modules/editor/particletools/editor/particleedit.cpp
@@ -15,7 +15,7 @@
 #include <components/transform.h>
 #include <components/effectrender.h>
 #include <components/camera.h>
-
+#include <components/directlight.h>
 
 #include "effectbuilder.h"
 #include "effectrootnode.h"
@@ -88,10 +88,10 @@ ParticleEdit::ParticleEdit() :
     ui->preview->init(); // must be called after all options set
     ui->preview->showGizmos(false);
 
-    m_light = Engine::composeActor("DirectLight", "DirectLight", scene);
+    m_light = Engine::composeActor<DirectLight>(gDirectLight, scene);
     m_light->transform()->setRotation(Vector3(-45.0f, 45.0f, 0.0f));
 
-    m_effect = Engine::composeActor("EffectRender", "EffectRender", scene);
+    m_effect = Engine::composeActor<EffectRender>(gEffectRender, scene);
     m_render = m_effect->getComponent<EffectRender>();
 
     EffectGraph *graph = &m_builder->graph();
diff --git a/modules/editor/pipelinetools/converter/pipelineconverter.cpp b/modules/editor/pipelinetools/converter/pipelineconverter.cpp
index 1b6067a00..dd9f284d0 100644
--- a/modules/editor/pipelinetools/converter/pipelineconverter.cpp
+++ b/modules/editor/pipelinetools/converter/pipelineconverter.cpp
@@ -40,12 +40,11 @@ AssetConverter::ReturnCode PipelineConverter::convertFile(AssetConverterSettings
 
     Pipeline *pipeline = Engine::loadResource<Pipeline>(settings->destination());
     if(pipeline == nullptr) {
-        pipeline = Engine::objectCreate<Pipeline>();
+        pipeline = Engine::objectCreate<Pipeline>(settings->destination());
     }
     pipeline->loadUserData(data);
-    Engine::setResource(pipeline, settings->destination());
 
-    return settings->saveBinary(Engine::toVariant(pipeline));
+    return settings->saveBinary(Engine::toVariant(pipeline), settings->absoluteDestination());
 }
 
 AssetConverterSettings *PipelineConverter::createSettings() {
diff --git a/modules/editor/shadertools/converter/functions/function.cpp b/modules/editor/shadertools/converter/functions/function.cpp
index 5070544bc..02d50b0bb 100644
--- a/modules/editor/shadertools/converter/functions/function.cpp
+++ b/modules/editor/shadertools/converter/functions/function.cpp
@@ -219,8 +219,8 @@ Widget *ShaderNode::widget() {
         if(graph) {
             Texture *preview = graph->preview(this);
             if(preview) {
-                Actor *actor = Engine::composeActor(gImage, "Preview", result->actor());
-                m_preview = static_cast<Image *>(actor->component(gImage));
+                Actor *actor = Engine::composeActor<Image>("Preview", result->actor());
+                m_preview = actor->getComponent<Image>();
                 if(m_preview) {
                     m_preview->setTexture(preview);
                     m_preview->setDrawMode(SpriteRender::Simple);
@@ -244,8 +244,8 @@ Widget *ShaderNode::widget() {
                     }
                 }
 
-                Actor *icon = Engine::composeActor(gButton, gImage, title);
-                m_previewBtn = static_cast<Button *>(icon->component(gButton));
+                Actor *icon = Engine::composeActor<Button>("PreviewBtn", title);
+                m_previewBtn = icon->getComponent<Button>();
 
                 m_previewBtn->setText("");
                 m_previewBtn->icon()->setSprite(Engine::loadResource<Sprite>(".embedded/ui.png"));
diff --git a/modules/editor/shadertools/converter/functions/function.h b/modules/editor/shadertools/converter/functions/function.h
index 53db0cfe8..fa17842b3 100644
--- a/modules/editor/shadertools/converter/functions/function.h
+++ b/modules/editor/shadertools/converter/functions/function.h
@@ -28,9 +28,6 @@ namespace {
     const char *y("Y");
     const char *z("Z");
     const char *w("W");
-
-    const char *gImage("Image");
-    const char *gButton("Button");
 }
 
 class ShaderNode : public GraphNode {
diff --git a/modules/editor/shadertools/converter/shaderbuilder.cpp b/modules/editor/shadertools/converter/shaderbuilder.cpp
index e4e45cdc2..c127d45f9 100644
--- a/modules/editor/shadertools/converter/shaderbuilder.cpp
+++ b/modules/editor/shadertools/converter/shaderbuilder.cpp
@@ -245,9 +245,8 @@ void ShaderBuilder::buildInstanceData(const VariantMap &user, PragmaMap &pragmas
 }
 
 Actor *ShaderBuilder::createActor(const AssetConverterSettings *settings, const TString &guid) const {
-    Actor *object = Engine::composeActor("MeshRender", "");
-
-    MeshRender *mesh = static_cast<MeshRender *>(object->component("MeshRender"));
+    Actor *object = Engine::composeActor<MeshRender>("");
+    MeshRender *mesh = object->getComponent<MeshRender>();
     if(mesh) {
         Mesh *m = Engine::loadResource<Mesh>(".embedded/sphere.fbx/Sphere001");
         if(m) {
@@ -314,7 +313,7 @@ AssetConverter::ReturnCode ShaderBuilder::convertFile(AssetConverterSettings *se
 
     builderSettings->setRhi(currentRhi());
 
-    return settings->saveBinary(result);
+    return settings->saveBinary(result, settings->absoluteDestination());
 }
 
 void ShaderBuilder::compileData(VariantMap &data) {
diff --git a/modules/editor/shadertools/editor/materialedit.cpp b/modules/editor/shadertools/editor/materialedit.cpp
index dab21a9d0..b37a823b6 100644
--- a/modules/editor/shadertools/editor/materialedit.cpp
+++ b/modules/editor/shadertools/editor/materialedit.cpp
@@ -96,10 +96,10 @@ MaterialEdit::MaterialEdit() :
     ui->preview->showCube(true);
     ui->preview->showGizmos(false);
 
-    m_light = Engine::composeActor(gDirectLight, gDirectLight, scene);
+    m_light = Engine::composeActor<DirectLight>(gDirectLight, scene);
     m_light->transform()->setRotation(Vector3(-45.0f, 45.0f, 0.0f));
 
-    m_mesh = Engine::composeActor(gMeshRender, gMeshRender, scene);
+    m_mesh = Engine::composeActor<MeshRender>(gMeshRender, scene);
 
     on_actionSphere_triggered();
 
@@ -186,7 +186,7 @@ void MaterialEdit::loadAsset(AssetConverterSettings *settings) {
 
         ui->schemeWidget->setGraph(m_graph);
 
-        MeshRender *mesh = static_cast<MeshRender *>(m_mesh->component(gMeshRender));
+        MeshRender *mesh = m_mesh->getComponent<MeshRender>();
         if(mesh) {
             mesh->setMaterial(m_material);
         }
@@ -209,7 +209,7 @@ void MaterialEdit::onGraphUpdated() {
         ShaderBuilder::compileData(data);
         m_material->loadUserData(data);
 
-        MeshRender *mesh = static_cast<MeshRender *>(m_mesh->component(gMeshRender));
+        MeshRender *mesh = m_mesh->getComponent<MeshRender>();
         if(mesh) {
             MaterialInstance *instance = mesh->materialInstance(0);
             m_material->initInstance(instance);
@@ -220,7 +220,7 @@ void MaterialEdit::onGraphUpdated() {
 }
 
 void MaterialEdit::changeMesh(Mesh *mesh) {
-    MeshRender *render = static_cast<MeshRender *>(m_mesh->component(gMeshRender));
+    MeshRender *render = m_mesh->getComponent<MeshRender>();
     if(render) {
         render->setMesh(mesh);
         if(m_material) {
diff --git a/modules/editor/spineimporter/converter/animationimporter.cpp b/modules/editor/spineimporter/converter/animationimporter.cpp
index 606731f0e..b8ce8aa83 100644
--- a/modules/editor/spineimporter/converter/animationimporter.cpp
+++ b/modules/editor/spineimporter/converter/animationimporter.cpp
@@ -254,7 +254,11 @@ void importDrawOrderTimeline(const VariantList &keys, AnimationClip &clip, Spine
 
 void SpineConverter::importAnimations(const VariantMap &animations, SpineConverterSettings *settings) {
     for(auto &animation : animations) {
-        AnimationClip *clip = Engine::objectCreate<AnimationClip>(animation.first);
+        TString uuid = settings->subItem(animation.first, true);
+        AnimationClip *clip = Engine::loadResource<AnimationClip>(uuid);
+        if(clip == nullptr) {
+            clip = Engine::objectCreate<AnimationClip>(uuid);
+        }
 
         for(auto &timeline : animation.second.value<VariantMap>()) {
             if(timeline.first == gBones) {
@@ -281,7 +285,6 @@ void SpineConverter::importAnimations(const VariantMap &animations, SpineConvert
             }
         }
 
-        TString uuid = settings->saveSubData(Engine::toVariant(clip), clip->name(), MetaType::name<AnimationClip>());
-        Engine::setResource(clip, uuid);
+        settings->saveSubData(clip, animation.first, MetaType::name<AnimationClip>());
     }
 }
diff --git a/modules/editor/spineimporter/converter/spineconverter.cpp b/modules/editor/spineimporter/converter/spineconverter.cpp
index 392466639..572a9a8f5 100644
--- a/modules/editor/spineimporter/converter/spineconverter.cpp
+++ b/modules/editor/spineimporter/converter/spineconverter.cpp
@@ -102,12 +102,18 @@ AssetConverter::ReturnCode SpineConverter::convertFile(AssetConverterSettings *s
         /// \todo Events section
 
         if(spineSettings->m_root) {
+            TString name(spineSettings->m_root->name());
+            spineSettings->m_root->setName(settings->destination());
             stabilizeUUID(spineSettings->m_root);
+            spineSettings->m_root->setName(name);
 
-            Prefab *prefab = Engine::objectCreate<Prefab>("");
+            Prefab *prefab = Engine::loadResource<Prefab>(settings->destination());
+            if(prefab == nullptr) {
+                prefab = Engine::objectCreate<Prefab>(settings->destination());
+            }
             prefab->setActor(spineSettings->m_root);
 
-            return settings->saveBinary(Engine::toVariant(prefab));
+            return settings->saveBinary(Engine::toVariant(prefab), settings->absoluteDestination());
         }
     }
 
@@ -221,7 +227,13 @@ void SpineConverter::importSkins(const VariantList &list, SpineConverterSettings
 
         auto skinIt = skinFields.find(gAttachments);
         if(skinIt != skinFields.end()) {
-            Sprite *sprite = Engine::objectCreate<Sprite>(skinFields[gName].toString());
+            TString skinName(skinFields[gName].toString());
+
+            TString uuid = settings->subItem(skinName, true);
+            Sprite *sprite = Engine::loadResource<Sprite>(uuid);
+            if(sprite == nullptr) {
+                sprite = Engine::objectCreate<Sprite>(uuid);
+            }
 
             importAtlas(sprite, settings);
 
@@ -230,7 +242,7 @@ void SpineConverter::importSkins(const VariantList &list, SpineConverterSettings
 
                 Actor *bone = settings->m_boneStructure[slot.bone];
 
-                Actor *slotActor = Engine::composeActor(gSpriteRender, slotIt.first, bone);
+                Actor *slotActor = Engine::composeActor<SpriteRender>(slotIt.first, bone);
 
                 for(auto &attachmentIt : slotIt.second.value<VariantMap>()) {
                     TString attachmentName = attachmentIt.first;
@@ -249,7 +261,11 @@ void SpineConverter::importSkins(const VariantList &list, SpineConverterSettings
                         attachmentName = it->second.toString();
                     }
 
-                    Mesh *mesh = Engine::objectCreate<Mesh>(attachmentName);
+                    TString uuid = settings->subItem(attachmentName, true);
+                    Mesh *mesh = Engine::loadResource<Mesh>(uuid);
+                    if(mesh == nullptr) {
+                        mesh = Engine::objectCreate<Mesh>(uuid);
+                    }
                     switch(type) {
                         case SkinTypes::Region: {
                             importRegion(attachmentFields, attachmentName, slotActor->transform(), mesh, settings);
@@ -264,8 +280,7 @@ void SpineConverter::importSkins(const VariantList &list, SpineConverterSettings
                         mesh->setColors(Vector4Vector(mesh->vertices().size(), Vector4(1.0f)));
                         mesh->recalcBounds();
 
-                        TString uuid = settings->saveSubData(Engine::toVariant(mesh), mesh->name(), MetaType::name<Mesh>());
-                        Engine::setResource(mesh, uuid);
+                        settings->saveSubData(mesh, attachmentName, MetaType::name<Mesh>());
 
                         sprite->setShape(Mathf::hashString(attachmentName), mesh);
                     } else {
@@ -273,7 +288,7 @@ void SpineConverter::importSkins(const VariantList &list, SpineConverterSettings
                     }
                 }
 
-                slot.render = static_cast<SpriteRender *>(slotActor->component(gSpriteRender));
+                slot.render = slotActor->getComponent<SpriteRender>();
                 if(slot.render) {
                     slot.render->setItem(slot.item);
                     slot.render->setSprite(sprite);
@@ -284,8 +299,7 @@ void SpineConverter::importSkins(const VariantList &list, SpineConverterSettings
                 }
             }
 
-            TString uuid = settings->saveSubData(Engine::toVariant(sprite), sprite->name(), MetaType::name<Sprite>());
-            Engine::setResource(sprite, uuid);
+            settings->saveSubData(sprite, skinName, MetaType::name<Sprite>());
         }
     }
 }
diff --git a/modules/editor/spineimporter/converter/spineconverter.h b/modules/editor/spineimporter/converter/spineconverter.h
index 296cf7cb1..3ab2e011f 100644
--- a/modules/editor/spineimporter/converter/spineconverter.h
+++ b/modules/editor/spineimporter/converter/spineconverter.h
@@ -41,7 +41,6 @@ namespace {
     const char *gTime("time");
     const char *gAngle("angle");
 
-    const char *gSpriteRender("SpriteRender");
     const char *gTransform("Transform");
 };
 
diff --git a/modules/editor/texturetools/converter/textureconverter.cpp b/modules/editor/texturetools/converter/textureconverter.cpp
index 717a6a03c..6c0bbe176 100644
--- a/modules/editor/texturetools/converter/textureconverter.cpp
+++ b/modules/editor/texturetools/converter/textureconverter.cpp
@@ -229,22 +229,20 @@ AssetConverter::ReturnCode TextureConverter::convertFile(AssetConverterSettings
         if(s->assetType() == TextureImportSettings::AssetType::Sprite) {
             Sprite *sprite = Engine::loadResource<Sprite>(settings->destination());
             if(sprite == nullptr) {
-                sprite = Engine::objectCreate<Sprite>();
-                Engine::setResource(sprite, settings->destination());
+                sprite = Engine::objectCreate<Sprite>(settings->destination());
             }
             convertSprite(sprite, s);
             resource = sprite;
         } else {
             Texture *texture = Engine::loadResource<Texture>(settings->destination());
             if(texture == nullptr) {
-                texture = Engine::objectCreate<Texture>();
-                Engine::setResource(texture, settings->destination());
+                texture = Engine::objectCreate<Texture>(settings->destination());
             }
             convertTexture(texture, s);
             resource = texture;
         }
 
-        return settings->saveBinary(Engine::toVariant(resource));
+        return settings->saveBinary(Engine::toVariant(resource), settings->absoluteDestination());
     }
 
     return InternalError;
@@ -380,16 +378,21 @@ uint32_t TextureConverter::toMeta(int type) {
 }
 
 void TextureConverter::convertSprite(Sprite *sprite, TextureImportSettings *settings) {
+    TString pageName("_Page1");
+
     Texture *texture = sprite->page();
     if(texture == nullptr) {
-        texture = Engine::objectCreate<Texture>("_Page1");
+        TString uuid = settings->subItem(pageName, true);
+        texture = Engine::loadResource<Texture>(uuid);
+        if(texture == nullptr) {
+            texture = Engine::objectCreate<Texture>(uuid);
+        }
         sprite->addPage(texture);
     }
 
     convertTexture(texture, settings);
 
-    TString uuid = settings->saveSubData(Engine::toVariant(texture), texture->name(), MetaType::name<Texture>());
-    Engine::setResource(texture, uuid);
+    settings->saveSubData(texture, pageName, MetaType::name<Texture>());
 
     float width = texture->width();
     float height = texture->height();
@@ -398,72 +401,74 @@ void TextureConverter::convertSprite(Sprite *sprite, TextureImportSettings *sett
 
     int i = 0;
     for(auto &it : settings->elements()) {
-        Mesh *mesh = Engine::objectCreate<Mesh>(it.first);
-        if(mesh) {
-            auto value = it.second;
-
-            Vector2 p = value.m_pivot;
-
-            float w = (value.m_max.x - value.m_min.x) / pixelsPerUnit;
-            float h = (value.m_max.y - value.m_min.y) / pixelsPerUnit;
-
-            float l = value.m_borderMin.x / pixelsPerUnit;
-            float r = value.m_borderMax.x / pixelsPerUnit;
-            float t = value.m_borderMax.y / pixelsPerUnit;
-            float b = value.m_borderMin.y / pixelsPerUnit;
-
-            mesh->setIndices({0, 1, 5, 0, 5, 4, 1, 2, 6, 1, 6, 5, 2, 3, 7, 2, 7, 6,
-                              4, 5, 9, 4, 9, 8, 5, 6,10, 5,10, 9, 6, 7,11, 6,11,10,
-                              8, 9,13, 8,13,12, 9,10,14, 9,14,13,10,11,15,10,15,14});
-
-            {
-                float x0 = -w * p.x;
-                float x1 = -w * p.x + l;
-                float x2 =  w * (1.0f - p.x) - r;
-                float x3 =  w * (1.0f - p.x);
-
-                float y0 = -h * p.y;
-                float y1 = -h * p.y + b;
-                float y2 =  h * (1.0f - p.y) - t;
-                float y3 =  h * (1.0f - p.y);
-
-                mesh->setVertices({
-                    Vector3(x0, y0, 0.0f), Vector3(x1, y0, 0.0f), Vector3(x2, y0, 0.0f), Vector3(x3, y0, 0.0f),
-                    Vector3(x0, y1, 0.0f), Vector3(x1, y1, 0.0f), Vector3(x2, y1, 0.0f), Vector3(x3, y1, 0.0f),
-
-                    Vector3(x0, y2, 0.0f), Vector3(x1, y2, 0.0f), Vector3(x2, y2, 0.0f), Vector3(x3, y2, 0.0f),
-                    Vector3(x0, y3, 0.0f), Vector3(x1, y3, 0.0f), Vector3(x2, y3, 0.0f), Vector3(x3, y3, 0.0f),
-                });
-            }
-            {
-                float x0 = value.m_min.x / width;
-                float x1 = (value.m_min.x + value.m_borderMin.x) / width;
-                float x2 = (value.m_max.x - value.m_borderMax.x) / width;
-                float x3 = value.m_max.x / width;
-
-                float y0 = value.m_min.y / height;
-                float y1 = (value.m_min.y + value.m_borderMin.y) / height;
-                float y2 = (value.m_max.y - value.m_borderMax.y) / height;
-                float y3 = value.m_max.y / height;
-
-                mesh->setUv0({
-                    Vector2(x0, y0), Vector2(x1, y0), Vector2(x2, y0), Vector2(x3, y0),
-                    Vector2(x0, y1), Vector2(x1, y1), Vector2(x2, y1), Vector2(x3, y1),
-
-                    Vector2(x0, y2), Vector2(x1, y2), Vector2(x2, y2), Vector2(x3, y2),
-                    Vector2(x0, y3), Vector2(x1, y3), Vector2(x2, y3), Vector2(x3, y3),
-                });
-            }
-            {
-                mesh->setColors(Vector4Vector(mesh->vertices().size(), Vector4(1.0f)));
-            }
+        TString uuid = settings->subItem(it.first, true);
+        Mesh *mesh = Engine::loadResource<Mesh>(uuid);
+        if(mesh == nullptr) {
+            mesh = Engine::objectCreate<Mesh>(uuid);
+        }
 
-            TString uuid = settings->saveSubData(Engine::toVariant(mesh), mesh->name(), MetaType::name<Mesh>());
-            Engine::setResource(mesh, uuid);
+        auto value = it.second;
 
-            sprite->setShape(Mathf::hashString(it.first), mesh);
-            i++;
+        Vector2 p = value.m_pivot;
+
+        float w = (value.m_max.x - value.m_min.x) / pixelsPerUnit;
+        float h = (value.m_max.y - value.m_min.y) / pixelsPerUnit;
+
+        float l = value.m_borderMin.x / pixelsPerUnit;
+        float r = value.m_borderMax.x / pixelsPerUnit;
+        float t = value.m_borderMax.y / pixelsPerUnit;
+        float b = value.m_borderMin.y / pixelsPerUnit;
+
+        mesh->setIndices({0, 1, 5, 0, 5, 4, 1, 2, 6, 1, 6, 5, 2, 3, 7, 2, 7, 6,
+                          4, 5, 9, 4, 9, 8, 5, 6,10, 5,10, 9, 6, 7,11, 6,11,10,
+                          8, 9,13, 8,13,12, 9,10,14, 9,14,13,10,11,15,10,15,14});
+
+        {
+            float x0 = -w * p.x;
+            float x1 = -w * p.x + l;
+            float x2 =  w * (1.0f - p.x) - r;
+            float x3 =  w * (1.0f - p.x);
+
+            float y0 = -h * p.y;
+            float y1 = -h * p.y + b;
+            float y2 =  h * (1.0f - p.y) - t;
+            float y3 =  h * (1.0f - p.y);
+
+            mesh->setVertices({
+                Vector3(x0, y0, 0.0f), Vector3(x1, y0, 0.0f), Vector3(x2, y0, 0.0f), Vector3(x3, y0, 0.0f),
+                Vector3(x0, y1, 0.0f), Vector3(x1, y1, 0.0f), Vector3(x2, y1, 0.0f), Vector3(x3, y1, 0.0f),
+
+                Vector3(x0, y2, 0.0f), Vector3(x1, y2, 0.0f), Vector3(x2, y2, 0.0f), Vector3(x3, y2, 0.0f),
+                Vector3(x0, y3, 0.0f), Vector3(x1, y3, 0.0f), Vector3(x2, y3, 0.0f), Vector3(x3, y3, 0.0f),
+            });
+        }
+        {
+            float x0 = value.m_min.x / width;
+            float x1 = (value.m_min.x + value.m_borderMin.x) / width;
+            float x2 = (value.m_max.x - value.m_borderMax.x) / width;
+            float x3 = value.m_max.x / width;
+
+            float y0 = value.m_min.y / height;
+            float y1 = (value.m_min.y + value.m_borderMin.y) / height;
+            float y2 = (value.m_max.y - value.m_borderMax.y) / height;
+            float y3 = value.m_max.y / height;
+
+            mesh->setUv0({
+                Vector2(x0, y0), Vector2(x1, y0), Vector2(x2, y0), Vector2(x3, y0),
+                Vector2(x0, y1), Vector2(x1, y1), Vector2(x2, y1), Vector2(x3, y1),
+
+                Vector2(x0, y2), Vector2(x1, y2), Vector2(x2, y2), Vector2(x3, y2),
+                Vector2(x0, y3), Vector2(x1, y3), Vector2(x2, y3), Vector2(x3, y3),
+            });
         }
+        {
+            mesh->setColors(Vector4Vector(mesh->vertices().size(), Vector4(1.0f)));
+        }
+
+        settings->saveSubData(mesh, it.first, MetaType::name<Mesh>());
+
+        sprite->setShape(Mathf::hashString(it.first), mesh);
+        i++;
     }
 }
 
@@ -475,7 +480,7 @@ Actor *TextureConverter::createActor(const AssetConverterSettings *settings, con
     Resource *res = Engine::loadResource<Resource>(guid);
     Sprite *sheet = dynamic_cast<Sprite *>(res);
     if(sheet) {
-        Actor *actor = Engine::composeActor("SpriteRender", "");
+        Actor *actor = Engine::composeActor<SpriteRender>("");
         SpriteRender *render = actor->getComponent<SpriteRender>();
         render->setSprite(sheet);
 
@@ -484,14 +489,14 @@ Actor *TextureConverter::createActor(const AssetConverterSettings *settings, con
         Texture *texture = dynamic_cast<Texture *>(res);
         if(texture) {
             if(!texture->isCubemap()) {
-                Actor *actor = Engine::composeActor("SpriteRender", "");
+                Actor *actor = Engine::composeActor<SpriteRender>("");
                 SpriteRender *render = actor->getComponent<SpriteRender>();
                 render->setSize(Vector2(texture->width(), texture->height()));
                 render->setTexture(texture);
 
                 return actor;
             } else {
-                Actor *actor = Engine::composeActor("MeshRender", "");
+                Actor *actor = Engine::composeActor<MeshRender>("");
                 MeshRender *render = actor->getComponent<MeshRender>();
                 render->setMesh(Engine::loadResource<Mesh>(".embedded/sphere.fbx/Sphere001"));
                 render->setMaterial(Engine::loadResource<Material>(".embedded/cubemap.shader"));
diff --git a/modules/editor/texturetools/editor/spriteedit.cpp b/modules/editor/texturetools/editor/spriteedit.cpp
index f72702726..79b61405b 100644
--- a/modules/editor/texturetools/editor/spriteedit.cpp
+++ b/modules/editor/texturetools/editor/spriteedit.cpp
@@ -51,12 +51,12 @@ SpriteEdit::SpriteEdit() :
         camera->setOrthographic(true);
     }
 
-    Actor *object = Engine::composeActor(gSpriteRender, gSpriteRender, m_scene);
+    Actor *object = Engine::composeActor<SpriteRender>(gSpriteRender, m_scene);
     m_render = object->getComponent<SpriteRender>();
     m_render->setMaterial(Engine::loadResource<Material>(".embedded/DefaultSprite.shader"));
     m_render->setLayer(2);
 
-    object = Engine::composeActor(gSpriteRender, "CheckerBoard", m_scene);
+    object = Engine::composeActor<SpriteRender>("CheckerBoard", m_scene);
     m_checker = object->getComponent<SpriteRender>();
     m_checker->setMaterial(Engine::loadResource<Material>(".embedded/checkerboard.shader"));
 
diff --git a/modules/editor/tiledimporter/converter/tiledmapconverter.cpp b/modules/editor/tiledimporter/converter/tiledmapconverter.cpp
index e7b728684..3319f935e 100644
--- a/modules/editor/tiledimporter/converter/tiledmapconverter.cpp
+++ b/modules/editor/tiledimporter/converter/tiledmapconverter.cpp
@@ -49,8 +49,10 @@ AssetConverter::ReturnCode TiledMapConverter::convertFile(AssetConverterSettings
                 if(prefab) {
                     root = prefab->actor();
                 } else {
-                    root = Engine::objectCreate<Actor>("TileMap", nullptr);
-                    root->addComponent("Transform");
+                    prefab = Engine::objectCreate<Prefab>(settings->destination());
+
+                    root = Engine::composeActor("", "TileMap", nullptr);
+                    prefab->setActor(root);
                 }
 
                 std::list<Component *> components = root->componentsInChild(gTileMapRender);
@@ -67,18 +69,17 @@ AssetConverter::ReturnCode TiledMapConverter::convertFile(AssetConverterSettings
                         QFileInfo info(settings->source().data());
                         QDir dir(ProjectSettings::instance()->contentPath().data());
                         if(source.isEmpty()) {
-                            tileSet = Engine::objectCreate<TileSet>();
-                            parseTileset(element, info.path(), *tileSet);
-
-                            TString uuid = settings->saveSubData(Engine::toVariant(tileSet), element.attribute("name").as_string(),
-                                                                 MetaType::name<TileSet>());
+                            TString tilesetName(element.attribute("name").as_string());
+                            TString uuid(settings->subItem(tilesetName, true));
 
-                            TileSet *set = Engine::loadResource<TileSet>(uuid);
-                            if(set == nullptr) {
-                                Engine::setResource(tileSet, uuid);
-                            } else {
-                                tileSet = set;
+                            tileSet = Engine::loadResource<TileSet>(uuid);
+                            if(tileSet == nullptr) {
+                                tileSet = Engine::objectCreate<TileSet>(uuid);
                             }
+
+                            parseTileset(element, info.path(), *tileSet);
+
+                            settings->saveSubData(tileSet, tilesetName, MetaType::name<TileSet>());
                         } else {
                             source = dir.relativeFilePath(info.path() + "/" + source.data()).toStdString();
 
@@ -87,7 +88,14 @@ AssetConverter::ReturnCode TiledMapConverter::convertFile(AssetConverterSettings
 
                         tileOffset = element.attribute("firstgid").as_int();
                     } else if(std::string(element.name()) == "layer") {
-                        TileMap *tileMap = new TileMap;
+                        TString tilemapName(element.attribute("name").as_string());
+                        TString uuid(settings->subItem(tilemapName, true));
+
+                        TileMap *tileMap = Engine::loadResource<TileMap>(uuid);
+                        if(tileMap == nullptr) {
+                            tileMap = Engine::objectCreate<TileMap>(uuid);
+                        }
+
                         parseLayer(element, tileOffset, *tileMap);
                         tileMap->setTileSet(tileSet);
 
@@ -112,15 +120,7 @@ AssetConverter::ReturnCode TiledMapConverter::convertFile(AssetConverterSettings
                         tileMap->setCellWidth(tileWidth);
                         tileMap->setCellHeight(tileHeight);
 
-                        TString uuid = settings->saveSubData(Engine::toVariant(tileMap), element.attribute("name").as_string(),
-                                                             MetaType::name<TileMap>());
-
-                        TileMap *map = Engine::loadResource<TileMap>(uuid);
-                        if(map == nullptr) {
-                            Engine::setResource(tileSet, uuid);
-                        } else {
-                            tileMap = map;
-                        }
+                        settings->saveSubData(tileMap, tilemapName, MetaType::name<TileMap>());
 
                         TileMapRender *render = nullptr;
 
@@ -134,7 +134,7 @@ AssetConverter::ReturnCode TiledMapConverter::convertFile(AssetConverterSettings
 
                         if(render == nullptr) {
                             Actor *actor = Engine::composeActor(gTileMapRender, name, root);
-                            render = static_cast<TileMapRender *>(actor->component(gTileMapRender));
+                            render = actor->getComponent<TileMapRender>();
                         }
                         render->setTileMap(tileMap);
                         render->setLayer(element.attribute("id").as_int());
@@ -155,12 +155,7 @@ AssetConverter::ReturnCode TiledMapConverter::convertFile(AssetConverterSettings
                     }
                 }
 
-                if(prefab == nullptr) {
-                    prefab = Engine::objectCreate<Prefab>("");
-                    prefab->setActor(root);
-                }
-
-                return settings->saveBinary(Engine::toVariant(prefab));
+                return settings->saveBinary(Engine::toVariant(prefab), settings->absoluteDestination());
             }
         }
     }
@@ -253,7 +248,7 @@ Actor *TiledMapConverter::createActor(const AssetConverterSettings *settings, co
     if(dynamic_cast<Prefab *>(resource) != nullptr) {
         return static_cast<Actor *>(static_cast<Prefab *>(resource)->actor()->clone());
     } else if(dynamic_cast<TileMap *>(resource) != nullptr) {
-        Actor *object = Engine::composeActor("TileMapRender", "");
+        Actor *object = Engine::composeActor<TileMapRender>("");
         TileMapRender *render = object->getComponent<TileMapRender>();
         if(render) {
             render->setTileMap(static_cast<TileMap *>(resource));
diff --git a/modules/editor/tiledimporter/converter/tiledsetconverter.cpp b/modules/editor/tiledimporter/converter/tiledsetconverter.cpp
index b687fc540..4c7828b02 100644
--- a/modules/editor/tiledimporter/converter/tiledsetconverter.cpp
+++ b/modules/editor/tiledimporter/converter/tiledsetconverter.cpp
@@ -40,10 +40,14 @@ AssetConverter::ReturnCode TiledSetConverter::convertFile(AssetConverterSettings
         if(result) {
             pugi::xml_node ts = doc.document_element();
             if(std::string(ts.name()) == "tileset") {
-                TileSet *tileSet = Engine::objectCreate<TileSet>();
+                TileSet *tileSet = Engine::loadResource<TileSet>(settings->destination());
+                if(tileSet == nullptr) {
+                    tileSet = Engine::objectCreate<TileSet>(settings->destination());
+                }
+
                 TiledMapConverter::parseTileset(ts, QFileInfo(settings->source().data()).path(), *tileSet);
 
-                return settings->saveBinary(Engine::toVariant(tileSet));
+                return settings->saveBinary(Engine::toVariant(tileSet), settings->absoluteDestination());
             }
         }
     }
diff --git a/modules/media/src/converters/audioconverter.cpp b/modules/media/src/converters/audioconverter.cpp
index d735a839a..7ccf5c493 100644
--- a/modules/media/src/converters/audioconverter.cpp
+++ b/modules/media/src/converters/audioconverter.cpp
@@ -103,12 +103,12 @@ AssetConverter::ReturnCode AudioConverter::convertFile(AssetConverterSettings *s
 
     AudioClip *clip = Engine::loadResource<AudioClip>(settings->destination());
     if(clip == nullptr) {
-        clip = Engine::objectCreate<AudioClip>();
+        clip = Engine::objectCreate<AudioClip>(settings->destination());
     }
 
     clip->loadUserData(convertResource(static_cast<AudioImportSettings *>(settings), channels));
 
-    return settings->saveBinary(Engine::toVariant(clip));
+    return settings->saveBinary(Engine::toVariant(clip), settings->absoluteDestination());
 }
 
 VariantMap AudioConverter::convertResource(AudioImportSettings *settings, int32_t srcChanels) {
diff --git a/modules/physics/bullet/src/converters/physicmaterialconverter.cpp b/modules/physics/bullet/src/converters/physicmaterialconverter.cpp
index 0e3e3688b..f25934f81 100644
--- a/modules/physics/bullet/src/converters/physicmaterialconverter.cpp
+++ b/modules/physics/bullet/src/converters/physicmaterialconverter.cpp
@@ -25,7 +25,7 @@ AssetConverter::ReturnCode PhysicMaterialConverter::convertFile(AssetConverterSe
     if(src.open(File::ReadOnly)) {
         PhysicMaterial *material = Engine::loadResource<PhysicMaterial>(settings->destination());
         if(material == nullptr) {
-            material = Engine::objectCreate<PhysicMaterial>();
+            material = Engine::objectCreate<PhysicMaterial>(settings->destination());
         }
 
         VariantMap map = Json::load(src.readAll()).toMap();
@@ -35,7 +35,7 @@ AssetConverter::ReturnCode PhysicMaterialConverter::convertFile(AssetConverterSe
         material->setRestitution(map["Restitution"].toFloat());
         material->setDensity(map["Density"].toFloat());
 
-        return settings->saveBinary(Engine::toVariant(material));
+        return settings->saveBinary(Engine::toVariant(material), settings->absoluteDestination());
     }
 
     return InternalError;
diff --git a/modules/uikit/src/components/abstractbutton.cpp b/modules/uikit/src/components/abstractbutton.cpp
index e18941a19..70cff3372 100644
--- a/modules/uikit/src/components/abstractbutton.cpp
+++ b/modules/uikit/src/components/abstractbutton.cpp
@@ -19,10 +19,6 @@ namespace {
     const char *gLabel("label");
     const char *gIcon("icon");
 
-    const char *gImageClass("Image");
-    const char *gFrameClass("Frame");
-    const char *gLabelClass("Label");
-
     const float gCorner = 4.0f;
     const float gFadeDuration = 0.2f;
 }
@@ -298,7 +294,7 @@ void AbstractButton::checkStateSet() {
         for(auto it : actor()->getChildren()) {
             Actor *actor = dynamic_cast<Actor *>(it);
             if(actor) {
-                AbstractButton *btn = static_cast<AbstractButton *>(actor->component("AbstractButton"));
+                AbstractButton *btn = actor->getComponent<AbstractButton>();
                 if(btn && btn != this) {
                     btn->setChecked(false);
                 }
@@ -314,14 +310,14 @@ void AbstractButton::composeComponent() {
     Widget::composeComponent();
 
     // Add background
-    Actor *background = Engine::composeActor(gFrameClass, gBackground, actor());
+    Actor *background = Engine::composeActor<Frame>(gBackground, actor());
     Frame *frame = background->getComponent<Frame>();
     frame->setCorners(Vector4(gCorner));
 
     setBackground(frame);
 
     // Add label
-    Actor *text = Engine::composeActor(gLabelClass, gLabel, actor());
+    Actor *text = Engine::composeActor<Label>(gLabel, actor());
     Label *label = text->getComponent<Label>();
     label->setAlign(Alignment::Middle | Alignment::Center);
     label->setColor(m_textColor);
@@ -334,7 +330,7 @@ void AbstractButton::composeComponent() {
     setText("Text");
 
     // Add icon
-    Actor *icon = Engine::composeActor(gImageClass, gIcon, actor());
+    Actor *icon = Engine::composeActor<Image>(gIcon, actor());
     Image *image = icon->getComponent<Image>();
 
     setIcon(image);
diff --git a/modules/uikit/src/components/checkbox.cpp b/modules/uikit/src/components/checkbox.cpp
index 5c8ed4066..1acfe1006 100644
--- a/modules/uikit/src/components/checkbox.cpp
+++ b/modules/uikit/src/components/checkbox.cpp
@@ -113,7 +113,7 @@ void CheckBox::composeComponent() {
         }
 
         // Add knob
-        Actor *knob = Engine::composeActor("Image", gKnob, background()->actor());
+        Actor *knob = Engine::composeActor<Image>(gKnob, background()->actor());
         Image *image = knob->getComponent<Image>();
         if(image) {
             Sprite *ui = Engine::loadResource<Sprite>(".embedded/ui.png");
diff --git a/modules/uikit/src/components/floatinput.cpp b/modules/uikit/src/components/floatinput.cpp
index 67a61efd8..4af512907 100644
--- a/modules/uikit/src/components/floatinput.cpp
+++ b/modules/uikit/src/components/floatinput.cpp
@@ -18,9 +18,6 @@ namespace {
     const char *gIncrease("increase");
     const char *gDecrease("decrease");
     const char *gInput("input");
-
-    const char *gLineEditClass("LineEdit");
-    const char *gButtonClass("Button");
 };
 
 /*!
@@ -206,7 +203,7 @@ void FloatInput::composeComponent() {
 
     const float width = 20.0f;
 
-    Actor *text = Engine::composeActor(gLineEditClass, gInput, actor());
+    Actor *text = Engine::composeActor<LineEdit>(gInput, actor());
 
     LineEdit *input = text->getComponent<LineEdit>();
     if(input) {
@@ -223,8 +220,8 @@ void FloatInput::composeComponent() {
 
     Sprite *arrow = Engine::loadResource<Sprite>(".embedded/ui.png");
 
-    Actor *left = Engine::composeActor(gButtonClass, gDecrease, actor());
-    Button *decreaseBtn = static_cast<Button *>(left->component(gButtonClass));
+    Actor *left = Engine::composeActor<LineEdit>(gDecrease, actor());
+    Button *decreaseBtn = left->getComponent<Button>();
     if(decreaseBtn) {
         connect(decreaseBtn, _SIGNAL(clicked()), this, _SLOT(onDecrease()));
 
@@ -247,8 +244,8 @@ void FloatInput::composeComponent() {
     leftRect->setAnchors(Vector2(0.0f), Vector2(0.0f, 1.0f));
     leftRect->setPivot(Vector2(0.0f));
 
-    Actor *right = Engine::composeActor(gButtonClass, "Increase", actor());
-    Button *increaseBtn = static_cast<Button *>(right->component(gButtonClass));
+    Actor *right = Engine::composeActor<Button>(gIncrease, actor());
+    Button *increaseBtn = right->getComponent<Button>();
     if(increaseBtn) {
         connect(increaseBtn, _SIGNAL(clicked()), this, _SLOT(onIncrease()));
 
diff --git a/modules/uikit/src/components/foldout.cpp b/modules/uikit/src/components/foldout.cpp
index 2b3b29927..cff69d358 100644
--- a/modules/uikit/src/components/foldout.cpp
+++ b/modules/uikit/src/components/foldout.cpp
@@ -13,10 +13,6 @@ namespace {
     const char *gLabel("label");
     const char *gIndicator("indicator");
     const char *gContainer("container");
-
-    const char *gButtonClass("Button");
-    const char *gFrameClass("Frame");
-    const char *gLabelClass("Label");
 }
 
 /*!
@@ -148,7 +144,7 @@ void Foldout::onExpand() {
 void Foldout::composeComponent() {
     Widget::composeComponent();
 
-    Actor *containerActor = Engine::composeActor(gFrameClass, gContainer, actor());
+    Actor *containerActor = Engine::composeActor<Frame>(gContainer, actor());
     Frame *container = containerActor->getComponent<Frame>();
     container->setColor(Vector4(0.0f, 0.0f, 0.0f, 0.25f));
     setContainer(container);
@@ -161,7 +157,7 @@ void Foldout::composeComponent() {
     Layout *containerLayout = new Layout;
     containerRect->setLayout(containerLayout);
 
-    Actor *indicatorActor = Engine::composeActor(gButtonClass, gIndicator, actor());
+    Actor *indicatorActor = Engine::composeActor<Button>(gIndicator, actor());
     Button *indicator = indicatorActor->getComponent<Button>();
 
     indicator->setText("");
@@ -180,7 +176,7 @@ void Foldout::composeComponent() {
     RectTransform *indicatorRect = indicator->rectTransform();
     indicatorRect->setSize(20);
 
-    Actor *labelActor = Engine::composeActor(gLabelClass, gLabel, actor());
+    Actor *labelActor = Engine::composeActor<Label>(gLabel, actor());
     Label *label = labelActor->getComponent<Label>();
     label->setAlign(Alignment::Top | Alignment::Left);
     setLabel(label);
diff --git a/modules/uikit/src/components/lineedit.cpp b/modules/uikit/src/components/lineedit.cpp
index bcd01a003..b4a91dbdb 100644
--- a/modules/uikit/src/components/lineedit.cpp
+++ b/modules/uikit/src/components/lineedit.cpp
@@ -268,7 +268,7 @@ void LineEdit::composeComponent() {
     Widget::composeComponent();
 
     // Add label
-    Actor *text = Engine::composeActor(gLabelClass, gText, actor());
+    Actor *text = Engine::composeActor<Label>(gText, actor());
     Label *label = text->getComponent<Label>();
     label->setAlign(Alignment::Middle | Alignment::Left);
 
diff --git a/modules/uikit/src/components/menu.cpp b/modules/uikit/src/components/menu.cpp
index b8eae25d6..dfca0698a 100644
--- a/modules/uikit/src/components/menu.cpp
+++ b/modules/uikit/src/components/menu.cpp
@@ -14,9 +14,6 @@
 namespace {
     const char *gSelected = "selected";
 
-    const char *gFrame = "Frame";
-    const char *gLabel = "Label";
-
     const float gCorner = 4.0f;
     const float gRowHeight = 20.0f;
 };
@@ -39,8 +36,8 @@ Menu::Menu() :
     Adds a section to the menu with the specified \a text.
 */
 void Menu::addSection(const TString &text) {
-    Actor *actor = Engine::composeActor(gLabel, text, Menu::actor());
-    Label *label = static_cast<Label *>(actor->component(gLabel));
+    Actor *actor = Engine::composeActor<Label>(text, Menu::actor());
+    Label *label = actor->getComponent<Label>();
     if(label) {
         label->setText(text);
         label->setAlign(Alignment::Middle | Alignment::Left);
@@ -181,8 +178,8 @@ void Menu::composeComponent() {
         r->setLayout(layout);
     }
 
-    Actor *actor = Engine::composeActor(gFrame, gSelected, Menu::actor());
-    Frame *select = static_cast<Frame *>(actor->component(gFrame));
+    Actor *actor = Engine::composeActor<Frame>(gSelected, Menu::actor());
+    Frame *select = actor->getComponent<Frame>();
     select->setColor(Vector4(0.01f, 0.6f, 0.89f, 1.0f));
     select->setCorners(0.0f);
     select->setBorderColor(0.0f);
diff --git a/modules/uikit/src/components/progressbar.cpp b/modules/uikit/src/components/progressbar.cpp
index b12f77566..53106a916 100644
--- a/modules/uikit/src/components/progressbar.cpp
+++ b/modules/uikit/src/components/progressbar.cpp
@@ -8,8 +8,6 @@
 namespace  {
     const char *gChunk = "chunk";
     const char *gBackground = "background";
-
-    const char *gFrame = "Frame";
 }
 
 /*!
@@ -163,15 +161,15 @@ void ProgressBar::setProgressColor(const Vector4 color) {
 void ProgressBar::composeComponent() {
     Widget::composeComponent();
 
-    Actor *background = Engine::composeActor(gFrame, gBackground, actor());
-    Frame *backgroundFrame = static_cast<Frame *>(background->component(gFrame));
+    Actor *background = Engine::composeActor<Frame>(gBackground, actor());
+    Frame *backgroundFrame = background->getComponent<Frame>();
     backgroundFrame->setColor(m_backgroundColor);
     backgroundFrame->rectTransform()->setAnchors(Vector2(0.0f), Vector2(1.0f));
 
     setBackground(backgroundFrame);
 
-    Actor *progress = Engine::composeActor(gFrame, gChunk, background);
-    Frame *progressFrame = static_cast<Frame *>(progress->component(gFrame));
+    Actor *progress = Engine::composeActor<Frame>(gChunk, background);
+    Frame *progressFrame = progress->getComponent<Frame>();
     progressFrame->setColor(m_progressColor);
     progressFrame->setBorderColor(0.0f);
 
diff --git a/modules/uikit/src/components/scrollbar.cpp b/modules/uikit/src/components/scrollbar.cpp
index 5811a0606..d77741184 100644
--- a/modules/uikit/src/components/scrollbar.cpp
+++ b/modules/uikit/src/components/scrollbar.cpp
@@ -12,9 +12,6 @@ namespace {
     const char *gBackArrow("backArrow");
     const char *gFrontArrow("frontArrow");
 
-    const char *gFrameClass("Frame");
-    const char *gButtonClass("Button");
-
     const char *gUiSprite(".embedded/ui.png");
     const char *gSpriteArrow("Arrow");
 }
@@ -223,7 +220,7 @@ void ScrollBar::composeComponent() {
     AbstractSlider::composeComponent();
 
     // Add knob
-    Actor *knobActor = Engine::composeActor(gFrameClass, gKnob, actor());
+    Actor *knobActor = Engine::composeActor<Frame>(gKnob, actor());
     Frame *knob = knobActor->getComponent<Frame>();
     knob->setCorners(Vector4(0.0f));
     knob->setColor(Vector4(0.5f, 0.5f, 0.5f, 1.0f));
@@ -238,7 +235,7 @@ void ScrollBar::composeComponent() {
     setKnob(knob);
 
     // Add back arrow
-    Actor *backActor = Engine::composeActor(gButtonClass, gBackArrow, actor());
+    Actor *backActor = Engine::composeActor<Button>(gBackArrow, actor());
     Button *back = backActor->getComponent<Button>();
     back->setText(TString());
 
@@ -252,7 +249,7 @@ void ScrollBar::composeComponent() {
     setBackArrow(back);
 
     // Add front arrow
-    Actor *frontActor = Engine::composeActor(gButtonClass, gFrontArrow, actor());
+    Actor *frontActor = Engine::composeActor<Button>(gFrontArrow, actor());
     Button *front = frontActor->getComponent<Button>();
     front->setText(TString());
 
diff --git a/modules/uikit/src/components/slider.cpp b/modules/uikit/src/components/slider.cpp
index c1590f247..c9b4a9eb3 100644
--- a/modules/uikit/src/components/slider.cpp
+++ b/modules/uikit/src/components/slider.cpp
@@ -6,9 +6,6 @@
 namespace {
     const char *gBackground("background");
     const char *gKnob("knob");
-
-    const char *gProgressBarClass("ProgressBar");
-    const char *gFrameClass("Frame");
 }
 
 Slider::Slider() :
@@ -110,7 +107,7 @@ void Slider::composeComponent() {
     AbstractSlider::composeComponent();
 
     // Add background
-    Actor *barActor = Engine::composeActor(gProgressBarClass, gBackground, actor());
+    Actor *barActor = Engine::composeActor<ProgressBar>(gBackground, actor());
     ProgressBar *bar = barActor->getComponent<ProgressBar>();
     bar->setValue(m_value);
     bar->setProgressColor(m_normalColor);
@@ -120,7 +117,7 @@ void Slider::composeComponent() {
     setOrientation(Horizontal);
 
     // Add knob
-    Actor *knobActor = Engine::composeActor(gFrameClass, gKnob, actor());
+    Actor *knobActor = Engine::composeActor<Frame>(gKnob, actor());
     Frame *knob = knobActor->getComponent<Frame>();
     knob->setCorners(Vector4(8.0f));
     knob->setColor(Vector4(1.0f));
diff --git a/modules/uikit/src/components/switch.cpp b/modules/uikit/src/components/switch.cpp
index d717e64cd..cd327665b 100644
--- a/modules/uikit/src/components/switch.cpp
+++ b/modules/uikit/src/components/switch.cpp
@@ -12,8 +12,6 @@
 
 namespace  {
     const char *gKnob("knob");
-
-    const char *gFrameClass("Frame");
 }
 
 /*!
@@ -158,7 +156,7 @@ void Switch::composeComponent() {
         }
 
         // Add knob
-        Actor *knob = Engine::composeActor(gFrameClass, gKnob, background()->actor());
+        Actor *knob = Engine::composeActor<Frame>(gKnob, background()->actor());
         Frame *frame = knob->getComponent<Frame>();
         frame->setCorners(background()->corners());
         setKnobGraphic(frame);
diff --git a/modules/uikit/src/components/toolbutton.cpp b/modules/uikit/src/components/toolbutton.cpp
index 46c83244f..9a9403c56 100644
--- a/modules/uikit/src/components/toolbutton.cpp
+++ b/modules/uikit/src/components/toolbutton.cpp
@@ -14,8 +14,8 @@
 #include <input.h>
 
 namespace {
-    const char *gImage = "Image";
-    const char *gMenu = "Menu";
+    const char *gIcon("icon");
+    const char *gMenu("menu");
 
     const char *gMenuFrame = "menu-frame";
 
@@ -105,8 +105,8 @@ void ToolButton::composeComponent() {
         back->rectTransform()->setAnchors(Vector2(0.0f), Vector2(1.0f));
     }
     // Add icon
-    Actor *icon = Engine::composeActor(gImage, gImage, actor());
-    Image *image = static_cast<Image *>(icon->component(gImage));
+    Actor *icon = Engine::composeActor<Image>(gIcon, actor());
+    Image *image = icon->getComponent<Image>();
     image->setSprite(Engine::loadResource<Sprite>(".embedded/ui.png"));
     image->setItem("Arrow");
 
@@ -117,8 +117,8 @@ void ToolButton::composeComponent() {
         t->setPivot(Vector2(1.0f, 0.5f));
     }
 
-    Actor *actor = Engine::composeActor(gMenu, gMenuFrame, ToolButton::actor());
-    Menu *menu = static_cast<Menu *>(actor->component(gMenu));
+    Actor *actor = Engine::composeActor<Menu>(gMenuFrame, ToolButton::actor());
+    Menu *menu = actor->getComponent<Menu>();
 
     setMenu(menu);
 
diff --git a/modules/uikit/src/converters/stylesheetconverter.cpp b/modules/uikit/src/converters/stylesheetconverter.cpp
index e67c364ef..a7401bb06 100644
--- a/modules/uikit/src/converters/stylesheetconverter.cpp
+++ b/modules/uikit/src/converters/stylesheetconverter.cpp
@@ -21,7 +21,7 @@ AssetConverter::ReturnCode StyleSheetConverter::convertFile(AssetConverterSettin
     if(src.open(File::ReadOnly)) {
         StyleSheet *style = Engine::loadResource<StyleSheet>(settings->destination());
         if(style == nullptr) {
-            style = Engine::objectCreate<StyleSheet>();
+            style = Engine::objectCreate<StyleSheet>(settings->destination());
         }
 
         TString array(src.readAll());
@@ -30,7 +30,7 @@ AssetConverter::ReturnCode StyleSheetConverter::convertFile(AssetConverterSettin
             style->setData(array);
         }
 
-        return settings->saveBinary(Engine::toVariant(style));
+        return settings->saveBinary(Engine::toVariant(style), settings->absoluteDestination());
     }
 
     return InternalError;
diff --git a/modules/uikit/src/converters/uiconverter.cpp b/modules/uikit/src/converters/uiconverter.cpp
index 94ef7b14c..4ec47375f 100644
--- a/modules/uikit/src/converters/uiconverter.cpp
+++ b/modules/uikit/src/converters/uiconverter.cpp
@@ -21,7 +21,7 @@ AssetConverter::ReturnCode UiConverter::convertFile(AssetConverterSettings *sett
     if(src.open(File::ReadOnly)) {
         UiDocument *document = Engine::loadResource<UiDocument>(settings->destination());
         if(document == nullptr) {
-            document = Engine::objectCreate<UiDocument>();
+            document = Engine::objectCreate<UiDocument>(settings->destination());
         }
 
         TString data(src.readAll());
@@ -30,7 +30,7 @@ AssetConverter::ReturnCode UiConverter::convertFile(AssetConverterSettings *sett
             document->setData(data);
         }
 
-        return settings->saveBinary(Engine::toVariant(document));
+        return settings->saveBinary(Engine::toVariant(document), settings->absoluteDestination());
     }
 
     return InternalError;
diff --git a/modules/uikit/src/editor/uiedit.cpp b/modules/uikit/src/editor/uiedit.cpp
index c9a292666..7ea3b397f 100644
--- a/modules/uikit/src/editor/uiedit.cpp
+++ b/modules/uikit/src/editor/uiedit.cpp
@@ -25,8 +25,6 @@
 #include "widgetcontroller.h"
 
 namespace {
-    const char *gUiLoader("UiLoader");
-
     const char *gUi("ui");
     const char *gName("name");
     const char *gStyle("style");
@@ -44,7 +42,7 @@ UiEdit::UiEdit() :
 
     ui->setupUi(this);
 
-    Actor *actor = Engine::composeActor(gUiLoader, "Screen", m_scene);
+    Actor *actor = Engine::composeActor<UiLoader>("Screen", m_scene);
     m_loader = actor->getComponent<UiLoader>();
 
     m_controller->setRoot(m_loader);
diff --git a/thirdparty/next/src/core/objectsystem.cpp b/thirdparty/next/src/core/objectsystem.cpp
index 6dfc5c0c5..e8f916b1f 100644
--- a/thirdparty/next/src/core/objectsystem.cpp
+++ b/thirdparty/next/src/core/objectsystem.cpp
@@ -294,16 +294,16 @@ Object *ObjectSystem::toObject(const Variant &variant, Object *parent, const TSt
             }
             i++;
 
-            Object *p = parent;
-            Object *obj = nullptr;
+            Object *parentObject = parent;
+            Object *tempObject = nullptr;
             auto localIt = localCache.find(parentUuid);
             if(localIt != localCache.end()) {
-                obj = localIt->second;
+                tempObject = localIt->second;
             } else {
-                obj = findObject(parentUuid);
+                tempObject = findObject(parentUuid);
             }
-            if(obj != nullptr) {
-                p = obj;
+            if(tempObject != nullptr) {
+                parentObject = tempObject;
             }
 
             Object *object = nullptr;
@@ -315,7 +315,7 @@ Object *ObjectSystem::toObject(const Variant &variant, Object *parent, const TSt
             }
 
             if(object == nullptr) {
-                object = objectCreate(type, n, p);
+                object = objectCreate(type, n, parentObject);
 
                 if(object && uuid != 0) {
                     replaceUUID(object, uuid);
@@ -328,15 +328,15 @@ Object *ObjectSystem::toObject(const Variant &variant, Object *parent, const TSt
                 Invalid *invalid = new Invalid();
                 invalid->loadData(o);
                 object = invalid;
-                if(p) {
-                    object->setSystem(p->system());
+                if(parentObject) {
+                    object->setSystem(parentObject->system());
                 }
                 if(uuid != 0) {
                     replaceUUID(object, uuid);
                     localCache[uuid] = object;
                 }
                 object->setName(n);
-                object->setParent(p);
+                object->setParent(parentObject);
             }
 
             i++;
diff --git a/worldeditor/src/managers/assetimporter/iconrender.cpp b/worldeditor/src/managers/assetimporter/iconrender.cpp
index 2fb9aadb6..5f882f1fb 100644
--- a/worldeditor/src/managers/assetimporter/iconrender.cpp
+++ b/worldeditor/src/managers/assetimporter/iconrender.cpp
@@ -29,7 +29,7 @@ IconRender::IconRender(QObject *parent) :
         m_render(nullptr),
         m_color(nullptr) {
 
-    m_actor = Engine::composeActor("Camera", "ActiveCamera", m_scene);
+    m_actor = Engine::composeActor<Camera>("ActiveCamera", m_scene);
     m_actor->transform()->setPosition(Vector3(0.0f, 0.0f, 0.0f));
     m_camera = m_actor->getComponent<Camera>();
     m_camera->setOrthographic(true);
@@ -77,7 +77,7 @@ const QImage IconRender::render(const TString &uuid) {
             context->subscribePost(IconRender::readPixels, this);
         }
 
-        m_light = Engine::composeActor("DirectLight", "LightSource", m_scene);
+        m_light = Engine::composeActor<DirectLight>("LightSource", m_scene);
         m_light->transform()->setQuaternion(Vector3(-45.0f, 45.0f, 0.0f));
     }
 
diff --git a/worldeditor/src/screens/scenecomposer/scenecomposer.cpp b/worldeditor/src/screens/scenecomposer/scenecomposer.cpp
index ce962c0f3..ae5faae99 100644
--- a/worldeditor/src/screens/scenecomposer/scenecomposer.cpp
+++ b/worldeditor/src/screens/scenecomposer/scenecomposer.cpp
@@ -17,6 +17,7 @@
 #include <components/scene.h>
 #include <components/camera.h>
 #include <components/transform.h>
+#include <components/directlight.h>
 
 #include <resources/prefab.h>
 #include <resources/map.h>
@@ -113,7 +114,7 @@ SceneComposer::SceneComposer(QWidget *parent) :
     ui->renderMode->setMenu(new QMenu);
     ui->isolationPanel->setVisible(false);
 
-    Actor *actor = Engine::composeActor("DirectLight", "SceneLight", m_isolationScene);
+    Actor *actor = Engine::composeActor<DirectLight>("SceneLight", m_isolationScene);
     if(actor) {
         actor->transform()->setRotation(Vector3(0.0f, 45.0f, 50.0f));
     }