diff --git a/openpype/hosts/blender/plugins/publish/extract_layout.py b/openpype/hosts/blender/plugins/publish/extract_layout.py
index 75d9cf440d..8502c6fbd4 100644
--- a/openpype/hosts/blender/plugins/publish/extract_layout.py
+++ b/openpype/hosts/blender/plugins/publish/extract_layout.py
@@ -180,7 +180,7 @@ class ExtractLayout(openpype.api.Extractor):
                 "rotation": {
                     "x": asset.rotation_euler.x,
                     "y": asset.rotation_euler.y,
-                    "z": asset.rotation_euler.z,
+                    "z": asset.rotation_euler.z
                 },
                 "scale": {
                     "x": asset.scale.x,
@@ -189,6 +189,18 @@ class ExtractLayout(openpype.api.Extractor):
                 }
             }
 
+            json_element["transform_matrix"] = []
+
+            for row in list(asset.matrix_world.transposed()):
+                json_element["transform_matrix"].append(list(row))
+
+            json_element["basis"] = [
+                [1, 0, 0, 0],
+                [0, -1, 0, 0],
+                [0, 0, 1, 0],
+                [0, 0, 0, 1]
+            ]
+
             # Extract the animation as well
             if family == "rig":
                 f, n = self._export_animation(
diff --git a/openpype/hosts/maya/plugins/publish/extract_layout.py b/openpype/hosts/maya/plugins/publish/extract_layout.py
new file mode 100644
index 0000000000..991217684a
--- /dev/null
+++ b/openpype/hosts/maya/plugins/publish/extract_layout.py
@@ -0,0 +1,146 @@
+import math
+import os
+import json
+
+from maya import cmds
+from maya.api import OpenMaya as om
+
+from bson.objectid import ObjectId
+
+from openpype.pipeline import legacy_io
+import openpype.api
+
+
+class ExtractLayout(openpype.api.Extractor):
+    """Extract a layout."""
+
+    label = "Extract Layout"
+    hosts = ["maya"]
+    families = ["layout"]
+    optional = True
+
+    def process(self, instance):
+        # Define extract output file path
+        stagingdir = self.staging_dir(instance)
+
+        # Perform extraction
+        self.log.info("Performing extraction..")
+
+        if "representations" not in instance.data:
+            instance.data["representations"] = []
+
+        json_data = []
+
+        for asset in cmds.sets(str(instance), query=True):
+            # Find the container
+            grp_name = asset.split(':')[0]
+            containers = cmds.ls(f"{grp_name}*_CON")
+
+            assert len(containers) == 1, \
+                f"More than one container found for {asset}"
+
+            container = containers[0]
+
+            representation_id = cmds.getAttr(f"{container}.representation")
+
+            representation = legacy_io.find_one(
+                {
+                    "type": "representation",
+                    "_id": ObjectId(representation_id)
+                }, projection={"parent": True, "context.family": True})
+
+            self.log.info(representation)
+
+            version_id = representation.get("parent")
+            family = representation.get("context").get("family")
+
+            json_element = {
+                "family": family,
+                "instance_name": cmds.getAttr(f"{container}.name"),
+                "representation": str(representation_id),
+                "version": str(version_id)
+            }
+
+            loc = cmds.xform(asset, query=True, translation=True)
+            rot = cmds.xform(asset, query=True, rotation=True, euler=True)
+            scl = cmds.xform(asset, query=True, relative=True, scale=True)
+
+            json_element["transform"] = {
+                "translation": {
+                    "x": loc[0],
+                    "y": loc[1],
+                    "z": loc[2]
+                },
+                "rotation": {
+                    "x": math.radians(rot[0]),
+                    "y": math.radians(rot[1]),
+                    "z": math.radians(rot[2])
+                },
+                "scale": {
+                    "x": scl[0],
+                    "y": scl[1],
+                    "z": scl[2]
+                }
+            }
+
+            row_length = 4
+            t_matrix_list = cmds.xform(asset, query=True, matrix=True)
+
+            transform_mm = om.MMatrix(t_matrix_list)
+            transform = om.MTransformationMatrix(transform_mm)
+
+            t = transform.translation(om.MSpace.kWorld)
+            t = om.MVector(t.x, t.z, -t.y)
+            transform.setTranslation(t, om.MSpace.kWorld)
+            transform.rotateBy(
+                om.MEulerRotation(math.radians(-90), 0, 0), om.MSpace.kWorld)
+            transform.scaleBy([1.0, 1.0, -1.0], om.MSpace.kObject)
+
+            t_matrix_list = list(transform.asMatrix())
+
+            t_matrix = []
+            for i in range(0, len(t_matrix_list), row_length):
+                t_matrix.append(t_matrix_list[i:i + row_length])
+
+            json_element["transform_matrix"] = []
+            for row in t_matrix:
+                json_element["transform_matrix"].append(list(row))
+
+            basis_list = [
+                1, 0, 0, 0,
+                0, 1, 0, 0,
+                0, 0, -1, 0,
+                0, 0, 0, 1
+            ]
+
+            basis_mm = om.MMatrix(basis_list)
+            basis = om.MTransformationMatrix(basis_mm)
+
+            b_matrix_list = list(basis.asMatrix())
+            b_matrix = []
+
+            for i in range(0, len(b_matrix_list), row_length):
+                b_matrix.append(b_matrix_list[i:i + row_length])
+
+            json_element["basis"] = []
+            for row in b_matrix:
+                json_element["basis"].append(list(row))
+
+            json_data.append(json_element)
+
+        json_filename = "{}.json".format(instance.name)
+        json_path = os.path.join(stagingdir, json_filename)
+
+        with open(json_path, "w+") as file:
+            json.dump(json_data, fp=file, indent=2)
+
+        json_representation = {
+            'name': 'json',
+            'ext': 'json',
+            'files': json_filename,
+            "stagingDir": stagingdir,
+        }
+        instance.data["representations"].append(json_representation)
+
+        self.log.info("Extracted instance '%s' to: %s",
+                      instance.name, json_representation)
diff --git a/openpype/hosts/unreal/plugins/load/load_alembic_skeletalmesh.py b/openpype/hosts/unreal/plugins/load/load_alembic_skeletalmesh.py
index b2c3889f68..9fe5f3ab4b 100644
--- a/openpype/hosts/unreal/plugins/load/load_alembic_skeletalmesh.py
+++ b/openpype/hosts/unreal/plugins/load/load_alembic_skeletalmesh.py
@@ -20,6 +20,34 @@ class SkeletalMeshAlembicLoader(plugin.Loader):
     icon = "cube"
     color = "orange"
 
+    def get_task(self, filename, asset_dir, asset_name, replace):
+        task = unreal.AssetImportTask()
+        options = unreal.AbcImportSettings()
+        sm_settings = unreal.AbcStaticMeshSettings()
+        conversion_settings = unreal.AbcConversionSettings(
+            preset=unreal.AbcConversionPreset.CUSTOM,
+            flip_u=False, flip_v=False,
+            rotation=[0.0, 0.0, 0.0],
+            scale=[1.0, 1.0, 1.0])
+
+        task.set_editor_property('filename', filename)
+        task.set_editor_property('destination_path', asset_dir)
+        task.set_editor_property('destination_name', asset_name)
+        task.set_editor_property('replace_existing', replace)
+        task.set_editor_property('automated', True)
+        task.set_editor_property('save', True)
+
+        # set import options here
+        # Unreal 4.24 ignores the settings. It works with Unreal 4.26
+        options.set_editor_property(
+            'import_type', unreal.AlembicImportType.SKELETAL)
+
+        options.static_mesh_settings = sm_settings
+        options.conversion_settings = conversion_settings
+        task.options = options
+
+        return task
+
     def load(self, context, name, namespace, data):
         """Load and containerise representation into Content Browser.
 
@@ -50,36 +78,24 @@ class SkeletalMeshAlembicLoader(plugin.Loader):
             asset_name = "{}_{}".format(asset, name)
         else:
             asset_name = "{}".format(name)
+        version = context.get('version').get('name')
 
         tools = unreal.AssetToolsHelpers().get_asset_tools()
         asset_dir, container_name = tools.create_unique_asset_name(
-            "{}/{}/{}".format(root, asset, name), suffix="")
+            f"{root}/{asset}/{name}_v{version:03d}", suffix="")
 
         container_name += suffix
 
-        unreal.EditorAssetLibrary.make_directory(asset_dir)
+        if not unreal.EditorAssetLibrary.does_directory_exist(asset_dir):
+            unreal.EditorAssetLibrary.make_directory(asset_dir)
 
-        task = unreal.AssetImportTask()
+            task = self.get_task(self.fname, asset_dir, asset_name, False)
 
-        task.set_editor_property('filename', self.fname)
-        task.set_editor_property('destination_path', asset_dir)
-        task.set_editor_property('destination_name', asset_name)
-        task.set_editor_property('replace_existing', False)
-        task.set_editor_property('automated', True)
-        task.set_editor_property('save', True)
+            unreal.AssetToolsHelpers.get_asset_tools().import_asset_tasks([task])  # noqa: E501
 
-        # set import options here
-        # Unreal 4.24 ignores the settings. It works with Unreal 4.26
-        options = unreal.AbcImportSettings()
-        options.set_editor_property(
-            'import_type', unreal.AlembicImportType.SKELETAL)
-
-        task.options = options
-        unreal.AssetToolsHelpers.get_asset_tools().import_asset_tasks([task])  # noqa: E501
-
-        # Create Asset Container
-        unreal_pipeline.create_container(
-            container=container_name, path=asset_dir)
+            # Create Asset Container
+            unreal_pipeline.create_container(
+                container=container_name, path=asset_dir)
 
         data = {
             "schema": "openpype:container-2.0",
@@ -110,23 +126,8 @@ class SkeletalMeshAlembicLoader(plugin.Loader):
         source_path = get_representation_path(representation)
         destination_path = container["namespace"]
 
-        task = unreal.AssetImportTask()
+        task = self.get_task(source_path, destination_path, name, True)
 
-        task.set_editor_property('filename', source_path)
-        task.set_editor_property('destination_path', destination_path)
-        # strip suffix
-        task.set_editor_property('destination_name', name)
-        task.set_editor_property('replace_existing', True)
-        task.set_editor_property('automated', True)
-        task.set_editor_property('save', True)
-
-        # set import options here
-        # Unreal 4.24 ignores the settings. It works with Unreal 4.26
-        options = unreal.AbcImportSettings()
-        options.set_editor_property(
-            'import_type', unreal.AlembicImportType.SKELETAL)
-
-        task.options = options
         # do import fbx and replace existing data
         unreal.AssetToolsHelpers.get_asset_tools().import_asset_tasks([task])
         container_path = "{}/{}".format(container["namespace"],
diff --git a/openpype/hosts/unreal/plugins/load/load_alembic_staticmesh.py b/openpype/hosts/unreal/plugins/load/load_alembic_staticmesh.py
index 5a73c72c64..50e498dbb0 100644
--- a/openpype/hosts/unreal/plugins/load/load_alembic_staticmesh.py
+++ b/openpype/hosts/unreal/plugins/load/load_alembic_staticmesh.py
@@ -24,7 +24,11 @@ class StaticMeshAlembicLoader(plugin.Loader):
         task = unreal.AssetImportTask()
         options = unreal.AbcImportSettings()
         sm_settings = unreal.AbcStaticMeshSettings()
-        conversion_settings = unreal.AbcConversionSettings()
+        conversion_settings = unreal.AbcConversionSettings(
+            preset=unreal.AbcConversionPreset.CUSTOM,
+            flip_u=False, flip_v=False,
+            rotation=[0.0, 0.0, 0.0],
+            scale=[1.0, 1.0, 1.0])
 
         task.set_editor_property('filename', filename)
         task.set_editor_property('destination_path', asset_dir)
@@ -40,13 +44,6 @@ class StaticMeshAlembicLoader(plugin.Loader):
 
         sm_settings.set_editor_property('merge_meshes', True)
 
-        conversion_settings.set_editor_property('flip_u', False)
-        conversion_settings.set_editor_property('flip_v', True)
-        conversion_settings.set_editor_property(
-            'scale', unreal.Vector(x=100.0, y=100.0, z=100.0))
-        conversion_settings.set_editor_property(
-            'rotation', unreal.Vector(x=-90.0, y=0.0, z=180.0))
-
         options.static_mesh_settings = sm_settings
         options.conversion_settings = conversion_settings
         task.options = options
@@ -83,22 +80,24 @@ class StaticMeshAlembicLoader(plugin.Loader):
             asset_name = "{}_{}".format(asset, name)
         else:
             asset_name = "{}".format(name)
+        version = context.get('version').get('name')
 
         tools = unreal.AssetToolsHelpers().get_asset_tools()
         asset_dir, container_name = tools.create_unique_asset_name(
-            "{}/{}/{}".format(root, asset, name), suffix="")
+            f"{root}/{asset}/{name}_v{version:03d}", suffix="")
 
         container_name += suffix
 
-        unreal.EditorAssetLibrary.make_directory(asset_dir)
+        if not unreal.EditorAssetLibrary.does_directory_exist(asset_dir):
+            unreal.EditorAssetLibrary.make_directory(asset_dir)
 
-        task = self.get_task(self.fname, asset_dir, asset_name, False)
+            task = self.get_task(self.fname, asset_dir, asset_name, False)
 
-        unreal.AssetToolsHelpers.get_asset_tools().import_asset_tasks([task])  # noqa: E501
+            unreal.AssetToolsHelpers.get_asset_tools().import_asset_tasks([task])  # noqa: E501
 
-        # Create Asset Container
-        unreal_pipeline.create_container(
-            container=container_name, path=asset_dir)
+            # Create Asset Container
+            unreal_pipeline.create_container(
+                container=container_name, path=asset_dir)
 
         data = {
             "schema": "openpype:container-2.0",
diff --git a/openpype/hosts/unreal/plugins/load/load_layout.py b/openpype/hosts/unreal/plugins/load/load_layout.py
index 01d589c69b..926c932a85 100644
--- a/openpype/hosts/unreal/plugins/load/load_layout.py
+++ b/openpype/hosts/unreal/plugins/load/load_layout.py
@@ -9,7 +9,10 @@ from unreal import EditorLevelLibrary
 from unreal import EditorLevelUtils
 from unreal import AssetToolsHelpers
 from unreal import FBXImportType
-from unreal import MathLibrary as umath
+from unreal import MovieSceneLevelVisibilityTrack
+from unreal import MovieSceneSubTrack
+
+from bson.objectid import ObjectId
 
 from openpype.client import get_asset_by_name, get_assets
 from openpype.pipeline import (
@@ -21,6 +24,7 @@ from openpype.pipeline import (
     legacy_io,
 )
 from openpype.pipeline.context_tools import get_current_project_asset
+from openpype.api import get_current_project_settings
 from openpype.hosts.unreal.api import plugin
 from openpype.hosts.unreal.api import pipeline as unreal_pipeline
 
@@ -159,9 +163,29 @@ class LayoutLoader(plugin.Loader):
             hid_section.set_row_index(index)
             hid_section.set_level_names(maps)
 
-    @staticmethod
+    def _transform_from_basis(self, transform, basis):
+        """Transform a transform from a basis to a new basis."""
+        # Get the basis matrix
+        basis_matrix = unreal.Matrix(
+            basis[0],
+            basis[1],
+            basis[2],
+            basis[3]
+        )
+        transform_matrix = unreal.Matrix(
+            transform[0],
+            transform[1],
+            transform[2],
+            transform[3]
+        )
+
+        new_transform = (
+            basis_matrix.get_inverse() * transform_matrix * basis_matrix)
+
+        return new_transform.transform()
+
     def _process_family(
-        assets, class_name, transform, sequence, inst_name=None
+        self, assets, class_name, transform, basis, sequence, inst_name=None
     ):
         ar = unreal.AssetRegistryHelpers.get_asset_registry()
 
@@ -171,30 +195,12 @@ class LayoutLoader(plugin.Loader):
         for asset in assets:
             obj = ar.get_asset_by_object_path(asset).get_asset()
             if obj.get_class().get_name() == class_name:
+                t = self._transform_from_basis(transform, basis)
                 actor = EditorLevelLibrary.spawn_actor_from_object(
-                    obj,
-                    transform.get('translation')
+                    obj, t.translation
                 )
-                if inst_name:
-                    try:
-                        # Rename method leads to crash
-                        # actor.rename(name=inst_name)
-
-                        # The label works, although it make it slightly more
-                        # complicated to check for the names, as we need to
-                        # loop through all the actors in the level
-                        actor.set_actor_label(inst_name)
-                    except Exception as e:
-                        print(e)
-                actor.set_actor_rotation(unreal.Rotator(
-                    umath.radians_to_degrees(
-                        transform.get('rotation').get('x')),
-                    -umath.radians_to_degrees(
-                        transform.get('rotation').get('y')),
-                    umath.radians_to_degrees(
-                        transform.get('rotation').get('z')),
-                ), False)
-                actor.set_actor_scale3d(transform.get('scale'))
+                actor.set_actor_rotation(t.rotation.rotator(), False)
+                actor.set_actor_scale3d(t.scale3d)
 
                 if class_name == 'SkeletalMesh':
                     skm_comp = actor.get_editor_property(
@@ -203,16 +209,17 @@ class LayoutLoader(plugin.Loader):
 
                 actors.append(actor)
 
-                binding = None
-                for p in sequence.get_possessables():
-                    if p.get_name() == actor.get_name():
-                        binding = p
-                        break
+                if sequence:
+                    binding = None
+                    for p in sequence.get_possessables():
+                        if p.get_name() == actor.get_name():
+                            binding = p
+                            break
 
-                if not binding:
-                    binding = sequence.add_possessable(actor)
+                    if not binding:
+                        binding = sequence.add_possessable(actor)
 
-                bindings.append(binding)
+                    bindings.append(binding)
 
         return actors, bindings
 
@@ -301,52 +308,53 @@ class LayoutLoader(plugin.Loader):
             actor.skeletal_mesh_component.animation_data.set_editor_property(
                 'anim_to_play', animation)
 
-            # Add animation to the sequencer
-            bindings = bindings_dict.get(instance_name)
+            if sequence:
+                # Add animation to the sequencer
+                bindings = bindings_dict.get(instance_name)
 
-            ar = unreal.AssetRegistryHelpers.get_asset_registry()
+                ar = unreal.AssetRegistryHelpers.get_asset_registry()
 
-            for binding in bindings:
-                tracks = binding.get_tracks()
-                track = None
-                track = tracks[0] if tracks else binding.add_track(
-                    unreal.MovieSceneSkeletalAnimationTrack)
+                for binding in bindings:
+                    tracks = binding.get_tracks()
+                    track = None
+                    track = tracks[0] if tracks else binding.add_track(
+                        unreal.MovieSceneSkeletalAnimationTrack)
 
-                sections = track.get_sections()
-                section = None
-                if not sections:
-                    section = track.add_section()
-                else:
-                    section = sections[0]
+                    sections = track.get_sections()
+                    section = None
+                    if not sections:
+                        section = track.add_section()
+                    else:
+                        section = sections[0]
 
+                        sec_params = section.get_editor_property('params')
+                        curr_anim = sec_params.get_editor_property('animation')
+
+                        if curr_anim:
+                            # Checks if the animation path has a container.
+                            # If it does, it means that the animation is
+                            # already in the sequencer.
+                            anim_path = str(Path(
+                                curr_anim.get_path_name()).parent
+                            ).replace('\\', '/')
+
+                            _filter = unreal.ARFilter(
+                                class_names=["AssetContainer"],
+                                package_paths=[anim_path],
+                                recursive_paths=False)
+                            containers = ar.get_assets(_filter)
+
+                            if len(containers) > 0:
+                                return
+
+                    section.set_range(
+                        sequence.get_playback_start(),
+                        sequence.get_playback_end())
                     sec_params = section.get_editor_property('params')
-                    curr_anim = sec_params.get_editor_property('animation')
-
-                    if curr_anim:
-                        # Checks if the animation path has a container.
-                        # If it does, it means that the animation is already
-                        # in the sequencer.
-                        anim_path = str(Path(
-                            curr_anim.get_path_name()).parent
-                        ).replace('\\', '/')
-
-                        _filter = unreal.ARFilter(
-                            class_names=["AssetContainer"],
-                            package_paths=[anim_path],
-                            recursive_paths=False)
-                        containers = ar.get_assets(_filter)
-
-                        if len(containers) > 0:
-                            return
-
-                section.set_range(
-                    sequence.get_playback_start(),
-                    sequence.get_playback_end())
-                sec_params = section.get_editor_property('params')
-                sec_params.set_editor_property('animation', animation)
+                    sec_params.set_editor_property('animation', animation)
 
     @staticmethod
-    def _generate_sequence(self, h, h_dir):
+    def _generate_sequence(h, h_dir):
         tools = unreal.AssetToolsHelpers().get_asset_tools()
 
         sequence = tools.create_asset(
@@ -402,7 +410,7 @@ class LayoutLoader(plugin.Loader):
 
         return sequence, (min_frame, max_frame)
 
-    def _process(self, lib_path, asset_dir, sequence, loaded=None):
+    def _process(self, lib_path, asset_dir, sequence, repr_loaded=None):
         ar = unreal.AssetRegistryHelpers.get_asset_registry()
 
         with open(lib_path, "r") as fp:
@@ -410,8 +418,8 @@ class LayoutLoader(plugin.Loader):
 
         all_loaders = discover_loader_plugins()
 
-        if not loaded:
-            loaded = []
+        if not repr_loaded:
+            repr_loaded = []
 
         path = Path(lib_path)
 
@@ -422,36 +430,65 @@ class LayoutLoader(plugin.Loader):
         loaded_assets = []
 
         for element in data:
-            reference = None
-            if element.get('reference_fbx'):
-                reference = element.get('reference_fbx')
+            representation = None
+            repr_format = None
+            if element.get('representation'):
+                # representation = element.get('representation')
+
+                self.log.info(element.get("version"))
+
+                valid_formats = ['fbx', 'abc']
+
+                repr_data = legacy_io.find_one({
+                    "type": "representation",
+                    "parent": ObjectId(element.get("version")),
+                    "name": {"$in": valid_formats}
+                })
+                repr_format = repr_data.get('name')
+
+                if not repr_data:
+                    self.log.error(
+                        f"No valid representation found for version "
+                        f"{element.get('version')}")
+                    continue
+
+                representation = str(repr_data.get('_id'))
+                print(representation)
+            # This is to keep compatibility with old versions of the
+            # json format.
+            elif element.get('reference_fbx'):
+                representation = element.get('reference_fbx')
+                repr_format = 'fbx'
             elif element.get('reference_abc'):
-                reference = element.get('reference_abc')
+                representation = element.get('reference_abc')
+                repr_format = 'abc'
 
             # If reference is None, this element is skipped, as it cannot be
             # imported in Unreal
-            if not reference:
+            if not representation:
                 continue
 
             instance_name = element.get('instance_name')
 
             skeleton = None
 
-            if reference not in loaded:
-                loaded.append(reference)
+            if representation not in repr_loaded:
+                repr_loaded.append(representation)
 
                 family = element.get('family')
                 loaders = loaders_from_representation(
-                    all_loaders, reference)
+                    all_loaders, representation)
 
                 loader = None
 
-                if reference == element.get('reference_fbx'):
+                if repr_format == 'fbx':
                     loader = self._get_fbx_loader(loaders, family)
-                elif reference == element.get('reference_abc'):
+                elif repr_format == 'abc':
                     loader = self._get_abc_loader(loaders, family)
 
                 if not loader:
+                    self.log.error(
+                        f"No valid loader found for {representation}")
                     continue
 
                 options = {
@@ -460,7 +497,7 @@ class LayoutLoader(plugin.Loader):
 
                 assets = load_container(
                     loader,
-                    reference,
+                    representation,
                     namespace=instance_name,
                     options=options
                 )
@@ -478,28 +515,36 @@ class LayoutLoader(plugin.Loader):
 
                 instances = [
                     item for item in data
-                    if (item.get('reference_fbx') == reference or
-                        item.get('reference_abc') == reference)]
+                    if ((item.get('version') and
+                        item.get('version') == element.get('version')) or
+                        item.get('reference_fbx') == representation or
+                        item.get('reference_abc') == representation)]
 
                 for instance in instances:
-                    transform = instance.get('transform')
+                    # transform = instance.get('transform')
+                    transform = instance.get('transform_matrix')
+                    basis = instance.get('basis')
                     inst = instance.get('instance_name')
 
                     actors = []
 
                     if family == 'model':
                         actors, _ = self._process_family(
-                            assets, 'StaticMesh', transform, sequence, inst)
+                            assets, 'StaticMesh', transform, basis,
+                            sequence, inst
+                        )
                     elif family == 'rig':
                         actors, bindings = self._process_family(
-                            assets, 'SkeletalMesh', transform, sequence, inst)
+                            assets, 'SkeletalMesh', transform, basis,
+                            sequence, inst
+                        )
                         actors_dict[inst] = actors
                         bindings_dict[inst] = bindings
 
                 if skeleton:
-                    skeleton_dict[reference] = skeleton
+                    skeleton_dict[representation] = skeleton
             else:
-                skeleton = skeleton_dict.get(reference)
+                skeleton = skeleton_dict.get(representation)
 
             animation_file = element.get('animation')
 
@@ -573,6 +618,9 @@ class LayoutLoader(plugin.Loader):
         Returns:
             list(str): list of container content
         """
+        data = get_current_project_settings()
+        create_sequences = data["unreal"]["level_sequences_for_layouts"]
+
         # Create directory for asset and avalon container
         hierarchy = context.get('asset').get('data').get('parents')
         root = self.ASSET_ROOT
@@ -593,81 +641,88 @@ class LayoutLoader(plugin.Loader):
 
         EditorAssetLibrary.make_directory(asset_dir)
 
-        # Create map for the shot, and create hierarchy of map. If the maps
-        # already exist, we will use them.
-        h_dir = hierarchy_dir_list[0]
-        h_asset = hierarchy[0]
-        master_level = f"{h_dir}/{h_asset}_map.{h_asset}_map"
-        if not EditorAssetLibrary.does_asset_exist(master_level):
-            EditorLevelLibrary.new_level(f"{h_dir}/{h_asset}_map")
+        master_level = None
+        shot = None
+        sequences = []
 
         level = f"{asset_dir}/{asset}_map.{asset}_map"
         EditorLevelLibrary.new_level(f"{asset_dir}/{asset}_map")
 
-        EditorLevelLibrary.load_level(master_level)
-        EditorLevelUtils.add_level_to_world(
-            EditorLevelLibrary.get_editor_world(),
-            level,
-            unreal.LevelStreamingDynamic
-        )
-        EditorLevelLibrary.save_all_dirty_levels()
-        EditorLevelLibrary.load_level(level)
+        if create_sequences:
+            # Create map for the shot, and create hierarchy of map. If the
+            # maps already exist, we will use them.
+            if hierarchy:
+                h_dir = hierarchy_dir_list[0]
+                h_asset = hierarchy[0]
+                master_level = f"{h_dir}/{h_asset}_map.{h_asset}_map"
+                if not EditorAssetLibrary.does_asset_exist(master_level):
+                    EditorLevelLibrary.new_level(f"{h_dir}/{h_asset}_map")
 
-        # Get all the sequences in the hierarchy. It will create them, if
-        # they don't exist.
-        sequences = []
-        frame_ranges = []
-        for (h_dir, h) in zip(hierarchy_dir_list, hierarchy):
-            root_content = EditorAssetLibrary.list_assets(
-                h_dir, recursive=False, include_folder=False)
+            if master_level:
+                EditorLevelLibrary.load_level(master_level)
+                EditorLevelUtils.add_level_to_world(
+                    EditorLevelLibrary.get_editor_world(),
+                    level,
+                    unreal.LevelStreamingDynamic
+                )
+                EditorLevelLibrary.save_all_dirty_levels()
+                EditorLevelLibrary.load_level(level)
 
-            existing_sequences = [
-                EditorAssetLibrary.find_asset_data(asset)
-                for asset in root_content
-                if EditorAssetLibrary.find_asset_data(
-                    asset).get_class().get_name() == 'LevelSequence'
-            ]
+            # Get all the sequences in the hierarchy. It will create them, if
+            # they don't exist.
+            frame_ranges = []
+            for (h_dir, h) in zip(hierarchy_dir_list, hierarchy):
+                root_content = EditorAssetLibrary.list_assets(
+                    h_dir, recursive=False, include_folder=False)
 
-            if not existing_sequences:
-                sequence, frame_range = self._generate_sequence(h, h_dir)
+                existing_sequences = [
+                    EditorAssetLibrary.find_asset_data(asset)
+                    for asset in root_content
+                    if EditorAssetLibrary.find_asset_data(
+                        asset).get_class().get_name() == 'LevelSequence'
+                ]
 
-                sequences.append(sequence)
-                frame_ranges.append(frame_range)
-            else:
-                for e in existing_sequences:
-                    sequences.append(e.get_asset())
-                    frame_ranges.append((
-                        e.get_asset().get_playback_start(),
-                        e.get_asset().get_playback_end()))
+                if not existing_sequences:
+                    sequence, frame_range = self._generate_sequence(h, h_dir)
 
-        shot = tools.create_asset(
-            asset_name=asset,
-            package_path=asset_dir,
-            asset_class=unreal.LevelSequence,
-            factory=unreal.LevelSequenceFactoryNew()
-        )
+                    sequences.append(sequence)
+                    frame_ranges.append(frame_range)
+                else:
+                    for e in existing_sequences:
+                        sequences.append(e.get_asset())
+                        frame_ranges.append((
+                            e.get_asset().get_playback_start(),
+                            e.get_asset().get_playback_end()))
 
-        # sequences and frame_ranges have the same length
-        for i in range(0, len(sequences) - 1):
-            self._set_sequence_hierarchy(
-                sequences[i], sequences[i + 1],
-                frame_ranges[i][1],
-                frame_ranges[i + 1][0], frame_ranges[i + 1][1],
-                [level])
+            shot = tools.create_asset(
+                asset_name=asset,
+                package_path=asset_dir,
+                asset_class=unreal.LevelSequence,
+                factory=unreal.LevelSequenceFactoryNew()
+            )
 
-        project_name = legacy_io.active_project()
-        data = get_asset_by_name(project_name, asset)["data"]
-        shot.set_display_rate(
-            unreal.FrameRate(data.get("fps"), 1.0))
-        shot.set_playback_start(0)
-        shot.set_playback_end(data.get('clipOut') - data.get('clipIn') + 1)
-        self._set_sequence_hierarchy(
-            sequences[-1], shot,
-            frame_ranges[-1][1],
-            data.get('clipIn'), data.get('clipOut'),
-            [level])
+            # sequences and frame_ranges have the same length
+            for i in range(0, len(sequences) - 1):
+                self._set_sequence_hierarchy(
+                    sequences[i], sequences[i + 1],
+                    frame_ranges[i][1],
+                    frame_ranges[i + 1][0], frame_ranges[i + 1][1],
+                    [level])
 
-        EditorLevelLibrary.load_level(level)
+            project_name = legacy_io.active_project()
+            data = get_asset_by_name(project_name, asset)["data"]
+            shot.set_display_rate(
+                unreal.FrameRate(data.get("fps"), 1.0))
+            shot.set_playback_start(0)
+            shot.set_playback_end(data.get('clipOut') - data.get('clipIn') + 1)
+            if sequences:
+                self._set_sequence_hierarchy(
+                    sequences[-1], shot,
+                    frame_ranges[-1][1],
+                    data.get('clipIn'), data.get('clipOut'),
+                    [level])
+
+            EditorLevelLibrary.load_level(level)
 
         loaded_assets = self._process(self.fname, asset_dir, shot)
 
@@ -702,32 +757,47 @@ class LayoutLoader(plugin.Loader):
         for a in asset_content:
             EditorAssetLibrary.save_asset(a)
 
-        EditorLevelLibrary.load_level(master_level)
+        if master_level:
+            EditorLevelLibrary.load_level(master_level)
 
         return asset_content
 
     def update(self, container, representation):
+        data = get_current_project_settings()
+        create_sequences = data["unreal"]["level_sequences_for_layouts"]
+
         ar = unreal.AssetRegistryHelpers.get_asset_registry()
 
         root = "/Game/OpenPype"
 
         asset_dir = container.get('namespace')
-
         context = representation.get("context")
 
-        hierarchy = context.get('hierarchy').split("/")
-        h_dir = f"{root}/{hierarchy[0]}"
-        h_asset = hierarchy[0]
-        master_level = f"{h_dir}/{h_asset}_map.{h_asset}_map"
+        sequence = None
+        master_level = None
 
-        # # Create a temporary level to delete the layout level.
-        # EditorLevelLibrary.save_all_dirty_levels()
-        # EditorAssetLibrary.make_directory(f"{root}/tmp")
-        # tmp_level = f"{root}/tmp/temp_map"
-        # if not EditorAssetLibrary.does_asset_exist(f"{tmp_level}.temp_map"):
-        #     EditorLevelLibrary.new_level(tmp_level)
-        # else:
-        #     EditorLevelLibrary.load_level(tmp_level)
+        if create_sequences:
+            hierarchy = context.get('hierarchy').split("/")
+            h_dir = f"{root}/{hierarchy[0]}"
+            h_asset = hierarchy[0]
+            master_level = f"{h_dir}/{h_asset}_map.{h_asset}_map"
+
+            filter = unreal.ARFilter(
+                class_names=["LevelSequence"],
+                package_paths=[asset_dir],
+                recursive_paths=False)
+            sequences = ar.get_assets(filter)
+            sequence = sequences[0].get_asset()
+
+        prev_level = None
+
+        if not master_level:
+            curr_level = unreal.LevelEditorSubsystem().get_current_level()
+            curr_level_path = curr_level.get_outer().get_path_name()
+            # If the level path does not start with "/Game/", the current
+            # level is a temporary, unsaved level.
+            if curr_level_path.startswith("/Game/"):
+                prev_level = curr_level_path
 
         # Get layout level
         filter = unreal.ARFilter(
@@ -735,11 +805,6 @@ class LayoutLoader(plugin.Loader):
             package_paths=[asset_dir],
             recursive_paths=False)
         levels = ar.get_assets(filter)
-        filter = unreal.ARFilter(
-            class_names=["LevelSequence"],
-            package_paths=[asset_dir],
-            recursive_paths=False)
-        sequences = ar.get_assets(filter)
 
         layout_level = levels[0].get_editor_property('object_path')
 
@@ -751,14 +816,14 @@ class LayoutLoader(plugin.Loader):
         for actor in actors:
             unreal.EditorLevelLibrary.destroy_actor(actor)
 
-        EditorLevelLibrary.save_current_level()
+        if create_sequences:
+            EditorLevelLibrary.save_current_level()
 
         EditorAssetLibrary.delete_directory(f"{asset_dir}/animations/")
 
         source_path = get_representation_path(representation)
 
-        loaded_assets = self._process(
-            source_path, asset_dir, sequences[0].get_asset())
+        loaded_assets = self._process(source_path, asset_dir, sequence)
 
         data = {
             "representation": str(representation["_id"]),
@@ -776,13 +841,20 @@ class LayoutLoader(plugin.Loader):
         for a in asset_content:
             EditorAssetLibrary.save_asset(a)
 
-        EditorLevelLibrary.load_level(master_level)
+        if master_level:
+            EditorLevelLibrary.load_level(master_level)
+        elif prev_level:
+            EditorLevelLibrary.load_level(prev_level)
 
     def remove(self, container):
         """
         Delete the layout. First, check if the assets loaded with the layout
         are used by other layouts. If not, delete the assets.
         """
+        data = get_current_project_settings()
+        create_sequences = data["unreal"]["level_sequences_for_layouts"]
+
+        root = "/Game/OpenPype"
         path = Path(container.get("namespace"))
 
         containers = unreal_pipeline.ls()
@@ -793,7 +865,7 @@ class LayoutLoader(plugin.Loader):
 
         # Check if the assets have been loaded by other layouts, and deletes
         # them if they haven't.
-        for asset in container.get('loaded_assets'):
+        for asset in eval(container.get('loaded_assets')):
             layouts = [
                 lc for lc in layout_containers
                 if asset in lc.get('loaded_assets')]
@@ -801,71 +873,87 @@ class LayoutLoader(plugin.Loader):
             if not layouts:
                 EditorAssetLibrary.delete_directory(str(Path(asset).parent))
 
-        # Remove the Level Sequence from the parent.
-        # We need to traverse the hierarchy from the master sequence to find
-        # the level sequence.
-        root = "/Game/OpenPype"
-        namespace = container.get('namespace').replace(f"{root}/", "")
-        ms_asset = namespace.split('/')[0]
-        ar = unreal.AssetRegistryHelpers.get_asset_registry()
-        _filter = unreal.ARFilter(
-            class_names=["LevelSequence"],
-            package_paths=[f"{root}/{ms_asset}"],
-            recursive_paths=False)
-        sequences = ar.get_assets(_filter)
-        master_sequence = sequences[0].get_asset()
-        _filter = unreal.ARFilter(
-            class_names=["World"],
-            package_paths=[f"{root}/{ms_asset}"],
-            recursive_paths=False)
-        levels = ar.get_assets(_filter)
-        master_level = levels[0].get_editor_property('object_path')
+                # Delete the parent folder if there aren't any more
+                # layouts in it.
+                asset_content = EditorAssetLibrary.list_assets(
+                    str(Path(asset).parent.parent), recursive=False,
+                    include_folder=True
+                )
 
-        sequences = [master_sequence]
+                if len(asset_content) == 0:
+                    EditorAssetLibrary.delete_directory(
+                        str(Path(asset).parent.parent))
 
-        parent = None
-        for s in sequences:
-            tracks = s.get_master_tracks()
-            subscene_track = None
-            visibility_track = None
-            for t in tracks:
-                if t.get_class() == unreal.MovieSceneSubTrack.static_class():
-                    subscene_track = t
-                if (t.get_class() ==
-                        unreal.MovieSceneLevelVisibilityTrack.static_class()):
-                    visibility_track = t
-            if subscene_track:
-                sections = subscene_track.get_sections()
-                for ss in sections:
-                    if ss.get_sequence().get_name() == container.get('asset'):
-                        parent = s
-                        subscene_track.remove_section(ss)
-                        break
-                    sequences.append(ss.get_sequence())
-                # Update subscenes indexes.
-                i = 0
-                for ss in sections:
-                    ss.set_row_index(i)
-                    i += 1
+        master_sequence = None
+        master_level = None
+        sequences = []
 
-            if visibility_track:
-                sections = visibility_track.get_sections()
-                for ss in sections:
-                    if (unreal.Name(f"{container.get('asset')}_map")
-                            in ss.get_level_names()):
-                        visibility_track.remove_section(ss)
-                # Update visibility sections indexes.
-                i = -1
-                prev_name = []
-                for ss in sections:
-                    if prev_name != ss.get_level_names():
+        if create_sequences:
+            # Remove the Level Sequence from the parent.
+            # We need to traverse the hierarchy from the master sequence to
+            # find the level sequence.
+            namespace = container.get('namespace').replace(f"{root}/", "")
+            ms_asset = namespace.split('/')[0]
+            ar = unreal.AssetRegistryHelpers.get_asset_registry()
+            _filter = unreal.ARFilter(
+                class_names=["LevelSequence"],
+                package_paths=[f"{root}/{ms_asset}"],
+                recursive_paths=False)
+            sequences = ar.get_assets(_filter)
+            master_sequence = sequences[0].get_asset()
+            _filter = unreal.ARFilter(
+                class_names=["World"],
+                package_paths=[f"{root}/{ms_asset}"],
+                recursive_paths=False)
+            levels = ar.get_assets(_filter)
+            master_level = levels[0].get_editor_property('object_path')
+
+            sequences = [master_sequence]
+
+            parent = None
+            for s in sequences:
+                tracks = s.get_master_tracks()
+                subscene_track = None
+                visibility_track = None
+                for t in tracks:
+                    if t.get_class() == MovieSceneSubTrack.static_class():
+                        subscene_track = t
+                    if (t.get_class() ==
+                            MovieSceneLevelVisibilityTrack.static_class()):
+                        visibility_track = t
+                if subscene_track:
+                    sections = subscene_track.get_sections()
+                    for ss in sections:
+                        if (ss.get_sequence().get_name() ==
+                                container.get('asset')):
+                            parent = s
+                            subscene_track.remove_section(ss)
+                            break
+                        sequences.append(ss.get_sequence())
+                    # Update subscenes indexes.
+                    i = 0
+                    for ss in sections:
+                        ss.set_row_index(i)
                         i += 1
-                    ss.set_row_index(i)
-                    prev_name = ss.get_level_names()
-            if parent:
-                break
 
-        assert parent, "Could not find the parent sequence"
+                if visibility_track:
+                    sections = visibility_track.get_sections()
+                    for ss in sections:
+                        if (unreal.Name(f"{container.get('asset')}_map")
+                                in ss.get_level_names()):
+                            visibility_track.remove_section(ss)
+                    # Update visibility sections indexes.
+                    i = -1
+                    prev_name = []
+                    for ss in sections:
+                        if prev_name != ss.get_level_names():
+                            i += 1
+                        ss.set_row_index(i)
+                        prev_name = ss.get_level_names()
+                if parent:
+                    break
+
+            assert parent, "Could not find the parent sequence"
 
         # Create a temporary level to delete the layout level.
         EditorLevelLibrary.save_all_dirty_levels()
@@ -879,10 +967,9 @@ class LayoutLoader(plugin.Loader):
         # Delete the layout directory.
         EditorAssetLibrary.delete_directory(str(path))
 
-        EditorLevelLibrary.load_level(master_level)
-        EditorAssetLibrary.delete_directory(f"{root}/tmp")
-
-        EditorLevelLibrary.save_current_level()
+        if create_sequences:
+            EditorLevelLibrary.load_level(master_level)
+            EditorAssetLibrary.delete_directory(f"{root}/tmp")
 
         # Delete the parent folder if there aren't any more layouts in it.
         asset_content = EditorAssetLibrary.list_assets(
diff --git a/openpype/settings/defaults/project_settings/unreal.json b/openpype/settings/defaults/project_settings/unreal.json
index dad61cd1f0..c5f5cdf719 100644
--- a/openpype/settings/defaults/project_settings/unreal.json
+++ b/openpype/settings/defaults/project_settings/unreal.json
@@ -1,4 +1,5 @@
 {
+    "level_sequences_for_layouts": false,
     "project_setup": {
         "dev_mode": true
     }
diff --git a/openpype/settings/entities/schemas/projects_schema/schema_project_unreal.json b/openpype/settings/entities/schemas/projects_schema/schema_project_unreal.json
index 4e197e9fc8..d26b5c1ccf 100644
--- a/openpype/settings/entities/schemas/projects_schema/schema_project_unreal.json
+++ b/openpype/settings/entities/schemas/projects_schema/schema_project_unreal.json
@@ -5,6 +5,11 @@
     "label": "Unreal Engine",
     "is_file": true,
     "children": [
+        {
+            "type": "boolean",
+            "key": "level_sequences_for_layouts",
+            "label": "Generate level sequences when loading layouts"
+        },
         {
             "type": "dict",
             "collapsible": true,
diff --git a/website/docs/artist_hosts_unreal.md b/website/docs/artist_hosts_unreal.md
index 1ff09893e3..45a0c8bb6f 100644
--- a/website/docs/artist_hosts_unreal.md
+++ b/website/docs/artist_hosts_unreal.md
@@ -8,6 +8,20 @@ sidebar_label: Unreal
 
 OpenPype supports Unreal in similar ways as in other DCCs Yet there are few specific you need to be aware of.
 
+### Creating the Unreal project
+
+Selecting a task and opening it with Unreal will generate the Unreal project, if it hasn't been created before.
+By default, OpenPype includes the plugin that will be built together with the project.
+
+Alternatively, the Environment variable `"OPENPYPE_UNREAL_PLUGIN"` can be set to the path of a compiled version of the plugin.
+The version of the compiled plugin must match the version of Unreal with which the project is being created.
+
+:::note
+Unreal version 5.0 onwards requires the following Environment variable:
+
+`"UE_PYTHONPATH": "{PYTHONPATH}"`
+:::
+
 ### Project naming
 
 Unreal doesn't support project names starting with non-alphabetic character. So names like `123_myProject` are
@@ -15,9 +29,9 @@ invalid. If OpenPype detects such name it automatically prepends letter **P** to
 
 ## OpenPype global tools
 
-OpenPype global tools can be found in *Window* main menu:
+OpenPype global tools can be found in Unreal's toolbar and in the *Tools* main menu:
 
-![Unreal OpenPype Menu](assets/unreal-avalon_tools.jpg)
+![Unreal OpenPype Menu](assets/unreal_openpype_tools.png)
 
 -   [Create](artist_tools.md#creator)
 -   [Load](artist_tools.md#loader)
@@ -31,10 +45,118 @@ OpenPype global tools can be found in *Window* main menu:
 
 To import Static Mesh model, just choose **OpenPype → Load ...** and select your mesh. Static meshes are transferred as FBX files as specified in [Unreal Engine 4 Static Mesh Pipeline](https://docs.unrealengine.com/en-US/Engine/Content/Importing/FBX/StaticMeshes/index.html). This action will create new folder with subset name (`unrealStaticMeshMain_CON` for example) and put all data into it. Inside, you can find:
 
-![Unreal Container Content](assets/unreal-container.jpg)
+![Unreal Container Content](assets/unreal_container.jpg)
 
-In this case there is **lambert1**, material pulled from Maya when this static mesh was published, **unrealStaticMeshCube** is the geometry itself, **unrealStaticMeshCube_CON** is a *AssetContainer* type and is there to mark this directory as Avalon Container (to track changes) and to hold OpenPype metadata.
+In this case there is **lambert1**, material pulled from Maya when this static mesh was published, **antennaA_modelMain** is the geometry itself, **modelMain_v002_CON** is a *AssetContainer* type and is there to mark this directory as Avalon Container (to track changes) and to hold OpenPype metadata.
 
 ### Publishing
 
-Publishing of Static Mesh works in similar ways. Select your mesh in *Content Browser* and **OpenPype → Create ...**. This will create folder named by subset you've chosen - for example **unrealStaticMeshDefault_INS**. It this folder is that mesh and *Avalon Publish Instance* asset marking this folder as publishable instance and holding important metadata on it. If you want to publish this instance, go **OpenPype → Publish ...**
\ No newline at end of file
+Publishing of Static Mesh works in similar ways. Select your mesh in *Content Browser* and **OpenPype → Create ...**. This will create folder named by subset you've chosen - for example **unrealStaticMeshDefault_INS**. It this folder is that mesh and *Avalon Publish Instance* asset marking this folder as publishable instance and holding important metadata on it. If you want to publish this instance, go **OpenPype → Publish ...**
+
+## Layout
+
+There are two different layout options in Unreal, depending on the type of project you are working on.
+One only imports the layout, and saves it in a level.
+The other uses [Master Sequences](https://docs.unrealengine.com/4.27/en-US/AnimatingObjects/Sequencer/Overview/TracksShot/) to track the whole level sequence hierarchy.
+You can choose in the Project Settings if you want to generate the level sequences.
+
+![Unreal OP Settings Level Sequence](assets/unreal_setting_level_sequence.png)
+
+### Loading
+
+To load a layout, click on the OpenPype icon in Unreal’s main taskbar, and select **Load**.
+
+![Unreal OP Tools Load](assets/unreal_openpype_tools_load.png)
+
+Select the task on the left, then right click on the layout asset and select **Load Layout**.
+
+![Unreal Layout Load](assets/unreal_load_layout.png)
+
+If you need to load multiple layouts, you can select more than one task on the left, and you can load them together.
+
+![Unreal Layout Load Batch](assets/unreal_load_layout_batch.png)
+
+### Navigating the project
+
+The layout will be imported in the directory `/Content/OpenPype`. The layout will be split into two subfolders: 
+- *Assets*, which will contain all the rigs and models contained in the layout;
+- *Asset name* (in the following example, *episode 2*), a folder named as the **asset** of the current **task**.
+
+![Unreal Layout Loading Result](assets/unreal_layout_loading_result.png)
+
+If you chose to generate the level sequences, in the second folder you will find the master level for the task (usually an episode), the level sequence and the folders for all the scenes in the episodes.
+Otherwise you will find the level generated for the loaded layout.
+
+#### Layout without level sequences
+
+In the layout folder, you will find the level with the imported layout and an object of *AssetContainer* type. The latter is there to mark this directory as Avalon Container (to track changes) and to hold OpenPype metadata.
+
+![Unreal Layout Loading No Sequence](assets/unreal_layout_loading_no_sequence.png)
+
+The layout level will and should contain only the data included in the layout. To add lighting, or other elements, like an environment, you have to create a master level, and add the layout level as a [streaming level](https://docs.unrealengine.com/5.0/en-US/level-streaming-in-unreal-engine/).
+
+Create the master level and open it. Then, open the *Levels* window (from the menu **Windows → Levels**). Click on **Levels → Add Existing** and select the layout level and the other levels you with to include in the scene. The following example shows a master level in which have been added a light level and the layout level.
+
+![Unreal Add Level](assets/unreal_add_level.png)
+![Unreal Level List](assets/unreal_level_list_no_sequences.png)
+
+#### Layout with level sequences
+
+In the episode folder, you will find the master level for the episode, the master level sequence and the folders for all the scenes in the episodes.
+
+After opening the master level, open the *Levels* window (from the menu **Windows → Levels**), and you will see the list of the levels of each shot of the episode for which a layout has been loaded.
+
+![Unreal Level List](assets/unreal_level_list.png)
+
+If it has not been added already, you will need to add the environment to the level. Click on **Levels → Add Existing** and select the level with the environment (check with the studio where it is located).
+
+![Unreal Add Level](assets/unreal_add_level.png)
+
+After adding the environment level to the master level, you will need to set it as always loaded by right clicking it, and selecting **Change Streaming Method** and selecting **Always Loaded**.
+
+![Unreal Level Streaming Method](assets/unreal_level_streaming_method.png)
+
+### Update layouts
+
+To manage loaded layouts, click on the OpenPype icon in Unreal’s main taskbar, and select **Manage**.
+
+![Unreal OP Tools Manage](assets/unreal_openpype_tools_manage.png)
+
+You will get a list of all the assets that have been loaded in the project.
+The version number will be in red if it isn’t the latest version. Right click on the element, and select Update if you need to update the layout.
+
+:::note
+**DO NOT** update rigs or models imported with a layout. Update only the layout.
+:::
+
+## Rendering
+
+:::note
+The rendering requires a layout loaded with the option to create the level sequences **on**.
+:::
+
+To render and publish an episode, a scene or a shot, you will need to create a publish instance. The publish instance for the rendering is based on one level sequence. That means that if you want to render the whole episode, you will need to create it for the level sequence of the episode, but if you want to render just one shot, you will need to create it for that shot.
+
+Navigate to the folder that contains the level sequence that you need to render. Select the level sequence, and then click on the OpenPype icon in Unreal’s main taskbar, and select **Create**.
+
+![Unreal OP Tools Create](assets/unreal_openpype_tools_create.png)
+
+In the Instance Creator, select **Unreal - Render**, give it a name, and click **Create**.
+
+![Unreal OP Instance Creator](assets/unreal_create_render.png)
+
+The render instance will be created in `/Content/OpenPype/PublishInstances`.
+
+Select the instance you need to render, and then click on the OpenPype icon in Unreal’s main taskbar, and select **Render**. You can render more than one instance at a time, if needed. Just select all the instances that you need to render before selecting the **Render** button from the OpenPype menu.
+
+![Unreal OP Tools Render](assets/unreal_openpype_tools_render.png)
+
+Once the render is finished, click on the OpenPype icon in Unreal’s main taskbar, and select **Publish**.
+
+![Unreal OP Tools Publish](assets/unreal_openpype_tools_publish.png)
+
+On the left, you will see the render instances. They will be automatically reorganised to have an instance for each shot. So, for example, if you have created the render instance for the whole episode, here you will have an instance for each shot in the episode.
+
+![Unreal Publish Render](assets/unreal_publish_render.png)
+
+Click on the play button in the bottom right, and it will start the publishing process.
diff --git a/website/docs/assets/unreal-avalon_tools.jpg b/website/docs/assets/unreal-avalon_tools.jpg
deleted file mode 100644
index 531fbe516a..0000000000
Binary files a/website/docs/assets/unreal-avalon_tools.jpg and /dev/null differ
diff --git a/website/docs/assets/unreal-container.jpg b/website/docs/assets/unreal-container.jpg
deleted file mode 100644
index f0c0a61e95..0000000000
Binary files a/website/docs/assets/unreal-container.jpg and /dev/null differ
diff --git a/website/docs/assets/unreal_add_level.png b/website/docs/assets/unreal_add_level.png
new file mode 100644
index 0000000000..caeef03d10
Binary files /dev/null and b/website/docs/assets/unreal_add_level.png differ
diff --git a/website/docs/assets/unreal_container.jpg b/website/docs/assets/unreal_container.jpg
new file mode 100644
index 0000000000..0fda640b00
Binary files /dev/null and b/website/docs/assets/unreal_container.jpg differ
diff --git a/website/docs/assets/unreal_create_render.png b/website/docs/assets/unreal_create_render.png
new file mode 100644
index 0000000000..2e3ef20b35
Binary files /dev/null and b/website/docs/assets/unreal_create_render.png differ
diff --git a/website/docs/assets/unreal_layout_loading_no_sequence.png b/website/docs/assets/unreal_layout_loading_no_sequence.png
new file mode 100644
index 0000000000..ed05d77f53
Binary files /dev/null and b/website/docs/assets/unreal_layout_loading_no_sequence.png differ
diff --git a/website/docs/assets/unreal_layout_loading_result.png b/website/docs/assets/unreal_layout_loading_result.png
new file mode 100644
index 0000000000..55b329110b
Binary files /dev/null and b/website/docs/assets/unreal_layout_loading_result.png differ
diff --git a/website/docs/assets/unreal_level_list.png b/website/docs/assets/unreal_level_list.png
new file mode 100644
index 0000000000..2fc0c1bfc7
Binary files /dev/null and b/website/docs/assets/unreal_level_list.png differ
diff --git a/website/docs/assets/unreal_level_list_no_sequences.png b/website/docs/assets/unreal_level_list_no_sequences.png
new file mode 100644
index 0000000000..7ed912b68b
Binary files /dev/null and b/website/docs/assets/unreal_level_list_no_sequences.png differ
diff --git a/website/docs/assets/unreal_level_streaming_method.png b/website/docs/assets/unreal_level_streaming_method.png
new file mode 100644
index 0000000000..8f817abd2e
Binary files /dev/null and b/website/docs/assets/unreal_level_streaming_method.png differ
diff --git a/website/docs/assets/unreal_level_streaming_method_no_sequences.png b/website/docs/assets/unreal_level_streaming_method_no_sequences.png
new file mode 100644
index 0000000000..77a2754ded
Binary files /dev/null and b/website/docs/assets/unreal_level_streaming_method_no_sequences.png differ
diff --git a/website/docs/assets/unreal_load_layout.png b/website/docs/assets/unreal_load_layout.png
new file mode 100644
index 0000000000..ffad60ae9b
Binary files /dev/null and b/website/docs/assets/unreal_load_layout.png differ
diff --git a/website/docs/assets/unreal_load_layout_batch.png b/website/docs/assets/unreal_load_layout_batch.png
new file mode 100644
index 0000000000..dd2f2f3e8f
Binary files /dev/null and b/website/docs/assets/unreal_load_layout_batch.png differ
diff --git a/website/docs/assets/unreal_openpype_tools.png b/website/docs/assets/unreal_openpype_tools.png
new file mode 100644
index 0000000000..bf7d850ab2
Binary files /dev/null and b/website/docs/assets/unreal_openpype_tools.png differ
diff --git a/website/docs/assets/unreal_openpype_tools_create.png b/website/docs/assets/unreal_openpype_tools_create.png
new file mode 100644
index 0000000000..9cfb95f2a1
Binary files /dev/null and b/website/docs/assets/unreal_openpype_tools_create.png differ
diff --git a/website/docs/assets/unreal_openpype_tools_load.png b/website/docs/assets/unreal_openpype_tools_load.png
new file mode 100644
index 0000000000..4909feac3b
Binary files /dev/null and b/website/docs/assets/unreal_openpype_tools_load.png differ
diff --git a/website/docs/assets/unreal_openpype_tools_manage.png b/website/docs/assets/unreal_openpype_tools_manage.png
new file mode 100644
index 0000000000..af7b182842
Binary files /dev/null and b/website/docs/assets/unreal_openpype_tools_manage.png differ
diff --git a/website/docs/assets/unreal_openpype_tools_publish.png b/website/docs/assets/unreal_openpype_tools_publish.png
new file mode 100644
index 0000000000..ab4c10c4ca
Binary files /dev/null and b/website/docs/assets/unreal_openpype_tools_publish.png differ
diff --git a/website/docs/assets/unreal_openpype_tools_render.png b/website/docs/assets/unreal_openpype_tools_render.png
new file mode 100644
index 0000000000..377dc2951e
Binary files /dev/null and b/website/docs/assets/unreal_openpype_tools_render.png differ
diff --git a/website/docs/assets/unreal_publish_render.png b/website/docs/assets/unreal_publish_render.png
new file mode 100644
index 0000000000..674b0ac30e
Binary files /dev/null and b/website/docs/assets/unreal_publish_render.png differ
diff --git a/website/docs/assets/unreal_setting_level_sequence.png b/website/docs/assets/unreal_setting_level_sequence.png
new file mode 100644
index 0000000000..5a8adc6257
Binary files /dev/null and b/website/docs/assets/unreal_setting_level_sequence.png differ