diff --git a/openpype/hooks/pre_global_host_data.py b/openpype/hooks/pre_global_host_data.py
index ea5e290d6f..6577e37cbe 100644
--- a/openpype/hooks/pre_global_host_data.py
+++ b/openpype/hooks/pre_global_host_data.py
@@ -1,11 +1,10 @@
-from openpype.api import Anatomy
 from openpype.lib import (
     PreLaunchHook,
     EnvironmentPrepData,
     prepare_app_environments,
     prepare_context_environments
 )
-from openpype.pipeline import AvalonMongoDB
+from openpype.pipeline import AvalonMongoDB, Anatomy
 
 
 class GlobalHostDataHook(PreLaunchHook):
diff --git a/openpype/hosts/blender/api/pipeline.py b/openpype/hosts/blender/api/pipeline.py
index 93d81145bc..ea405b028e 100644
--- a/openpype/hosts/blender/api/pipeline.py
+++ b/openpype/hosts/blender/api/pipeline.py
@@ -93,7 +93,7 @@ def set_start_end_frames():
     # Default scene settings
     frameStart = scene.frame_start
     frameEnd = scene.frame_end
-    fps = scene.render.fps
+    fps = scene.render.fps / scene.render.fps_base
     resolution_x = scene.render.resolution_x
     resolution_y = scene.render.resolution_y
 
@@ -116,7 +116,8 @@ def set_start_end_frames():
 
     scene.frame_start = frameStart
     scene.frame_end = frameEnd
-    scene.render.fps = fps
+    scene.render.fps = round(fps)
+    scene.render.fps_base = round(fps) / fps
     scene.render.resolution_x = resolution_x
     scene.render.resolution_y = resolution_y
 
diff --git a/openpype/hosts/hiero/api/lib.py b/openpype/hosts/hiero/api/lib.py
index 8c8c31bc4c..2f66f3ddd7 100644
--- a/openpype/hosts/hiero/api/lib.py
+++ b/openpype/hosts/hiero/api/lib.py
@@ -19,8 +19,9 @@ from openpype.client import (
     get_last_versions,
     get_representations,
 )
-from openpype.pipeline import legacy_io
-from openpype.api import (Logger, Anatomy, get_anatomy_settings)
+from openpype.settings import get_anatomy_settings
+from openpype.pipeline import legacy_io, Anatomy
+from openpype.api import Logger
 from . import tags
 
 try:
diff --git a/openpype/hosts/houdini/vendor/husdoutputprocessors/avalon_uri_processor.py b/openpype/hosts/houdini/vendor/husdoutputprocessors/avalon_uri_processor.py
index 202287f1c3..d7d1c79d73 100644
--- a/openpype/hosts/houdini/vendor/husdoutputprocessors/avalon_uri_processor.py
+++ b/openpype/hosts/houdini/vendor/husdoutputprocessors/avalon_uri_processor.py
@@ -5,8 +5,7 @@ import husdoutputprocessors.base as base
 import colorbleed.usdlib as usdlib
 
 from openpype.client import get_asset_by_name
-from openpype.api import Anatomy
-from openpype.pipeline import legacy_io
+from openpype.pipeline import legacy_io, Anatomy
 
 
 class AvalonURIOutputProcessor(base.OutputProcessorBase):
diff --git a/openpype/hosts/maya/api/lib.py b/openpype/hosts/maya/api/lib.py
index de9a9da911..34340a13a5 100644
--- a/openpype/hosts/maya/api/lib.py
+++ b/openpype/hosts/maya/api/lib.py
@@ -1908,7 +1908,7 @@ def iter_parents(node):
     """
     while True:
         split = node.rsplit("|", 1)
-        if len(split) == 1:
+        if len(split) == 1 or not split[0]:
             return
 
         node = split[0]
@@ -3213,3 +3213,209 @@ def parent_nodes(nodes, parent=None):
                 node[0].setParent(node[1])
         if delete_parent:
             pm.delete(parent_node)
+
+
+@contextlib.contextmanager
+def maintained_time():
+    ct = cmds.currentTime(query=True)
+    try:
+        yield
+    finally:
+        cmds.currentTime(ct, edit=True)
+
+
+def iter_visible_nodes_in_range(nodes, start, end):
+    """Yield nodes that are visible in start-end frame range.
+
+    - Ignores intermediateObjects completely.
+    - Considers animated visibility attributes + upstream visibilities.
+
+    This is optimized for large scenes where some nodes in the parent
+    hierarchy might have some input connections to the visibilities,
+    e.g. key, driven keys, connections to other attributes, etc.
+
+    This only does a single time step to `start` if current frame is
+    not inside frame range since the assumption is made that changing
+    a frame isn't so slow that it beats querying all visibility
+    plugs through MDGContext on another frame.
+
+    Args:
+        nodes (list): List of node names to consider.
+        start (int, float): Start frame.
+        end (int, float): End frame.
+
+    Returns:
+        list: List of node names. These will be long full path names so
+            might have a longer name than the input nodes.
+
+    """
+    # States we consider per node
+    VISIBLE = 1  # always visible
+    INVISIBLE = 0  # always invisible
+    ANIMATED = -1  # animated visibility
+
+    # Ensure integers
+    start = int(start)
+    end = int(end)
+
+    # Consider only non-intermediate dag nodes and use the "long" names.
+    nodes = cmds.ls(nodes, long=True, noIntermediate=True, type="dagNode")
+    if not nodes:
+        return
+
+    with maintained_time():
+        # Go to first frame of the range if the current time is outside
+        # the queried range so can directly query all visible nodes on
+        # that frame.
+        current_time = cmds.currentTime(query=True)
+        if not (start <= current_time <= end):
+            cmds.currentTime(start)
+
+        visible = cmds.ls(nodes, long=True, visible=True)
+        for node in visible:
+            yield node
+        if len(visible) == len(nodes) or start == end:
+            # All are visible on frame one, so they are at least visible once
+            # inside the frame range.
+            return
+
+    # For the invisible ones check whether its visibility and/or
+    # any of its parents visibility attributes are animated. If so, it might
+    # get visible on other frames in the range.
+    def memodict(f):
+        """Memoization decorator for a function taking a single argument.
+
+        See: http://code.activestate.com/recipes/
+             578231-probably-the-fastest-memoization-decorator-in-the-/
+        """
+
+        class memodict(dict):
+            def __missing__(self, key):
+                ret = self[key] = f(key)
+                return ret
+
+        return memodict().__getitem__
+
+    @memodict
+    def get_state(node):
+        plug = node + ".visibility"
+        connections = cmds.listConnections(plug,
+                                           source=True,
+                                           destination=False)
+        if connections:
+            return ANIMATED
+        else:
+            return VISIBLE if cmds.getAttr(plug) else INVISIBLE
+
+    visible = set(visible)
+    invisible = [node for node in nodes if node not in visible]
+    always_invisible = set()
+    # Iterate over the nodes by short to long names to iterate the highest
+    # in hierarchy nodes first. So the collected data can be used from the
+    # cache for parent queries in next iterations.
+    node_dependencies = dict()
+    for node in sorted(invisible, key=len):
+
+        state = get_state(node)
+        if state == INVISIBLE:
+            always_invisible.add(node)
+            continue
+
+        # If not always invisible by itself we should go through and check
+        # the parents to see if any of them are always invisible. For those
+        # that are "ANIMATED" we consider that this node is dependent on
+        # that attribute, we store them as dependency.
+        dependencies = set()
+        if state == ANIMATED:
+            dependencies.add(node)
+
+        traversed_parents = list()
+        for parent in iter_parents(node):
+
+            if parent in always_invisible or get_state(parent) == INVISIBLE:
+                # When parent is always invisible then consider this parent,
+                # this node we started from and any of the parents we
+                # have traversed in-between to be *always invisible*
+                always_invisible.add(parent)
+                always_invisible.add(node)
+                always_invisible.update(traversed_parents)
+                break
+
+            # If we have traversed the parent before and its visibility
+            # was dependent on animated visibilities then we can just extend
+            # its dependencies for to those for this node and break further
+            # iteration upwards.
+            parent_dependencies = node_dependencies.get(parent, None)
+            if parent_dependencies is not None:
+                dependencies.update(parent_dependencies)
+                break
+
+            state = get_state(parent)
+            if state == ANIMATED:
+                dependencies.add(parent)
+
+            traversed_parents.append(parent)
+
+        if node not in always_invisible and dependencies:
+            node_dependencies[node] = dependencies
+
+    if not node_dependencies:
+        return
+
+    # Now we only have to check the visibilities for nodes that have animated
+    # visibility dependencies upstream. The fastest way to check these
+    # visibility attributes across different frames is with Python api 2.0
+    # so we do that.
+    @memodict
+    def get_visibility_mplug(node):
+        """Return api 2.0 MPlug with cached memoize decorator"""
+        sel = om.MSelectionList()
+        sel.add(node)
+        dag = sel.getDagPath(0)
+        return om.MFnDagNode(dag).findPlug("visibility", True)
+
+    @contextlib.contextmanager
+    def dgcontext(mtime):
+        """MDGContext context manager"""
+        context = om.MDGContext(mtime)
+        try:
+            previous = context.makeCurrent()
+            yield context
+        finally:
+            previous.makeCurrent()
+
+    # We skip the first frame as we already used that frame to check for
+    # overall visibilities. And end+1 to include the end frame.
+    scene_units = om.MTime.uiUnit()
+    for frame in range(start + 1, end + 1):
+        mtime = om.MTime(frame, unit=scene_units)
+
+        # Build little cache so we don't query the same MPlug's value
+        # again if it was checked on this frame and also is a dependency
+        # for another node
+        frame_visibilities = {}
+        with dgcontext(mtime) as context:
+            for node, dependencies in list(node_dependencies.items()):
+                for dependency in dependencies:
+                    dependency_visible = frame_visibilities.get(dependency,
+                                                                None)
+                    if dependency_visible is None:
+                        mplug = get_visibility_mplug(dependency)
+                        dependency_visible = mplug.asBool(context)
+                        frame_visibilities[dependency] = dependency_visible
+
+                    if not dependency_visible:
+                        # One dependency is not visible, thus the
+                        # node is not visible.
+                        break
+
+                else:
+                    # All dependencies are visible.
+                    yield node
+                    # Remove node with dependencies for next frame iterations
+                    # because it was visible at least once.
+                    node_dependencies.pop(node)
+
+        # If no more nodes to process break the frame iterations..
+        if not node_dependencies:
+            break
diff --git a/openpype/hosts/maya/api/plugin.py b/openpype/hosts/maya/api/plugin.py
index f05893a7b4..9280805945 100644
--- a/openpype/hosts/maya/api/plugin.py
+++ b/openpype/hosts/maya/api/plugin.py
@@ -9,8 +9,8 @@ from openpype.pipeline import (
     LoaderPlugin,
     get_representation_path,
     AVALON_CONTAINER_ID,
+    Anatomy,
 )
-from openpype.api import Anatomy
 from openpype.settings import get_project_settings
 from .pipeline import containerise
 from . import lib
diff --git a/openpype/hosts/maya/plugins/load/load_vdb_to_arnold.py b/openpype/hosts/maya/plugins/load/load_vdb_to_arnold.py
new file mode 100644
index 0000000000..d458c5abda
--- /dev/null
+++ b/openpype/hosts/maya/plugins/load/load_vdb_to_arnold.py
@@ -0,0 +1,139 @@
+import os
+
+from openpype.api import get_project_settings
+from openpype.pipeline import (
+    load,
+    get_representation_path
+)
+# TODO aiVolume doesn't automatically set velocity fps correctly, set manual?
+
+
+class LoadVDBtoArnold(load.LoaderPlugin):
+    """Load OpenVDB for Arnold in aiVolume"""
+
+    families = ["vdbcache"]
+    representations = ["vdb"]
+
+    label = "Load VDB to Arnold"
+    icon = "cloud"
+    color = "orange"
+
+    def load(self, context, name, namespace, data):
+
+        from maya import cmds
+        from openpype.hosts.maya.api.pipeline import containerise
+        from openpype.hosts.maya.api.lib import unique_namespace
+
+        try:
+            family = context["representation"]["context"]["family"]
+        except ValueError:
+            family = "vdbcache"
+
+        # Check if the plugin for arnold is available on the pc
+        try:
+            cmds.loadPlugin("mtoa", quiet=True)
+        except Exception as exc:
+            self.log.error("Encountered exception:\n%s" % exc)
+            return
+
+        asset = context['asset']
+        asset_name = asset["name"]
+        namespace = namespace or unique_namespace(
+            asset_name + "_",
+            prefix="_" if asset_name[0].isdigit() else "",
+            suffix="_",
+        )
+
+        # Root group
+        label = "{}:{}".format(namespace, name)
+        root = cmds.group(name=label, empty=True)
+
+        settings = get_project_settings(os.environ['AVALON_PROJECT'])
+        colors = settings['maya']['load']['colors']
+
+        c = colors.get(family)
+        if c is not None:
+            cmds.setAttr(root + ".useOutlinerColor", 1)
+            cmds.setAttr(root + ".outlinerColor",
+                         (float(c[0]) / 255),
+                         (float(c[1]) / 255),
+                         (float(c[2]) / 255)
+                         )
+
+        # Create VRayVolumeGrid
+        grid_node = cmds.createNode("aiVolume",
+                                    name="{}Shape".format(root),
+                                    parent=root)
+
+        self._set_path(grid_node,
+                       path=self.fname,
+                       representation=context["representation"])
+
+        # Lock the shape node so the user can't delete the transform/shape
+        # as if it was referenced
+        cmds.lockNode(grid_node, lock=True)
+
+        nodes = [root, grid_node]
+        self[:] = nodes
+
+        return containerise(
+            name=name,
+            namespace=namespace,
+            nodes=nodes,
+            context=context,
+            loader=self.__class__.__name__)
+
+    def update(self, container, representation):
+
+        from maya import cmds
+
+        path = get_representation_path(representation)
+
+        # Find VRayVolumeGrid
+        members = cmds.sets(container['objectName'], query=True)
+        grid_nodes = cmds.ls(members, type="aiVolume", long=True)
+        assert len(grid_nodes) == 1, "This is a bug"
+
+        # Update the VRayVolumeGrid
+        self._set_path(grid_nodes[0], path=path, representation=representation)
+
+        # Update container representation
+        cmds.setAttr(container["objectName"] + ".representation",
+                     str(representation["_id"]),
+                     type="string")
+
+    def switch(self, container, representation):
+        self.update(container, representation)
+
+    def remove(self, container):
+
+        from maya import cmds
+
+        # Get all members of the avalon container, ensure they are unlocked
+        # and delete everything
+        members = cmds.sets(container['objectName'], query=True)
+        cmds.lockNode(members, lock=False)
+        cmds.delete([container['objectName']] + members)
+
+        # Clean up the namespace
+        try:
+            cmds.namespace(removeNamespace=container['namespace'],
+                           deleteNamespaceContent=True)
+        except RuntimeError:
+            pass
+
+    @staticmethod
+    def _set_path(grid_node,
+                  path,
+                  representation):
+        """Apply the settings for the VDB path to the aiVolume node"""
+        from maya import cmds
+
+        if not os.path.exists(path):
+            raise RuntimeError("Path does not exist: %s" % path)
+
+        is_sequence = bool(representation["context"].get("frame"))
+        cmds.setAttr(grid_node + ".useFrameExtension", is_sequence)
+
+        # Set file path
+        cmds.setAttr(grid_node + ".filename", path, type="string")
diff --git a/openpype/hosts/maya/plugins/load/load_vdb_to_redshift.py b/openpype/hosts/maya/plugins/load/load_vdb_to_redshift.py
index 70bd9d22e2..c6a69dfe35 100644
--- a/openpype/hosts/maya/plugins/load/load_vdb_to_redshift.py
+++ b/openpype/hosts/maya/plugins/load/load_vdb_to_redshift.py
@@ -1,11 +1,21 @@
 import os
 
 from openpype.api import get_project_settings
-from openpype.pipeline import load
+from openpype.pipeline import (
+    load,
+    get_representation_path
+)
 
 
 class LoadVDBtoRedShift(load.LoaderPlugin):
-    """Load OpenVDB in a Redshift Volume Shape"""
+    """Load OpenVDB in a Redshift Volume Shape
+
+    Note that the RedshiftVolumeShape is created without a RedshiftVolume
+    shader assigned. To get the Redshift volume to render correctly assign
+    a RedshiftVolume shader (in the Hypershade) and set the density, scatter
+    and emission channels to the channel names of the volumes in the VDB file.
+
+    """
 
     families = ["vdbcache"]
     representations = ["vdb"]
@@ -55,7 +65,7 @@ class LoadVDBtoRedShift(load.LoaderPlugin):
 
         # Root group
         label = "{}:{}".format(namespace, name)
-        root = cmds.group(name=label, empty=True)
+        root = cmds.createNode("transform", name=label)
 
         settings = get_project_settings(os.environ['AVALON_PROJECT'])
         colors = settings['maya']['load']['colors']
@@ -74,9 +84,9 @@ class LoadVDBtoRedShift(load.LoaderPlugin):
                                       name="{}RVSShape".format(label),
                                       parent=root)
 
-        cmds.setAttr("{}.fileName".format(volume_node),
-                     self.fname,
-                     type="string")
+        self._set_path(volume_node,
+                       path=self.fname,
+                       representation=context["representation"])
 
         nodes = [root, volume_node]
         self[:] = nodes
@@ -87,3 +97,56 @@ class LoadVDBtoRedShift(load.LoaderPlugin):
             nodes=nodes,
             context=context,
             loader=self.__class__.__name__)
+
+    def update(self, container, representation):
+        from maya import cmds
+
+        path = get_representation_path(representation)
+
+        # Find VRayVolumeGrid
+        members = cmds.sets(container['objectName'], query=True)
+        grid_nodes = cmds.ls(members, type="RedshiftVolumeShape", long=True)
+        assert len(grid_nodes) == 1, "This is a bug"
+
+        # Update the VRayVolumeGrid
+        self._set_path(grid_nodes[0], path=path, representation=representation)
+
+        # Update container representation
+        cmds.setAttr(container["objectName"] + ".representation",
+                     str(representation["_id"]),
+                     type="string")
+
+    def remove(self, container):
+        from maya import cmds
+
+        # Get all members of the avalon container, ensure they are unlocked
+        # and delete everything
+        members = cmds.sets(container['objectName'], query=True)
+        cmds.lockNode(members, lock=False)
+        cmds.delete([container['objectName']] + members)
+
+        # Clean up the namespace
+        try:
+            cmds.namespace(removeNamespace=container['namespace'],
+                           deleteNamespaceContent=True)
+        except RuntimeError:
+            pass
+
+    def switch(self, container, representation):
+        self.update(container, representation)
+
+    @staticmethod
+    def _set_path(grid_node,
+                  path,
+                  representation):
+        """Apply the settings for the VDB path to the RedshiftVolumeShape"""
+        from maya import cmds
+
+        if not os.path.exists(path):
+            raise RuntimeError("Path does not exist: %s" % path)
+
+        is_sequence = bool(representation["context"].get("frame"))
+        cmds.setAttr(grid_node + ".useFrameExtension", is_sequence)
+
+        # Set file path
+        cmds.setAttr(grid_node + ".fileName", path, type="string")
diff --git a/openpype/hosts/maya/plugins/publish/extract_animation.py b/openpype/hosts/maya/plugins/publish/extract_animation.py
index abe5ed3bf5..8ed2d8d7a3 100644
--- a/openpype/hosts/maya/plugins/publish/extract_animation.py
+++ b/openpype/hosts/maya/plugins/publish/extract_animation.py
@@ -6,7 +6,8 @@ import openpype.api
 from openpype.hosts.maya.api.lib import (
     extract_alembic,
     suspended_refresh,
-    maintained_selection
+    maintained_selection,
+    iter_visible_nodes_in_range
 )
 
 
@@ -76,6 +77,16 @@ class ExtractAnimation(openpype.api.Extractor):
             # Since Maya 2017 alembic supports multiple uv sets - write them.
             options["writeUVSets"] = True
 
+        if instance.data.get("visibleOnly", False):
+            # If we only want to include nodes that are visible in the frame
+            # range then we need to do our own check. Alembic's `visibleOnly`
+            # flag does not filter out those that are only hidden on some
+            # frames as it counts "animated" or "connected" visibilities as
+            # if it's always visible.
+            nodes = list(iter_visible_nodes_in_range(nodes,
+                                                     start=start,
+                                                     end=end))
+
         with suspended_refresh():
             with maintained_selection():
                 cmds.select(nodes, noExpand=True)
diff --git a/openpype/hosts/maya/plugins/publish/extract_pointcache.py b/openpype/hosts/maya/plugins/publish/extract_pointcache.py
index c4c8610ebb..775b5e9939 100644
--- a/openpype/hosts/maya/plugins/publish/extract_pointcache.py
+++ b/openpype/hosts/maya/plugins/publish/extract_pointcache.py
@@ -6,7 +6,8 @@ import openpype.api
 from openpype.hosts.maya.api.lib import (
     extract_alembic,
     suspended_refresh,
-    maintained_selection
+    maintained_selection,
+    iter_visible_nodes_in_range
 )
 
 
@@ -79,6 +80,16 @@ class ExtractAlembic(openpype.api.Extractor):
             # Since Maya 2017 alembic supports multiple uv sets - write them.
             options["writeUVSets"] = True
 
+        if instance.data.get("visibleOnly", False):
+            # If we only want to include nodes that are visible in the frame
+            # range then we need to do our own check. Alembic's `visibleOnly`
+            # flag does not filter out those that are only hidden on some
+            # frames as it counts "animated" or "connected" visibilities as
+            # if it's always visible.
+            nodes = list(iter_visible_nodes_in_range(nodes,
+                                                     start=start,
+                                                     end=end))
+
         with suspended_refresh():
             with maintained_selection():
                 cmds.select(nodes, noExpand=True)
diff --git a/openpype/hosts/maya/plugins/publish/validate_visible_only.py b/openpype/hosts/maya/plugins/publish/validate_visible_only.py
new file mode 100644
index 0000000000..59a7f976ab
--- /dev/null
+++ b/openpype/hosts/maya/plugins/publish/validate_visible_only.py
@@ -0,0 +1,51 @@
+import pyblish.api
+
+import openpype.api
+from openpype.hosts.maya.api.lib import iter_visible_nodes_in_range
+import openpype.hosts.maya.api.action
+
+
+class ValidateAlembicVisibleOnly(pyblish.api.InstancePlugin):
+    """Validates at least a single node is visible in frame range.
+
+    This validation only validates if the `visibleOnly` flag is enabled
+    on the instance - otherwise the validation is skipped.
+
+    """
+    order = openpype.api.ValidateContentsOrder + 0.05
+    label = "Alembic Visible Only"
+    hosts = ["maya"]
+    families = ["pointcache", "animation"]
+    actions = [openpype.hosts.maya.api.action.SelectInvalidAction]
+
+    def process(self, instance):
+
+        if not instance.data.get("visibleOnly", False):
+            self.log.debug("Visible only is disabled. Validation skipped..")
+            return
+
+        invalid = self.get_invalid(instance)
+        if invalid:
+            start, end = self.get_frame_range(instance)
+            raise RuntimeError("No visible nodes found in "
+                               "frame range {}-{}.".format(start, end))
+
+    @classmethod
+    def get_invalid(cls, instance):
+
+        if instance.data["family"] == "animation":
+            # Special behavior to use the nodes in out_SET
+            nodes = instance.data["out_hierarchy"]
+        else:
+            nodes = instance[:]
+
+        start, end = cls.get_frame_range(instance)
+        if not any(iter_visible_nodes_in_range(nodes, start, end)):
+            # Return the nodes we have considered so the user can identify
+            # them with the select invalid action
+            return nodes
+
+    @staticmethod
+    def get_frame_range(instance):
+        data = instance.data
+        return data["frameStartHandle"], data["frameEndHandle"]
diff --git a/openpype/hosts/nuke/api/lib.py b/openpype/hosts/nuke/api/lib.py
index 45a1e72703..f565ec8546 100644
--- a/openpype/hosts/nuke/api/lib.py
+++ b/openpype/hosts/nuke/api/lib.py
@@ -20,21 +20,23 @@ from openpype.client import (
 )
 from openpype.api import (
     Logger,
-    Anatomy,
     BuildWorkfile,
     get_version_from_path,
-    get_anatomy_settings,
     get_workdir_data,
     get_asset,
     get_current_project_settings,
 )
 from openpype.tools.utils import host_tools
 from openpype.lib.path_tools import HostDirmap
-from openpype.settings import get_project_settings
+from openpype.settings import (
+    get_project_settings,
+    get_anatomy_settings,
+)
 from openpype.modules import ModulesManager
 from openpype.pipeline import (
     discover_legacy_creator_plugins,
     legacy_io,
+    Anatomy,
 )
 
 from . import gizmo_menu
diff --git a/openpype/hosts/nuke/plugins/publish/extract_review_data_mov.py b/openpype/hosts/nuke/plugins/publish/extract_review_data_mov.py
index 5ea7c352b9..fc16e189fb 100644
--- a/openpype/hosts/nuke/plugins/publish/extract_review_data_mov.py
+++ b/openpype/hosts/nuke/plugins/publish/extract_review_data_mov.py
@@ -104,7 +104,10 @@ class ExtractReviewDataMov(openpype.api.Extractor):
                     self, instance, o_name, o_data["extension"],
                     multiple_presets)
 
-                if "render.farm" in families:
+                if (
+                    "render.farm" in families or
+                    "prerender.farm" in families
+                ):
                     if "review" in instance.data["families"]:
                         instance.data["families"].remove("review")
 
diff --git a/openpype/hosts/nuke/plugins/publish/extract_slate_frame.py b/openpype/hosts/nuke/plugins/publish/extract_slate_frame.py
index e0c4bdb953..6d930d358d 100644
--- a/openpype/hosts/nuke/plugins/publish/extract_slate_frame.py
+++ b/openpype/hosts/nuke/plugins/publish/extract_slate_frame.py
@@ -4,6 +4,7 @@ import nuke
 import copy
 
 import pyblish.api
+import six
 
 import openpype
 from openpype.hosts.nuke.api import (
@@ -12,7 +13,6 @@ from openpype.hosts.nuke.api import (
     get_view_process_node
 )
 
-
 class ExtractSlateFrame(openpype.api.Extractor):
     """Extracts movie and thumbnail with baked in luts
 
@@ -236,6 +236,48 @@ class ExtractSlateFrame(openpype.api.Extractor):
             int(slate_first_frame)
         )
 
+        # Add file to representation files
+        # - get write node
+        write_node = instance.data["writeNode"]
+        # - evaluate filepaths for first frame and slate frame
+        first_filename = os.path.basename(
+            write_node["file"].evaluate(first_frame))
+        slate_filename = os.path.basename(
+            write_node["file"].evaluate(slate_first_frame))
+
+        # Find matching representation based on first filename
+        matching_repre = None
+        is_sequence = None
+        for repre in instance.data["representations"]:
+            files = repre["files"]
+            if (
+                not isinstance(files, six.string_types)
+                and first_filename in files
+            ):
+                matching_repre = repre
+                is_sequence = True
+                break
+
+            elif files == first_filename:
+                matching_repre = repre
+                is_sequence = False
+                break
+
+        if not matching_repre:
+            self.log.info((
+                "Matching reresentaion was not found."
+                " Representation files were not filled with slate."
+            ))
+            return
+
+        # Add frame to matching representation files
+        if not is_sequence:
+            matching_repre["files"] = [first_filename, slate_filename]
+        elif slate_filename not in matching_repre["files"]:
+            matching_repre["files"].insert(0, slate_filename)
+
+        self.log.warning("Added slate frame to representation files")
+
     def add_comment_slate_node(self, instance, node):
 
         comment = instance.context.data.get("comment")
diff --git a/openpype/hosts/nuke/plugins/publish/precollect_writes.py b/openpype/hosts/nuke/plugins/publish/precollect_writes.py
index 049958bd07..a97f34b370 100644
--- a/openpype/hosts/nuke/plugins/publish/precollect_writes.py
+++ b/openpype/hosts/nuke/plugins/publish/precollect_writes.py
@@ -35,6 +35,7 @@ class CollectNukeWrites(pyblish.api.InstancePlugin):
         if node is None:
             return
 
+        instance.data["writeNode"] = node
         self.log.debug("checking instance: {}".format(instance))
 
         # Determine defined file type
diff --git a/openpype/hosts/tvpaint/plugins/load/load_workfile.py b/openpype/hosts/tvpaint/plugins/load/load_workfile.py
index 462f12abf0..c6dc765a27 100644
--- a/openpype/hosts/tvpaint/plugins/load/load_workfile.py
+++ b/openpype/hosts/tvpaint/plugins/load/load_workfile.py
@@ -10,8 +10,8 @@ from openpype.lib import (
 from openpype.pipeline import (
     registered_host,
     legacy_io,
+    Anatomy,
 )
-from openpype.api import Anatomy
 from openpype.hosts.tvpaint.api import lib, pipeline, plugin
 
 
diff --git a/openpype/hosts/unreal/api/rendering.py b/openpype/hosts/unreal/api/rendering.py
index b2732506fc..29e4747f6e 100644
--- a/openpype/hosts/unreal/api/rendering.py
+++ b/openpype/hosts/unreal/api/rendering.py
@@ -2,7 +2,7 @@ import os
 
 import unreal
 
-from openpype.api import Anatomy
+from openpype.pipeline import Anatomy
 from openpype.hosts.unreal.api import pipeline
 
 
diff --git a/openpype/hosts/unreal/plugins/publish/collect_render_instances.py b/openpype/hosts/unreal/plugins/publish/collect_render_instances.py
index 9fb45ea7a7..cb28f4bf60 100644
--- a/openpype/hosts/unreal/plugins/publish/collect_render_instances.py
+++ b/openpype/hosts/unreal/plugins/publish/collect_render_instances.py
@@ -3,7 +3,7 @@ from pathlib import Path
 
 import unreal
 
-from openpype.api import Anatomy
+from openpype.pipeline import Anatomy
 from openpype.hosts.unreal.api import pipeline
 import pyblish.api
 
diff --git a/openpype/lib/anatomy.py b/openpype/lib/anatomy.py
index 3fbc05ee88..6d339f058f 100644
--- a/openpype/lib/anatomy.py
+++ b/openpype/lib/anatomy.py
@@ -1,1260 +1,38 @@
-import os
-import re
-import copy
-import platform
-import collections
-import numbers
+"""Code related to project Anatomy was moved
+to 'openpype.pipeline.anatomy' please change your imports as soon as
+possible. File will be probably removed in OpenPype 3.14.*
+"""
 
-from openpype.settings.lib import (
-    get_default_anatomy_settings,
-    get_anatomy_settings
-)
-from .path_templates import (
-    TemplateUnsolved,
-    TemplateResult,
-    TemplatesDict,
-    FormatObject,
-)
-from .log import PypeLogger
-
-log = PypeLogger().get_logger(__name__)
-
-try:
-    StringType = basestring
-except NameError:
-    StringType = str
+import warnings
+import functools
 
 
-class ProjectNotSet(Exception):
-    """Exception raised when is created Anatomy without project name."""
+class AnatomyDeprecatedWarning(DeprecationWarning):
+    pass
 
 
-class RootCombinationError(Exception):
-    """This exception is raised when templates has combined root types."""
+def anatomy_deprecated(func):
+    """Mark functions as deprecated.
 
-    def __init__(self, roots):
-        joined_roots = ", ".join(
-            ["\"{}\"".format(_root) for _root in roots]
-        )
-        # TODO better error message
-        msg = (
-            "Combination of root with and"
-            " without root name in AnatomyTemplates. {}"
-        ).format(joined_roots)
-
-        super(RootCombinationError, self).__init__(msg)
-
-
-class Anatomy:
-    """Anatomy module helps to keep project settings.
-
-    Wraps key project specifications, AnatomyTemplates and Roots.
-
-    Args:
-        project_name (str): Project name to look on overrides.
+    It will result in a warning being emitted when the function is used.
     """
 
-    root_key_regex = re.compile(r"{(root?[^}]+)}")
-    root_name_regex = re.compile(r"root\[([^]]+)\]")
-
-    def __init__(self, project_name=None, site_name=None):
-        if not project_name:
-            project_name = os.environ.get("AVALON_PROJECT")
-
-        if not project_name:
-            raise ProjectNotSet((
-                "Implementation bug: Project name is not set. Anatomy requires"
-                " to load data for specific project."
-            ))
-
-        self.project_name = project_name
-
-        self._data = self._prepare_anatomy_data(
-            get_anatomy_settings(project_name, site_name)
+    @functools.wraps(func)
+    def new_func(*args, **kwargs):
+        warnings.simplefilter("always", AnatomyDeprecatedWarning)
+        warnings.warn(
+            (
+                "Deprecated import of 'Anatomy'."
+                " Class was moved to 'openpype.pipeline.anatomy'."
+                " Please change your imports of Anatomy in codebase."
+            ),
+            category=AnatomyDeprecatedWarning
         )
-        self._site_name = site_name
-        self._templates_obj = AnatomyTemplates(self)
-        self._roots_obj = Roots(self)
+        return func(*args, **kwargs)
+    return new_func
 
-    # Anatomy used as dictionary
-    # - implemented only getters returning copy
-    def __getitem__(self, key):
-        return copy.deepcopy(self._data[key])
 
-    def get(self, key, default=None):
-        return copy.deepcopy(self._data).get(key, default)
-
-    def keys(self):
-        return copy.deepcopy(self._data).keys()
-
-    def values(self):
-        return copy.deepcopy(self._data).values()
-
-    def items(self):
-        return copy.deepcopy(self._data).items()
-
-    @staticmethod
-    def default_data():
-        """Default project anatomy data.
-
-        Always return fresh loaded data. May be used as data for new project.
-
-        Not used inside Anatomy itself.
-        """
-        return get_default_anatomy_settings(clear_metadata=False)
-
-    @staticmethod
-    def _prepare_anatomy_data(anatomy_data):
-        """Prepare anatomy data for further processing.
-
-        Method added to replace `{task}` with `{task[name]}` in templates.
-        """
-        templates_data = anatomy_data.get("templates")
-        if templates_data:
-            # Replace `{task}` with `{task[name]}` in templates
-            value_queue = collections.deque()
-            value_queue.append(templates_data)
-            while value_queue:
-                item = value_queue.popleft()
-                if not isinstance(item, dict):
-                    continue
-
-                for key in tuple(item.keys()):
-                    value = item[key]
-                    if isinstance(value, dict):
-                        value_queue.append(value)
-
-                    elif isinstance(value, StringType):
-                        item[key] = value.replace("{task}", "{task[name]}")
-        return anatomy_data
-
-    def reset(self):
-        """Reset values of cached data in templates and roots objects."""
-        self._data = self._prepare_anatomy_data(
-            get_anatomy_settings(self.project_name, self._site_name)
-        )
-        self.templates_obj.reset()
-        self.roots_obj.reset()
-
-    @property
-    def templates(self):
-        """Wrap property `templates` of Anatomy's AnatomyTemplates instance."""
-        return self._templates_obj.templates
-
-    @property
-    def templates_obj(self):
-        """Return `AnatomyTemplates` object of current Anatomy instance."""
-        return self._templates_obj
-
-    def format(self, *args, **kwargs):
-        """Wrap `format` method of Anatomy's `templates_obj`."""
-        return self._templates_obj.format(*args, **kwargs)
-
-    def format_all(self, *args, **kwargs):
-        """Wrap `format_all` method of Anatomy's `templates_obj`."""
-        return self._templates_obj.format_all(*args, **kwargs)
-
-    @property
-    def roots(self):
-        """Wrap `roots` property of Anatomy's `roots_obj`."""
-        return self._roots_obj.roots
-
-    @property
-    def roots_obj(self):
-        """Return `Roots` object of current Anatomy instance."""
-        return self._roots_obj
-
-    def root_environments(self):
-        """Return OPENPYPE_ROOT_* environments for current project in dict."""
-        return self._roots_obj.root_environments()
-
-    def root_environmets_fill_data(self, template=None):
-        """Environment variable values in dictionary for rootless path.
-
-        Args:
-            template (str): Template for environment variable key fill.
-                By default is set to `"${}"`.
-        """
-        return self.roots_obj.root_environmets_fill_data(template)
-
-    def find_root_template_from_path(self, *args, **kwargs):
-        """Wrapper for Roots `find_root_template_from_path`."""
-        return self.roots_obj.find_root_template_from_path(*args, **kwargs)
-
-    def path_remapper(self, *args, **kwargs):
-        """Wrapper for Roots `path_remapper`."""
-        return self.roots_obj.path_remapper(*args, **kwargs)
-
-    def all_root_paths(self):
-        """Wrapper for Roots `all_root_paths`."""
-        return self.roots_obj.all_root_paths()
-
-    def set_root_environments(self):
-        """Set OPENPYPE_ROOT_* environments for current project."""
-        self._roots_obj.set_root_environments()
-
-    def root_names(self):
-        """Return root names for current project."""
-        return self.root_names_from_templates(self.templates)
-
-    def _root_keys_from_templates(self, data):
-        """Extract root key from templates in data.
-
-        Args:
-            data (dict): Data that may contain templates as string.
-
-        Return:
-            set: Set of all root names from templates as strings.
-
-        Output example: `{"root[work]", "root[publish]"}`
-        """
-
-        output = set()
-        if isinstance(data, dict):
-            for value in data.values():
-                for root in self._root_keys_from_templates(value):
-                    output.add(root)
-
-        elif isinstance(data, str):
-            for group in re.findall(self.root_key_regex, data):
-                output.add(group)
-
-        return output
-
-    def root_value_for_template(self, template):
-        """Returns value of root key from template."""
-        root_templates = []
-        for group in re.findall(self.root_key_regex, template):
-            root_templates.append("{" + group + "}")
-
-        if not root_templates:
-            return None
-
-        return root_templates[0].format(**{"root": self.roots})
-
-    def root_names_from_templates(self, templates):
-        """Extract root names form anatomy templates.
-
-        Returns None if values in templates contain only "{root}".
-        Empty list is returned if there is no "root" in templates.
-        Else returns all root names from templates in list.
-
-        RootCombinationError is raised when templates contain both root types,
-        basic "{root}" and with root name specification "{root[work]}".
-
-        Args:
-            templates (dict): Anatomy templates where roots are not filled.
-
-        Return:
-            list/None: List of all root names from templates as strings when
-            multiroot setup is used, otherwise None is returned.
-        """
-        roots = list(self._root_keys_from_templates(templates))
-        # Return empty list if no roots found in templates
-        if not roots:
-            return roots
-
-        # Raise exception when root keys have roots with and without root name.
-        # Invalid output example: ["root", "root[project]", "root[render]"]
-        if len(roots) > 1 and "root" in roots:
-            raise RootCombinationError(roots)
-
-        # Return None if "root" without root name in templates
-        if len(roots) == 1 and roots[0] == "root":
-            return None
-
-        names = set()
-        for root in roots:
-            for group in re.findall(self.root_name_regex, root):
-                names.add(group)
-        return list(names)
-
-    def fill_root(self, template_path):
-        """Fill template path where is only "root" key unfilled.
-
-        Args:
-            template_path (str): Path with "root" key in.
-                Example path: "{root}/projects/MyProject/Shot01/Lighting/..."
-
-        Return:
-            str: formatted path
-        """
-        # NOTE does not care if there are different keys than "root"
-        return template_path.format(**{"root": self.roots})
-
-    @classmethod
-    def fill_root_with_path(cls, rootless_path, root_path):
-        """Fill path without filled "root" key with passed path.
-
-        This is helper to fill root with different directory path than anatomy
-        has defined no matter if is single or multiroot.
-
-        Output path is same as input path if `rootless_path` does not contain
-        unfilled root key.
-
-        Args:
-            rootless_path (str): Path without filled "root" key. Example:
-                "{root[work]}/MyProject/..."
-            root_path (str): What should replace root key in `rootless_path`.
-
-        Returns:
-            str: Path with filled root.
-        """
-        output = str(rootless_path)
-        for group in re.findall(cls.root_key_regex, rootless_path):
-            replacement = "{" + group + "}"
-            output = output.replace(replacement, root_path)
-
-        return output
-
-    def replace_root_with_env_key(self, filepath, template=None):
-        """Replace root of path with environment key.
-
-        # Example:
-        ## Project with roots:
-        ```
-        {
-            "nas": {
-                "windows": P:/projects",
-                ...
-            }
-            ...
-        }
-        ```
-
-        ## Entered filepath
-        "P:/projects/project/asset/task/animation_v001.ma"
-
-        ## Entered template
-        "<{}>"
-
-        ## Output
-        "<OPENPYPE_PROJECT_ROOT_NAS>/project/asset/task/animation_v001.ma"
-
-        Args:
-            filepath (str): Full file path where root should be replaced.
-            template (str): Optional template for environment key. Must
-                have one index format key.
-                Default value if not entered: "${}"
-
-        Returns:
-            str: Path where root is replaced with environment root key.
-
-        Raise:
-            ValueError: When project's roots were not found in entered path.
-        """
-        success, rootless_path = self.find_root_template_from_path(filepath)
-        if not success:
-            raise ValueError(
-                "{}: Project's roots were not found in path: {}".format(
-                    self.project_name, filepath
-                )
-            )
-
-        data = self.root_environmets_fill_data(template)
-        return rootless_path.format(**data)
-
-
-class AnatomyTemplateUnsolved(TemplateUnsolved):
-    """Exception for unsolved template when strict is set to True."""
-
-    msg = "Anatomy template \"{0}\" is unsolved.{1}{2}"
-
-
-class AnatomyTemplateResult(TemplateResult):
-    rootless = None
-
-    def __new__(cls, result, rootless_path):
-        new_obj = super(AnatomyTemplateResult, cls).__new__(
-            cls,
-            str(result),
-            result.template,
-            result.solved,
-            result.used_values,
-            result.missing_keys,
-            result.invalid_types
-        )
-        new_obj.rootless = rootless_path
-        return new_obj
-
-    def validate(self):
-        if not self.solved:
-            raise AnatomyTemplateUnsolved(
-                self.template,
-                self.missing_keys,
-                self.invalid_types
-            )
-
-
-class AnatomyTemplates(TemplatesDict):
-    inner_key_pattern = re.compile(r"(\{@.*?[^{}0]*\})")
-    inner_key_name_pattern = re.compile(r"\{@(.*?[^{}0]*)\}")
-
-    def __init__(self, anatomy):
-        super(AnatomyTemplates, self).__init__()
-        self.anatomy = anatomy
-        self.loaded_project = None
-
-    def __getitem__(self, key):
-        return self.templates[key]
-
-    def get(self, key, default=None):
-        return self.templates.get(key, default)
-
-    def reset(self):
-        self._raw_templates = None
-        self._templates = None
-        self._objected_templates = None
-
-    @property
-    def project_name(self):
-        return self.anatomy.project_name
-
-    @property
-    def roots(self):
-        return self.anatomy.roots
-
-    @property
-    def templates(self):
-        self._validate_discovery()
-        return self._templates
-
-    @property
-    def objected_templates(self):
-        self._validate_discovery()
-        return self._objected_templates
-
-    def _validate_discovery(self):
-        if self.project_name != self.loaded_project:
-            self.reset()
-
-        if self._templates is None:
-            self._discover()
-            self.loaded_project = self.project_name
-
-    def _format_value(self, value, data):
-        if isinstance(value, RootItem):
-            return self._solve_dict(value, data)
-
-        result = super(AnatomyTemplates, self)._format_value(value, data)
-        if isinstance(result, TemplateResult):
-            rootless_path = self._rootless_path(result, data)
-            result = AnatomyTemplateResult(result, rootless_path)
-        return result
-
-    def set_templates(self, templates):
-        if not templates:
-            self.reset()
-            return
-
-        self._raw_templates = copy.deepcopy(templates)
-        templates = copy.deepcopy(templates)
-        v_queue = collections.deque()
-        v_queue.append(templates)
-        while v_queue:
-            item = v_queue.popleft()
-            if not isinstance(item, dict):
-                continue
-
-            for key in tuple(item.keys()):
-                value = item[key]
-                if isinstance(value, dict):
-                    v_queue.append(value)
-
-                elif (
-                    isinstance(value, StringType)
-                    and "{task}" in value
-                ):
-                    item[key] = value.replace("{task}", "{task[name]}")
-
-        solved_templates = self.solve_template_inner_links(templates)
-        self._templates = solved_templates
-        self._objected_templates = self.create_ojected_templates(
-            solved_templates
-        )
-
-    def default_templates(self):
-        """Return default templates data with solved inner keys."""
-        return self.solve_template_inner_links(
-            self.anatomy["templates"]
-        )
-
-    def _discover(self):
-        """ Loads anatomy templates from yaml.
-        Default templates are loaded if project is not set or project does
-        not have set it's own.
-        TODO: create templates if not exist.
-
-        Returns:
-            TemplatesResultDict: Contain templates data for current project of
-                default templates.
-        """
-
-        if self.project_name is None:
-            # QUESTION create project specific if not found?
-            raise AssertionError((
-                "Project \"{0}\" does not have his own templates."
-                " Trying to use default."
-            ).format(self.project_name))
-
-        self.set_templates(self.anatomy["templates"])
-
-    @classmethod
-    def replace_inner_keys(cls, matches, value, key_values, key):
-        """Replacement of inner keys in template values."""
-        for match in matches:
-            anatomy_sub_keys = (
-                cls.inner_key_name_pattern.findall(match)
-            )
-            if key in anatomy_sub_keys:
-                raise ValueError((
-                    "Unsolvable recursion in inner keys, "
-                    "key: \"{}\" is in his own value."
-                    " Can't determine source, please check Anatomy templates."
-                ).format(key))
-
-            for anatomy_sub_key in anatomy_sub_keys:
-                replace_value = key_values.get(anatomy_sub_key)
-                if replace_value is None:
-                    raise KeyError((
-                        "Anatomy templates can't be filled."
-                        " Anatomy key `{0}` has"
-                        " invalid inner key `{1}`."
-                    ).format(key, anatomy_sub_key))
-
-                valid = isinstance(replace_value, (numbers.Number, StringType))
-                if not valid:
-                    raise ValueError((
-                        "Anatomy templates can't be filled."
-                        " Anatomy key `{0}` has"
-                        " invalid inner key `{1}`"
-                        " with value `{2}`."
-                    ).format(key, anatomy_sub_key, str(replace_value)))
-
-                value = value.replace(match, str(replace_value))
-
-        return value
-
-    @classmethod
-    def prepare_inner_keys(cls, key_values):
-        """Check values of inner keys.
-
-        Check if inner key exist in template group and has valid value.
-        It is also required to avoid infinite loop with unsolvable recursion
-        when first inner key's value refers to second inner key's value where
-        first is used.
-        """
-        keys_to_solve = set(key_values.keys())
-        while True:
-            found = False
-            for key in tuple(keys_to_solve):
-                value = key_values[key]
-
-                if isinstance(value, StringType):
-                    matches = cls.inner_key_pattern.findall(value)
-                    if not matches:
-                        keys_to_solve.remove(key)
-                        continue
-
-                    found = True
-                    key_values[key] = cls.replace_inner_keys(
-                        matches, value, key_values, key
-                    )
-                    continue
-
-                elif not isinstance(value, dict):
-                    keys_to_solve.remove(key)
-                    continue
-
-                subdict_found = False
-                for _key, _value in tuple(value.items()):
-                    matches = cls.inner_key_pattern.findall(_value)
-                    if not matches:
-                        continue
-
-                    subdict_found = True
-                    found = True
-                    key_values[key][_key] = cls.replace_inner_keys(
-                        matches, _value, key_values,
-                        "{}.{}".format(key, _key)
-                    )
-
-                if not subdict_found:
-                    keys_to_solve.remove(key)
-
-            if not found:
-                break
-
-        return key_values
-
-    @classmethod
-    def solve_template_inner_links(cls, templates):
-        """Solve templates inner keys identified by "{@*}".
-
-        Process is split into 2 parts.
-        First is collecting all global keys (keys in top hierarchy where value
-        is not dictionary). All global keys are set for all group keys (keys
-        in top hierarchy where value is dictionary). Value of a key is not
-        overridden in group if already contain value for the key.
-
-        In second part all keys with "at" symbol in value are replaced with
-        value of the key afterward "at" symbol from the group.
-
-        Args:
-            templates (dict): Raw templates data.
-
-        Example:
-            templates::
-                key_1: "value_1",
-                key_2: "{@key_1}/{filling_key}"
-
-                group_1:
-                    key_3: "value_3/{@key_2}"
-
-                group_2:
-                    key_2": "value_2"
-                    key_4": "value_4/{@key_2}"
-
-            output::
-                key_1: "value_1"
-                key_2: "value_1/{filling_key}"
-
-                group_1: {
-                    key_1: "value_1"
-                    key_2: "value_1/{filling_key}"
-                    key_3: "value_3/value_1/{filling_key}"
-
-                group_2: {
-                    key_1: "value_1"
-                    key_2: "value_2"
-                    key_4: "value_3/value_2"
-        """
-        default_key_values = templates.pop("defaults", {})
-        for key, value in tuple(templates.items()):
-            if isinstance(value, dict):
-                continue
-            default_key_values[key] = templates.pop(key)
-
-        # Pop "others" key before before expected keys are processed
-        other_templates = templates.pop("others") or {}
-
-        keys_by_subkey = {}
-        for sub_key, sub_value in templates.items():
-            key_values = {}
-            key_values.update(default_key_values)
-            key_values.update(sub_value)
-            keys_by_subkey[sub_key] = cls.prepare_inner_keys(key_values)
-
-        for sub_key, sub_value in other_templates.items():
-            if sub_key in keys_by_subkey:
-                log.warning((
-                    "Key \"{}\" is duplicated in others. Skipping."
-                ).format(sub_key))
-                continue
-
-            key_values = {}
-            key_values.update(default_key_values)
-            key_values.update(sub_value)
-            keys_by_subkey[sub_key] = cls.prepare_inner_keys(key_values)
-
-        default_keys_by_subkeys = cls.prepare_inner_keys(default_key_values)
-
-        for key, value in default_keys_by_subkeys.items():
-            keys_by_subkey[key] = value
-
-        return keys_by_subkey
-
-    def _dict_to_subkeys_list(self, subdict, pre_keys=None):
-        if pre_keys is None:
-            pre_keys = []
-        output = []
-        for key in subdict:
-            value = subdict[key]
-            result = list(pre_keys)
-            result.append(key)
-            if isinstance(value, dict):
-                for item in self._dict_to_subkeys_list(value, result):
-                    output.append(item)
-            else:
-                output.append(result)
-        return output
-
-    def _keys_to_dicts(self, key_list, value):
-        if not key_list:
-            return None
-        if len(key_list) == 1:
-            return {key_list[0]: value}
-        return {key_list[0]: self._keys_to_dicts(key_list[1:], value)}
-
-    def _rootless_path(self, result, final_data):
-        used_values = result.used_values
-        missing_keys = result.missing_keys
-        template = result.template
-        invalid_types = result.invalid_types
-        if (
-            "root" not in used_values
-            or "root" in missing_keys
-            or "{root" not in template
-        ):
-            return
-
-        for invalid_type in invalid_types:
-            if "root" in invalid_type:
-                return
-
-        root_keys = self._dict_to_subkeys_list({"root": used_values["root"]})
-        if not root_keys:
-            return
-
-        output = str(result)
-        for used_root_keys in root_keys:
-            if not used_root_keys:
-                continue
-
-            used_value = used_values
-            root_key = None
-            for key in used_root_keys:
-                used_value = used_value[key]
-                if root_key is None:
-                    root_key = key
-                else:
-                    root_key += "[{}]".format(key)
-
-            root_key = "{" + root_key + "}"
-            output = output.replace(str(used_value), root_key)
-
-        return output
-
-    def format(self, data, strict=True):
-        copy_data = copy.deepcopy(data)
-        roots = self.roots
-        if roots:
-            copy_data["root"] = roots
-        result = super(AnatomyTemplates, self).format(copy_data)
-        result.strict = strict
-        return result
-
-    def format_all(self, in_data, only_keys=True):
-        """ Solves templates based on entered data.
-
-        Args:
-            data (dict): Containing keys to be filled into template.
-
-        Returns:
-            TemplatesResultDict: Output `TemplateResult` have `strict`
-                attribute set to False so accessing unfilled keys in templates
-                won't raise any exceptions.
-        """
-        return self.format(in_data, strict=False)
-
-
-class RootItem(FormatObject):
-    """Represents one item or roots.
-
-    Holds raw data of root item specification. Raw data contain value
-    for each platform, but current platform value is used when object
-    is used for formatting of template.
-
-    Args:
-        root_raw_data (dict): Dictionary containing root values by platform
-            names. ["windows", "linux" and "darwin"]
-        name (str, optional): Root name which is representing. Used with
-            multi root setup otherwise None value is expected.
-        parent_keys (list, optional): All dictionary parent keys. Values of
-            `parent_keys` are used for get full key which RootItem is
-            representing. Used for replacing root value in path with
-            formattable key. e.g. parent_keys == ["work"] -> {root[work]}
-        parent (object, optional): It is expected to be `Roots` object.
-            Value of `parent` won't affect code logic much.
-    """
-
-    def __init__(
-        self, root_raw_data, name=None, parent_keys=None, parent=None
-    ):
-        lowered_platform_keys = {}
-        for key, value in root_raw_data.items():
-            lowered_platform_keys[key.lower()] = value
-        self.raw_data = lowered_platform_keys
-        self.cleaned_data = self._clean_roots(lowered_platform_keys)
-        self.name = name
-        self.parent_keys = parent_keys or []
-        self.parent = parent
-
-        self.available_platforms = list(lowered_platform_keys.keys())
-        self.value = lowered_platform_keys.get(platform.system().lower())
-        self.clean_value = self.clean_root(self.value)
-
-    def __format__(self, *args, **kwargs):
-        return self.value.__format__(*args, **kwargs)
-
-    def __str__(self):
-        return str(self.value)
-
-    def __repr__(self):
-        return self.__str__()
-
-    def __getitem__(self, key):
-        if isinstance(key, numbers.Number):
-            return self.value[key]
-
-        additional_info = ""
-        if self.parent and self.parent.project_name:
-            additional_info += " for project \"{}\"".format(
-                self.parent.project_name
-            )
-
-        raise AssertionError(
-            "Root key \"{}\" is missing{}.".format(
-                key, additional_info
-            )
-        )
-
-    def full_key(self):
-        """Full key value for dictionary formatting in template.
-
-        Returns:
-            str: Return full replacement key for formatting. This helps when
-                multiple roots are set. In that case e.g. `"root[work]"` is
-                returned.
-        """
-        if not self.name:
-            return "root"
-
-        joined_parent_keys = "".join(
-            ["[{}]".format(key) for key in self.parent_keys]
-        )
-        return "root{}".format(joined_parent_keys)
-
-    def clean_path(self, path):
-        """Just replace backslashes with forward slashes."""
-        return str(path).replace("\\", "/")
-
-    def clean_root(self, root):
-        """Makes sure root value does not end with slash."""
-        if root:
-            root = self.clean_path(root)
-            while root.endswith("/"):
-                root = root[:-1]
-        return root
-
-    def _clean_roots(self, raw_data):
-        """Clean all values of raw root item values."""
-        cleaned = {}
-        for key, value in raw_data.items():
-            cleaned[key] = self.clean_root(value)
-        return cleaned
-
-    def path_remapper(self, path, dst_platform=None, src_platform=None):
-        """Remap path for specific platform.
-
-        Args:
-            path (str): Source path which need to be remapped.
-            dst_platform (str, optional): Specify destination platform
-                for which remapping should happen.
-            src_platform (str, optional): Specify source platform. This is
-                recommended to not use and keep unset until you really want
-                to use specific platform.
-            roots (dict/RootItem/None, optional): It is possible to remap
-                path with different roots then instance where method was
-                called has.
-
-        Returns:
-            str/None: When path does not contain known root then
-                None is returned else returns remapped path with "{root}"
-                or "{root[<name>]}".
-        """
-        cleaned_path = self.clean_path(path)
-        if dst_platform:
-            dst_root_clean = self.cleaned_data.get(dst_platform)
-            if not dst_root_clean:
-                key_part = ""
-                full_key = self.full_key()
-                if full_key != "root":
-                    key_part += "\"{}\" ".format(full_key)
-
-                log.warning(
-                    "Root {}miss platform \"{}\" definition.".format(
-                        key_part, dst_platform
-                    )
-                )
-                return None
-
-            if cleaned_path.startswith(dst_root_clean):
-                return cleaned_path
-
-        if src_platform:
-            src_root_clean = self.cleaned_data.get(src_platform)
-            if src_root_clean is None:
-                log.warning(
-                    "Root \"{}\" miss platform \"{}\" definition.".format(
-                        self.full_key(), src_platform
-                    )
-                )
-                return None
-
-            if not cleaned_path.startswith(src_root_clean):
-                return None
-
-            subpath = cleaned_path[len(src_root_clean):]
-            if dst_platform:
-                # `dst_root_clean` is used from upper condition
-                return dst_root_clean + subpath
-            return self.clean_value + subpath
-
-        result, template = self.find_root_template_from_path(path)
-        if not result:
-            return None
-
-        def parent_dict(keys, value):
-            if not keys:
-                return value
-
-            key = keys.pop(0)
-            return {key: parent_dict(keys, value)}
-
-        if dst_platform:
-            format_value = parent_dict(list(self.parent_keys), dst_root_clean)
-        else:
-            format_value = parent_dict(list(self.parent_keys), self.value)
-
-        return template.format(**{"root": format_value})
-
-    def find_root_template_from_path(self, path):
-        """Replaces known root value with formattable key in path.
-
-        All platform values are checked for this replacement.
-
-        Args:
-            path (str): Path where root value should be found.
-
-        Returns:
-            tuple: Tuple contain 2 values: `success` (bool) and `path` (str).
-                When success it True then path should contain replaced root
-                value with formattable key.
-
-        Example:
-            When input path is::
-                "C:/windows/path/root/projects/my_project/file.ext"
-
-            And raw data of item looks like::
-                {
-                    "windows": "C:/windows/path/root",
-                    "linux": "/mount/root"
-                }
-
-            Output will be::
-                (True, "{root}/projects/my_project/file.ext")
-
-            If any of raw data value wouldn't match path's root output is::
-                (False, "C:/windows/path/root/projects/my_project/file.ext")
-        """
-        result = False
-        output = str(path)
-
-        root_paths = list(self.cleaned_data.values())
-        mod_path = self.clean_path(path)
-        for root_path in root_paths:
-            # Skip empty paths
-            if not root_path:
-                continue
-
-            if mod_path.startswith(root_path):
-                result = True
-                replacement = "{" + self.full_key() + "}"
-                output = replacement + mod_path[len(root_path):]
-                break
-
-        return (result, output)
-
-
-class Roots:
-    """Object which should be used for formatting "root" key in templates.
-
-    Args:
-        anatomy Anatomy: Anatomy object created for a specific project.
-    """
-
-    env_prefix = "OPENPYPE_PROJECT_ROOT"
-    roots_filename = "roots.json"
-
-    def __init__(self, anatomy):
-        self.anatomy = anatomy
-        self.loaded_project = None
-        self._roots = None
-
-    def __format__(self, *args, **kwargs):
-        return self.roots.__format__(*args, **kwargs)
-
-    def __getitem__(self, key):
-        return self.roots[key]
-
-    def reset(self):
-        """Reset current roots value."""
-        self._roots = None
-
-    def path_remapper(
-        self, path, dst_platform=None, src_platform=None, roots=None
-    ):
-        """Remap path for specific platform.
-
-        Args:
-            path (str): Source path which need to be remapped.
-            dst_platform (str, optional): Specify destination platform
-                for which remapping should happen.
-            src_platform (str, optional): Specify source platform. This is
-                recommended to not use and keep unset until you really want
-                to use specific platform.
-            roots (dict/RootItem/None, optional): It is possible to remap
-                path with different roots then instance where method was
-                called has.
-
-        Returns:
-            str/None: When path does not contain known root then
-                None is returned else returns remapped path with "{root}"
-                or "{root[<name>]}".
-        """
-        if roots is None:
-            roots = self.roots
-
-        if roots is None:
-            raise ValueError("Roots are not set. Can't find path.")
-
-        if "{root" in path:
-            path = path.format(**{"root": roots})
-            # If `dst_platform` is not specified then return else continue.
-            if not dst_platform:
-                return path
-
-        if isinstance(roots, RootItem):
-            return roots.path_remapper(path, dst_platform, src_platform)
-
-        for _root in roots.values():
-            result = self.path_remapper(
-                path, dst_platform, src_platform, _root
-            )
-            if result is not None:
-                return result
-
-    def find_root_template_from_path(self, path, roots=None):
-        """Find root value in entered path and replace it with formatting key.
-
-        Args:
-            path (str): Source path where root will be searched.
-            roots (Roots/dict, optional): It is possible to use different
-                roots than instance where method was triggered has.
-
-        Returns:
-            tuple: Output contains tuple with bool representing success as
-                first value and path with or without replaced root with
-                formatting key as second value.
-
-        Raises:
-            ValueError: When roots are not entered and can't be loaded.
-        """
-        if roots is None:
-            log.debug(
-                "Looking for matching root in path \"{}\".".format(path)
-            )
-            roots = self.roots
-
-        if roots is None:
-            raise ValueError("Roots are not set. Can't find path.")
-
-        if isinstance(roots, RootItem):
-            return roots.find_root_template_from_path(path)
-
-        for root_name, _root in roots.items():
-            success, result = self.find_root_template_from_path(path, _root)
-            if success:
-                log.info("Found match in root \"{}\".".format(root_name))
-                return success, result
-
-        log.warning("No matching root was found in current setting.")
-        return (False, path)
-
-    def set_root_environments(self):
-        """Set root environments for current project."""
-        for key, value in self.root_environments().items():
-            os.environ[key] = value
-
-    def root_environments(self):
-        """Use root keys to create unique keys for environment variables.
-
-        Concatenates prefix "OPENPYPE_ROOT" with root keys to create unique
-        keys.
-
-        Returns:
-            dict: Result is `{(str): (str)}` dicitonary where key represents
-                unique key concatenated by keys and value is root value of
-                current platform root.
-
-        Example:
-            With raw root values::
-                "work": {
-                    "windows": "P:/projects/work",
-                    "linux": "/mnt/share/projects/work",
-                    "darwin": "/darwin/path/work"
-                },
-                "publish": {
-                    "windows": "P:/projects/publish",
-                    "linux": "/mnt/share/projects/publish",
-                    "darwin": "/darwin/path/publish"
-                }
-
-            Result on windows platform::
-                {
-                    "OPENPYPE_ROOT_WORK": "P:/projects/work",
-                    "OPENPYPE_ROOT_PUBLISH": "P:/projects/publish"
-                }
-
-            Short example when multiroot is not used::
-                {
-                    "OPENPYPE_ROOT": "P:/projects"
-                }
-        """
-        return self._root_environments()
-
-    def all_root_paths(self, roots=None):
-        """Return all paths for all roots of all platforms."""
-        if roots is None:
-            roots = self.roots
-
-        output = []
-        if isinstance(roots, RootItem):
-            for value in roots.raw_data.values():
-                output.append(value)
-            return output
-
-        for _roots in roots.values():
-            output.extend(self.all_root_paths(_roots))
-        return output
-
-    def _root_environments(self, keys=None, roots=None):
-        if not keys:
-            keys = []
-        if roots is None:
-            roots = self.roots
-
-        if isinstance(roots, RootItem):
-            key_items = [self.env_prefix]
-            for _key in keys:
-                key_items.append(_key.upper())
-
-            key = "_".join(key_items)
-            # Make sure key and value does not contain unicode
-            #   - can happen in Python 2 hosts
-            return {str(key): str(roots.value)}
-
-        output = {}
-        for _key, _value in roots.items():
-            _keys = list(keys)
-            _keys.append(_key)
-            output.update(self._root_environments(_keys, _value))
-        return output
-
-    def root_environmets_fill_data(self, template=None):
-        """Environment variable values in dictionary for rootless path.
-
-        Args:
-            template (str): Template for environment variable key fill.
-                By default is set to `"${}"`.
-        """
-        if template is None:
-            template = "${}"
-        return self._root_environmets_fill_data(template)
-
-    def _root_environmets_fill_data(self, template, keys=None, roots=None):
-        if keys is None and roots is None:
-            return {
-                "root": self._root_environmets_fill_data(
-                    template, [], self.roots
-                )
-            }
-
-        if isinstance(roots, RootItem):
-            key_items = [Roots.env_prefix]
-            for _key in keys:
-                key_items.append(_key.upper())
-            key = "_".join(key_items)
-            return template.format(key)
-
-        output = {}
-        for key, value in roots.items():
-            _keys = list(keys)
-            _keys.append(key)
-            output[key] = self._root_environmets_fill_data(
-                template, _keys, value
-            )
-        return output
-
-    @property
-    def project_name(self):
-        """Return project name which will be used for loading root values."""
-        return self.anatomy.project_name
-
-    @property
-    def roots(self):
-        """Property for filling "root" key in templates.
-
-        This property returns roots for current project or default root values.
-        Warning:
-            Default roots value may cause issues when project use different
-            roots settings. That may happen when project use multiroot
-            templates but default roots miss their keys.
-        """
-        if self.project_name != self.loaded_project:
-            self._roots = None
-
-        if self._roots is None:
-            self._roots = self._discover()
-            self.loaded_project = self.project_name
-        return self._roots
-
-    def _discover(self):
-        """ Loads current project's roots or default.
-
-        Default roots are loaded if project override's does not contain roots.
-
-        Returns:
-            `RootItem` or `dict` with multiple `RootItem`s when multiroot
-            setting is used.
-        """
-
-        return self._parse_dict(self.anatomy["roots"], parent=self)
-
-    @staticmethod
-    def _parse_dict(data, key=None, parent_keys=None, parent=None):
-        """Parse roots raw data into RootItem or dictionary with RootItems.
-
-        Converting raw roots data to `RootItem` helps to handle platform keys.
-        This method is recursive to be able handle multiroot setup and
-        is static to be able to load default roots without creating new object.
-
-        Args:
-            data (dict): Should contain raw roots data to be parsed.
-            key (str, optional): Current root key. Set by recursion.
-            parent_keys (list): Parent dictionary keys. Set by recursion.
-            parent (Roots, optional): Parent object set in `RootItem`
-                helps to keep RootItem instance updated with `Roots` object.
-
-        Returns:
-            `RootItem` or `dict` with multiple `RootItem`s when multiroot
-            setting is used.
-        """
-        if not parent_keys:
-            parent_keys = []
-        is_last = False
-        for value in data.values():
-            if isinstance(value, StringType):
-                is_last = True
-                break
-
-        if is_last:
-            return RootItem(data, key, parent_keys, parent=parent)
-
-        output = {}
-        for _key, value in data.items():
-            _parent_keys = list(parent_keys)
-            _parent_keys.append(_key)
-            output[_key] = Roots._parse_dict(value, _key, _parent_keys, parent)
-        return output
+@anatomy_deprecated
+def Anatomy(*args, **kwargs):
+    from openpype.pipeline.anatomy import Anatomy
+    return Anatomy(*args, **kwargs)
diff --git a/openpype/lib/applications.py b/openpype/lib/applications.py
index a81bdeca0f..d229848645 100644
--- a/openpype/lib/applications.py
+++ b/openpype/lib/applications.py
@@ -20,10 +20,7 @@ from openpype.settings.constants import (
     METADATA_KEYS,
     M_DYNAMIC_KEY_LABEL
 )
-from . import (
-    PypeLogger,
-    Anatomy
-)
+from . import PypeLogger
 from .profiles_filtering import filter_profiles
 from .local_settings import get_openpype_username
 from .avalon_context import (
@@ -1305,7 +1302,7 @@ def get_app_environments_for_context(
         dict: Environments for passed context and application.
     """
 
-    from openpype.pipeline import AvalonMongoDB
+    from openpype.pipeline import AvalonMongoDB, Anatomy
 
     # Avalon database connection
     dbcon = AvalonMongoDB()
diff --git a/openpype/lib/avalon_context.py b/openpype/lib/avalon_context.py
index a03f066300..616460410e 100644
--- a/openpype/lib/avalon_context.py
+++ b/openpype/lib/avalon_context.py
@@ -14,7 +14,6 @@ from openpype.settings import (
     get_project_settings,
     get_system_settings
 )
-from .anatomy import Anatomy
 from .profiles_filtering import filter_profiles
 from .events import emit_event
 from .path_templates import StringTemplate
@@ -593,6 +592,7 @@ def get_workdir_with_workdir_data(
         ))
 
     if not anatomy:
+        from openpype.pipeline import Anatomy
         anatomy = Anatomy(project_name)
 
     if not template_key:
@@ -604,7 +604,10 @@ def get_workdir_with_workdir_data(
 
     anatomy_filled = anatomy.format(workdir_data)
     # Output is TemplateResult object which contain useful data
-    return anatomy_filled[template_key]["folder"]
+    path = anatomy_filled[template_key]["folder"]
+    if path:
+        path = os.path.normpath(path)
+    return path
 
 
 def get_workdir(
@@ -635,6 +638,7 @@ def get_workdir(
         TemplateResult: Workdir path.
     """
     if not anatomy:
+        from openpype.pipeline import Anatomy
         anatomy = Anatomy(project_doc["name"])
 
     workdir_data = get_workdir_data(
@@ -747,6 +751,8 @@ def compute_session_changes(
 
 @with_pipeline_io
 def get_workdir_from_session(session=None, template_key=None):
+    from openpype.pipeline import Anatomy
+
     if session is None:
         session = legacy_io.Session
     project_name = session["AVALON_PROJECT"]
@@ -762,7 +768,10 @@ def get_workdir_from_session(session=None, template_key=None):
             host_name,
             project_name=project_name
         )
-    return anatomy_filled[template_key]["folder"]
+    path = anatomy_filled[template_key]["folder"]
+    if path:
+        path = os.path.normpath(path)
+    return path
 
 
 @with_pipeline_io
@@ -853,6 +862,8 @@ def create_workfile_doc(asset_doc, task_name, filename, workdir, dbcon=None):
         dbcon (AvalonMongoDB): Optionally enter avalon AvalonMongoDB object and
             `legacy_io` is used if not entered.
     """
+    from openpype.pipeline import Anatomy
+
     # Use legacy_io if dbcon is not entered
     if not dbcon:
         dbcon = legacy_io
@@ -1673,6 +1684,7 @@ def _get_task_context_data_for_anatomy(
     """
 
     if anatomy is None:
+        from openpype.pipeline import Anatomy
         anatomy = Anatomy(project_doc["name"])
 
     asset_name = asset_doc["name"]
@@ -1741,6 +1753,7 @@ def get_custom_workfile_template_by_context(
     """
 
     if anatomy is None:
+        from openpype.pipeline import Anatomy
         anatomy = Anatomy(project_doc["name"])
 
     # get project, asset, task anatomy context data
diff --git a/openpype/lib/path_tools.py b/openpype/lib/path_tools.py
index caad20f4d6..4f28be3302 100644
--- a/openpype/lib/path_tools.py
+++ b/openpype/lib/path_tools.py
@@ -9,7 +9,6 @@ import platform
 from openpype.client import get_project
 from openpype.settings import get_project_settings
 
-from .anatomy import Anatomy
 from .profiles_filtering import filter_profiles
 
 log = logging.getLogger(__name__)
@@ -227,6 +226,7 @@ def fill_paths(path_list, anatomy):
 
 
 def create_project_folders(basic_paths, project_name):
+    from openpype.pipeline import Anatomy
     anatomy = Anatomy(project_name)
 
     concat_paths = concatenate_splitted_paths(basic_paths, anatomy)
diff --git a/openpype/modules/avalon_apps/rest_api.py b/openpype/modules/avalon_apps/rest_api.py
index b35f5bf357..a52ce1b6df 100644
--- a/openpype/modules/avalon_apps/rest_api.py
+++ b/openpype/modules/avalon_apps/rest_api.py
@@ -5,7 +5,12 @@ from bson.objectid import ObjectId
 
 from aiohttp.web_response import Response
 
-from openpype.pipeline import AvalonMongoDB
+from openpype.client import (
+    get_projects,
+    get_project,
+    get_assets,
+    get_asset_by_name,
+)
 from openpype_modules.webserver.base_routes import RestApiEndpoint
 
 
@@ -14,19 +19,13 @@ class _RestApiEndpoint(RestApiEndpoint):
         self.resource = resource
         super(_RestApiEndpoint, self).__init__()
 
-    @property
-    def dbcon(self):
-        return self.resource.dbcon
-
 
 class AvalonProjectsEndpoint(_RestApiEndpoint):
     async def get(self) -> Response:
-        output = []
-        for project_name in self.dbcon.database.collection_names():
-            project_doc = self.dbcon.database[project_name].find_one({
-                "type": "project"
-            })
-            output.append(project_doc)
+        output = [
+            project_doc
+            for project_doc in get_projects()
+        ]
         return Response(
             status=200,
             body=self.resource.encode(output),
@@ -36,9 +35,7 @@ class AvalonProjectsEndpoint(_RestApiEndpoint):
 
 class AvalonProjectEndpoint(_RestApiEndpoint):
     async def get(self, project_name) -> Response:
-        project_doc = self.dbcon.database[project_name].find_one({
-            "type": "project"
-        })
+        project_doc = get_project(project_name)
         if project_doc:
             return Response(
                 status=200,
@@ -53,9 +50,7 @@ class AvalonProjectEndpoint(_RestApiEndpoint):
 
 class AvalonAssetsEndpoint(_RestApiEndpoint):
     async def get(self, project_name) -> Response:
-        asset_docs = list(self.dbcon.database[project_name].find({
-            "type": "asset"
-        }))
+        asset_docs = list(get_assets(project_name))
         return Response(
             status=200,
             body=self.resource.encode(asset_docs),
@@ -65,10 +60,7 @@ class AvalonAssetsEndpoint(_RestApiEndpoint):
 
 class AvalonAssetEndpoint(_RestApiEndpoint):
     async def get(self, project_name, asset_name) -> Response:
-        asset_doc = self.dbcon.database[project_name].find_one({
-            "type": "asset",
-            "name": asset_name
-        })
+        asset_doc = get_asset_by_name(project_name, asset_name)
         if asset_doc:
             return Response(
                 status=200,
@@ -88,9 +80,6 @@ class AvalonRestApiResource:
         self.module = avalon_module
         self.server_manager = server_manager
 
-        self.dbcon = AvalonMongoDB()
-        self.dbcon.install()
-
         self.prefix = "/avalon"
 
         self.endpoint_defs = (
diff --git a/openpype/modules/clockify/launcher_actions/ClockifyStart.py b/openpype/modules/clockify/launcher_actions/ClockifyStart.py
index 4669f98b01..7663aecc31 100644
--- a/openpype/modules/clockify/launcher_actions/ClockifyStart.py
+++ b/openpype/modules/clockify/launcher_actions/ClockifyStart.py
@@ -1,16 +1,9 @@
-from openpype.api import Logger
-from openpype.pipeline import (
-    legacy_io,
-    LauncherAction,
-)
+from openpype.client import get_asset_by_name
+from openpype.pipeline import LauncherAction
 from openpype_modules.clockify.clockify_api import ClockifyAPI
 
 
-log = Logger.get_logger(__name__)
-
-
 class ClockifyStart(LauncherAction):
-
     name = "clockify_start_timer"
     label = "Clockify - Start Timer"
     icon = "clockify_icon"
@@ -24,20 +17,19 @@ class ClockifyStart(LauncherAction):
         return False
 
     def process(self, session, **kwargs):
-        project_name = session['AVALON_PROJECT']
-        asset_name = session['AVALON_ASSET']
-        task_name = session['AVALON_TASK']
+        project_name = session["AVALON_PROJECT"]
+        asset_name = session["AVALON_ASSET"]
+        task_name = session["AVALON_TASK"]
 
         description = asset_name
-        asset = legacy_io.find_one({
-            'type': 'asset',
-            'name': asset_name
-        })
-        if asset is not None:
-            desc_items = asset.get('data', {}).get('parents', [])
+        asset_doc = get_asset_by_name(
+            project_name, asset_name, fields=["data.parents"]
+        )
+        if asset_doc is not None:
+            desc_items = asset_doc.get("data", {}).get("parents", [])
             desc_items.append(asset_name)
             desc_items.append(task_name)
-            description = '/'.join(desc_items)
+            description = "/".join(desc_items)
 
         project_id = self.clockapi.get_project_id(project_name)
         tag_ids = []
diff --git a/openpype/modules/clockify/launcher_actions/ClockifySync.py b/openpype/modules/clockify/launcher_actions/ClockifySync.py
index 356bbd0306..c346a1b4f6 100644
--- a/openpype/modules/clockify/launcher_actions/ClockifySync.py
+++ b/openpype/modules/clockify/launcher_actions/ClockifySync.py
@@ -1,11 +1,6 @@
+from openpype.client import get_projects, get_project
 from openpype_modules.clockify.clockify_api import ClockifyAPI
-from openpype.api import Logger
-from openpype.pipeline import (
-    legacy_io,
-    LauncherAction,
-)
-
-log = Logger.get_logger(__name__)
+from openpype.pipeline import LauncherAction
 
 
 class ClockifySync(LauncherAction):
@@ -22,39 +17,36 @@ class ClockifySync(LauncherAction):
         return self.have_permissions
 
     def process(self, session, **kwargs):
-        project_name = session.get('AVALON_PROJECT', None)
+        project_name = session.get("AVALON_PROJECT") or ""
 
         projects_to_sync = []
-        if project_name.strip() == '' or project_name is None:
-            for project in legacy_io.projects():
-                projects_to_sync.append(project)
+        if project_name.strip():
+            projects_to_sync = [get_project(project_name)]
         else:
-            project = legacy_io.find_one({'type': 'project'})
-            projects_to_sync.append(project)
+            projects_to_sync = get_projects()
 
         projects_info = {}
         for project in projects_to_sync:
-            task_types = project['config']['tasks'].keys()
-            projects_info[project['name']] = task_types
+            task_types = project["config"]["tasks"].keys()
+            projects_info[project["name"]] = task_types
 
         clockify_projects = self.clockapi.get_projects()
         for project_name, task_types in projects_info.items():
-            if project_name not in clockify_projects:
-                response = self.clockapi.add_project(project_name)
-                if 'id' not in response:
-                    self.log.error('Project {} can\'t be created'.format(
-                        project_name
-                    ))
-                    continue
-                project_id = response['id']
-            else:
-                project_id = clockify_projects[project_name]
+            if project_name in clockify_projects:
+                continue
+
+            response = self.clockapi.add_project(project_name)
+            if "id" not in response:
+                self.log.error("Project {} can't be created".format(
+                    project_name
+                ))
+                continue
 
             clockify_workspace_tags = self.clockapi.get_tags()
             for task_type in task_types:
                 if task_type not in clockify_workspace_tags:
                     response = self.clockapi.add_tag(task_type)
-                    if 'id' not in response:
+                    if "id" not in response:
                         self.log.error('Task {} can\'t be created'.format(
                             task_type
                         ))
diff --git a/openpype/modules/deadline/plugins/publish/submit_maya_deadline.py b/openpype/modules/deadline/plugins/publish/submit_maya_deadline.py
index 9964e3c646..3707c5709f 100644
--- a/openpype/modules/deadline/plugins/publish/submit_maya_deadline.py
+++ b/openpype/modules/deadline/plugins/publish/submit_maya_deadline.py
@@ -710,7 +710,9 @@ class MayaSubmitDeadline(pyblish.api.InstancePlugin):
                 new_payload["JobInfo"].update(tiles_data["JobInfo"])
                 new_payload["PluginInfo"].update(tiles_data["PluginInfo"])
 
-                job_hash = hashlib.sha256("{}_{}".format(file_index, file))
+                self.log.info("hashing {} - {}".format(file_index, file))
+                job_hash = hashlib.sha256(
+                    ("{}_{}".format(file_index, file)).encode("utf-8"))
                 frame_jobs[frame] = job_hash.hexdigest()
                 new_payload["JobInfo"]["ExtraInfo0"] = job_hash.hexdigest()
                 new_payload["JobInfo"]["ExtraInfo1"] = file
diff --git a/openpype/modules/deadline/plugins/publish/submit_publish_job.py b/openpype/modules/deadline/plugins/publish/submit_publish_job.py
index b54b00d099..9dd1428a63 100644
--- a/openpype/modules/deadline/plugins/publish/submit_publish_job.py
+++ b/openpype/modules/deadline/plugins/publish/submit_publish_job.py
@@ -1045,7 +1045,7 @@ class ProcessSubmittedJobOnFarm(pyblish.api.InstancePlugin):
                     get publish_path
 
         Args:
-            anatomy (pype.lib.anatomy.Anatomy):
+            anatomy (openpype.pipeline.anatomy.Anatomy):
             template_data (dict): pre-calculated collected data for process
             asset (string): asset name
             subset (string): subset name (actually group name of subset)
diff --git a/openpype/modules/ftrack/event_handlers_server/event_user_assigment.py b/openpype/modules/ftrack/event_handlers_server/event_user_assigment.py
index 82b79e986b..88d252e8cf 100644
--- a/openpype/modules/ftrack/event_handlers_server/event_user_assigment.py
+++ b/openpype/modules/ftrack/event_handlers_server/event_user_assigment.py
@@ -2,11 +2,11 @@ import re
 import subprocess
 
 from openpype.client import get_asset_by_id, get_asset_by_name
+from openpype.settings import get_project_settings
+from openpype.pipeline import Anatomy
 from openpype_modules.ftrack.lib import BaseEvent
 from openpype_modules.ftrack.lib.avalon_sync import CUST_ATTR_ID_KEY
 
-from openpype.api import Anatomy, get_project_settings
-
 
 class UserAssigmentEvent(BaseEvent):
     """
diff --git a/openpype/modules/ftrack/event_handlers_user/action_create_folders.py b/openpype/modules/ftrack/event_handlers_user/action_create_folders.py
index 81f38e0c39..9806f83773 100644
--- a/openpype/modules/ftrack/event_handlers_user/action_create_folders.py
+++ b/openpype/modules/ftrack/event_handlers_user/action_create_folders.py
@@ -1,7 +1,7 @@
 import os
 import collections
 import copy
-from openpype.api import Anatomy
+from openpype.pipeline import Anatomy
 from openpype_modules.ftrack.lib import BaseAction, statics_icon
 
 
diff --git a/openpype/modules/ftrack/event_handlers_user/action_delete_old_versions.py b/openpype/modules/ftrack/event_handlers_user/action_delete_old_versions.py
index 3400c509ab..79d04a7854 100644
--- a/openpype/modules/ftrack/event_handlers_user/action_delete_old_versions.py
+++ b/openpype/modules/ftrack/event_handlers_user/action_delete_old_versions.py
@@ -11,9 +11,8 @@ from openpype.client import (
     get_versions,
     get_representations
 )
-from openpype.api import Anatomy
 from openpype.lib import StringTemplate, TemplateUnsolved
-from openpype.pipeline import AvalonMongoDB
+from openpype.pipeline import AvalonMongoDB, Anatomy
 from openpype_modules.ftrack.lib import BaseAction, statics_icon
 
 
diff --git a/openpype/modules/ftrack/event_handlers_user/action_delivery.py b/openpype/modules/ftrack/event_handlers_user/action_delivery.py
index 4b799b092b..ad82af39a3 100644
--- a/openpype/modules/ftrack/event_handlers_user/action_delivery.py
+++ b/openpype/modules/ftrack/event_handlers_user/action_delivery.py
@@ -10,12 +10,13 @@ from openpype.client import (
     get_versions,
     get_representations
 )
-from openpype.api import Anatomy, config
+from openpype.pipeline import Anatomy
 from openpype_modules.ftrack.lib import BaseAction, statics_icon
 from openpype_modules.ftrack.lib.avalon_sync import CUST_ATTR_ID_KEY
 from openpype_modules.ftrack.lib.custom_attributes import (
     query_custom_attributes
 )
+from openpype.lib import config
 from openpype.lib.delivery import (
     path_from_representation,
     get_format_dict,
diff --git a/openpype/modules/ftrack/event_handlers_user/action_fill_workfile_attr.py b/openpype/modules/ftrack/event_handlers_user/action_fill_workfile_attr.py
index d30c41a749..d91649d7ba 100644
--- a/openpype/modules/ftrack/event_handlers_user/action_fill_workfile_attr.py
+++ b/openpype/modules/ftrack/event_handlers_user/action_fill_workfile_attr.py
@@ -11,13 +11,13 @@ from openpype.client import (
     get_project,
     get_assets,
 )
-from openpype.api import get_project_settings
+from openpype.settings import get_project_settings
 from openpype.lib import (
     get_workfile_template_key,
     get_workdir_data,
-    Anatomy,
     StringTemplate,
 )
+from openpype.pipeline import Anatomy
 from openpype_modules.ftrack.lib import BaseAction, statics_icon
 from openpype_modules.ftrack.lib.avalon_sync import create_chunks
 
diff --git a/openpype/modules/ftrack/event_handlers_user/action_rv.py b/openpype/modules/ftrack/event_handlers_user/action_rv.py
index 2480ea7f95..d05f0c47f6 100644
--- a/openpype/modules/ftrack/event_handlers_user/action_rv.py
+++ b/openpype/modules/ftrack/event_handlers_user/action_rv.py
@@ -11,10 +11,10 @@ from openpype.client import (
     get_version_by_name,
     get_representation_by_name
 )
-from openpype.api import Anatomy
 from openpype.pipeline import (
     get_representation_path,
     AvalonMongoDB,
+    Anatomy,
 )
 from openpype_modules.ftrack.lib import BaseAction, statics_icon
 
diff --git a/openpype/modules/ftrack/event_handlers_user/action_store_thumbnails_to_avalon.py b/openpype/modules/ftrack/event_handlers_user/action_store_thumbnails_to_avalon.py
index d655dddcaf..8748f426bd 100644
--- a/openpype/modules/ftrack/event_handlers_user/action_store_thumbnails_to_avalon.py
+++ b/openpype/modules/ftrack/event_handlers_user/action_store_thumbnails_to_avalon.py
@@ -14,8 +14,7 @@ from openpype.client import (
     get_representations
 )
 from openpype_modules.ftrack.lib import BaseAction, statics_icon
-from openpype.api import Anatomy
-from openpype.pipeline import AvalonMongoDB
+from openpype.pipeline import AvalonMongoDB, Anatomy
 
 from openpype_modules.ftrack.lib.avalon_sync import CUST_ATTR_ID_KEY
 
diff --git a/openpype/modules/log_viewer/tray/widgets.py b/openpype/modules/log_viewer/tray/widgets.py
index ed08e62109..c7ac64ab70 100644
--- a/openpype/modules/log_viewer/tray/widgets.py
+++ b/openpype/modules/log_viewer/tray/widgets.py
@@ -1,3 +1,4 @@
+import html
 from Qt import QtCore, QtWidgets
 import qtawesome
 from .models import LogModel, LogsFilterProxy
@@ -286,7 +287,7 @@ class OutputWidget(QtWidgets.QWidget):
             if level == "debug":
                 line_f = (
                     "<font color=\"Yellow\"> -"
-                    " <font color=\"Lime\">{{  {loggerName}  }}: ["
+                    " <font color=\"Lime\">{{  {logger_name}  }}: ["
                     " <font color=\"White\">{message}"
                     " <font color=\"Lime\">]"
                 )
@@ -299,7 +300,7 @@ class OutputWidget(QtWidgets.QWidget):
             elif level == "warning":
                 line_f = (
                     "<font color=\"Yellow\">*** WRN:"
-                    " <font color=\"Lime\"> >>> {{ {loggerName} }}: ["
+                    " <font color=\"Lime\"> >>> {{ {logger_name} }}: ["
                     " <font color=\"White\">{message}"
                     " <font color=\"Lime\">]"
                 )
@@ -307,16 +308,25 @@ class OutputWidget(QtWidgets.QWidget):
                 line_f = (
                     "<font color=\"Red\">!!! ERR:"
                     " <font color=\"White\">{timestamp}"
-                    " <font color=\"Lime\">>>> {{ {loggerName} }}: ["
+                    " <font color=\"Lime\">>>> {{ {logger_name} }}: ["
                     " <font color=\"White\">{message}"
                     " <font color=\"Lime\">]"
                 )
 
+            logger_name = log["loggerName"]
+            timestamp = ""
+            if not show_timecode:
+                timestamp = log["timestamp"]
+            message = log["message"]
             exc = log.get("exception")
             if exc:
-                log["message"] = exc["message"]
+                message = exc["message"]
 
-            line = line_f.format(**log)
+            line = line_f.format(
+                message=html.escape(message),
+                logger_name=logger_name,
+                timestamp=timestamp
+            )
 
             if show_timecode:
                 timestamp = log["timestamp"]
diff --git a/openpype/modules/sync_server/providers/local_drive.py b/openpype/modules/sync_server/providers/local_drive.py
index 68f604b39c..172cb338cf 100644
--- a/openpype/modules/sync_server/providers/local_drive.py
+++ b/openpype/modules/sync_server/providers/local_drive.py
@@ -4,10 +4,11 @@ import shutil
 import threading
 import time
 
-from openpype.api import Logger, Anatomy
+from openpype.api import Logger
+from openpype.pipeline import Anatomy
 from .abstract_provider import AbstractProvider
 
-log = Logger().get_logger("SyncServer")
+log = Logger.get_logger("SyncServer")
 
 
 class LocalDriveHandler(AbstractProvider):
diff --git a/openpype/modules/sync_server/sync_server_module.py b/openpype/modules/sync_server/sync_server_module.py
index 698b296a52..4027561d22 100644
--- a/openpype/modules/sync_server/sync_server_module.py
+++ b/openpype/modules/sync_server/sync_server_module.py
@@ -9,14 +9,12 @@ from collections import deque, defaultdict
 
 from openpype.modules import OpenPypeModule
 from openpype_interfaces import ITrayModule
-from openpype.api import (
-    Anatomy,
+from openpype.settings import (
     get_project_settings,
     get_system_settings,
-    get_local_site_id
 )
-from openpype.lib import PypeLogger
-from openpype.pipeline import AvalonMongoDB
+from openpype.lib import PypeLogger, get_local_site_id
+from openpype.pipeline import AvalonMongoDB, Anatomy
 from openpype.settings.lib import (
     get_default_anatomy_settings,
     get_anatomy_settings
@@ -28,7 +26,7 @@ from .providers import lib
 from .utils import time_function, SyncStatus, SiteAlreadyPresentError
 
 
-log = PypeLogger().get_logger("SyncServer")
+log = PypeLogger.get_logger("SyncServer")
 
 
 class SyncServerModule(OpenPypeModule, ITrayModule):
diff --git a/openpype/pipeline/__init__.py b/openpype/pipeline/__init__.py
index 2e441fbf27..2cf785d981 100644
--- a/openpype/pipeline/__init__.py
+++ b/openpype/pipeline/__init__.py
@@ -6,6 +6,7 @@ from .constants import (
 from .mongodb import (
     AvalonMongoDB,
 )
+from .anatomy import Anatomy
 
 from .create import (
     BaseCreator,
@@ -96,6 +97,9 @@ __all__ = (
     # --- MongoDB ---
     "AvalonMongoDB",
 
+    # --- Anatomy ---
+    "Anatomy",
+
     # --- Create ---
     "BaseCreator",
     "Creator",
diff --git a/openpype/pipeline/anatomy.py b/openpype/pipeline/anatomy.py
new file mode 100644
index 0000000000..73081f18fb
--- /dev/null
+++ b/openpype/pipeline/anatomy.py
@@ -0,0 +1,1257 @@
+import os
+import re
+import copy
+import platform
+import collections
+import numbers
+
+import six
+
+from openpype.settings.lib import get_anatomy_settings
+from openpype.lib.path_templates import (
+    TemplateUnsolved,
+    TemplateResult,
+    TemplatesDict,
+    FormatObject,
+)
+from openpype.lib.log import PypeLogger
+
+log = PypeLogger.get_logger(__name__)
+
+
+class ProjectNotSet(Exception):
+    """Exception raised when is created Anatomy without project name."""
+
+
+class RootCombinationError(Exception):
+    """This exception is raised when templates has combined root types."""
+
+    def __init__(self, roots):
+        joined_roots = ", ".join(
+            ["\"{}\"".format(_root) for _root in roots]
+        )
+        # TODO better error message
+        msg = (
+            "Combination of root with and"
+            " without root name in AnatomyTemplates. {}"
+        ).format(joined_roots)
+
+        super(RootCombinationError, self).__init__(msg)
+
+
+class Anatomy:
+    """Anatomy module helps to keep project settings.
+
+    Wraps key project specifications, AnatomyTemplates and Roots.
+
+    Args:
+        project_name (str): Project name to look on overrides.
+    """
+
+    root_key_regex = re.compile(r"{(root?[^}]+)}")
+    root_name_regex = re.compile(r"root\[([^]]+)\]")
+
+    def __init__(self, project_name=None, site_name=None):
+        if not project_name:
+            project_name = os.environ.get("AVALON_PROJECT")
+
+        if not project_name:
+            raise ProjectNotSet((
+                "Implementation bug: Project name is not set. Anatomy requires"
+                " to load data for specific project."
+            ))
+
+        self.project_name = project_name
+
+        self._data = self._prepare_anatomy_data(
+            get_anatomy_settings(project_name, site_name)
+        )
+        self._site_name = site_name
+        self._templates_obj = AnatomyTemplates(self)
+        self._roots_obj = Roots(self)
+
+    # Anatomy used as dictionary
+    # - implemented only getters returning copy
+    def __getitem__(self, key):
+        return copy.deepcopy(self._data[key])
+
+    def get(self, key, default=None):
+        return copy.deepcopy(self._data).get(key, default)
+
+    def keys(self):
+        return copy.deepcopy(self._data).keys()
+
+    def values(self):
+        return copy.deepcopy(self._data).values()
+
+    def items(self):
+        return copy.deepcopy(self._data).items()
+
+    @staticmethod
+    def _prepare_anatomy_data(anatomy_data):
+        """Prepare anatomy data for further processing.
+
+        Method added to replace `{task}` with `{task[name]}` in templates.
+        """
+        templates_data = anatomy_data.get("templates")
+        if templates_data:
+            # Replace `{task}` with `{task[name]}` in templates
+            value_queue = collections.deque()
+            value_queue.append(templates_data)
+            while value_queue:
+                item = value_queue.popleft()
+                if not isinstance(item, dict):
+                    continue
+
+                for key in tuple(item.keys()):
+                    value = item[key]
+                    if isinstance(value, dict):
+                        value_queue.append(value)
+
+                    elif isinstance(value, six.string_types):
+                        item[key] = value.replace("{task}", "{task[name]}")
+        return anatomy_data
+
+    def reset(self):
+        """Reset values of cached data in templates and roots objects."""
+        self._data = self._prepare_anatomy_data(
+            get_anatomy_settings(self.project_name, self._site_name)
+        )
+        self.templates_obj.reset()
+        self.roots_obj.reset()
+
+    @property
+    def templates(self):
+        """Wrap property `templates` of Anatomy's AnatomyTemplates instance."""
+        return self._templates_obj.templates
+
+    @property
+    def templates_obj(self):
+        """Return `AnatomyTemplates` object of current Anatomy instance."""
+        return self._templates_obj
+
+    def format(self, *args, **kwargs):
+        """Wrap `format` method of Anatomy's `templates_obj`."""
+        return self._templates_obj.format(*args, **kwargs)
+
+    def format_all(self, *args, **kwargs):
+        """Wrap `format_all` method of Anatomy's `templates_obj`."""
+        return self._templates_obj.format_all(*args, **kwargs)
+
+    @property
+    def roots(self):
+        """Wrap `roots` property of Anatomy's `roots_obj`."""
+        return self._roots_obj.roots
+
+    @property
+    def roots_obj(self):
+        """Return `Roots` object of current Anatomy instance."""
+        return self._roots_obj
+
+    def root_environments(self):
+        """Return OPENPYPE_ROOT_* environments for current project in dict."""
+        return self._roots_obj.root_environments()
+
+    def root_environmets_fill_data(self, template=None):
+        """Environment variable values in dictionary for rootless path.
+
+        Args:
+            template (str): Template for environment variable key fill.
+                By default is set to `"${}"`.
+        """
+        return self.roots_obj.root_environmets_fill_data(template)
+
+    def find_root_template_from_path(self, *args, **kwargs):
+        """Wrapper for Roots `find_root_template_from_path`."""
+        return self.roots_obj.find_root_template_from_path(*args, **kwargs)
+
+    def path_remapper(self, *args, **kwargs):
+        """Wrapper for Roots `path_remapper`."""
+        return self.roots_obj.path_remapper(*args, **kwargs)
+
+    def all_root_paths(self):
+        """Wrapper for Roots `all_root_paths`."""
+        return self.roots_obj.all_root_paths()
+
+    def set_root_environments(self):
+        """Set OPENPYPE_ROOT_* environments for current project."""
+        self._roots_obj.set_root_environments()
+
+    def root_names(self):
+        """Return root names for current project."""
+        return self.root_names_from_templates(self.templates)
+
+    def _root_keys_from_templates(self, data):
+        """Extract root key from templates in data.
+
+        Args:
+            data (dict): Data that may contain templates as string.
+
+        Return:
+            set: Set of all root names from templates as strings.
+
+        Output example: `{"root[work]", "root[publish]"}`
+        """
+
+        output = set()
+        if isinstance(data, dict):
+            for value in data.values():
+                for root in self._root_keys_from_templates(value):
+                    output.add(root)
+
+        elif isinstance(data, str):
+            for group in re.findall(self.root_key_regex, data):
+                output.add(group)
+
+        return output
+
+    def root_value_for_template(self, template):
+        """Returns value of root key from template."""
+        root_templates = []
+        for group in re.findall(self.root_key_regex, template):
+            root_templates.append("{" + group + "}")
+
+        if not root_templates:
+            return None
+
+        return root_templates[0].format(**{"root": self.roots})
+
+    def root_names_from_templates(self, templates):
+        """Extract root names form anatomy templates.
+
+        Returns None if values in templates contain only "{root}".
+        Empty list is returned if there is no "root" in templates.
+        Else returns all root names from templates in list.
+
+        RootCombinationError is raised when templates contain both root types,
+        basic "{root}" and with root name specification "{root[work]}".
+
+        Args:
+            templates (dict): Anatomy templates where roots are not filled.
+
+        Return:
+            list/None: List of all root names from templates as strings when
+            multiroot setup is used, otherwise None is returned.
+        """
+        roots = list(self._root_keys_from_templates(templates))
+        # Return empty list if no roots found in templates
+        if not roots:
+            return roots
+
+        # Raise exception when root keys have roots with and without root name.
+        # Invalid output example: ["root", "root[project]", "root[render]"]
+        if len(roots) > 1 and "root" in roots:
+            raise RootCombinationError(roots)
+
+        # Return None if "root" without root name in templates
+        if len(roots) == 1 and roots[0] == "root":
+            return None
+
+        names = set()
+        for root in roots:
+            for group in re.findall(self.root_name_regex, root):
+                names.add(group)
+        return list(names)
+
+    def fill_root(self, template_path):
+        """Fill template path where is only "root" key unfilled.
+
+        Args:
+            template_path (str): Path with "root" key in.
+                Example path: "{root}/projects/MyProject/Shot01/Lighting/..."
+
+        Return:
+            str: formatted path
+        """
+        # NOTE does not care if there are different keys than "root"
+        return template_path.format(**{"root": self.roots})
+
+    @classmethod
+    def fill_root_with_path(cls, rootless_path, root_path):
+        """Fill path without filled "root" key with passed path.
+
+        This is helper to fill root with different directory path than anatomy
+        has defined no matter if is single or multiroot.
+
+        Output path is same as input path if `rootless_path` does not contain
+        unfilled root key.
+
+        Args:
+            rootless_path (str): Path without filled "root" key. Example:
+                "{root[work]}/MyProject/..."
+            root_path (str): What should replace root key in `rootless_path`.
+
+        Returns:
+            str: Path with filled root.
+        """
+        output = str(rootless_path)
+        for group in re.findall(cls.root_key_regex, rootless_path):
+            replacement = "{" + group + "}"
+            output = output.replace(replacement, root_path)
+
+        return output
+
+    def replace_root_with_env_key(self, filepath, template=None):
+        """Replace root of path with environment key.
+
+        # Example:
+        ## Project with roots:
+        ```
+        {
+            "nas": {
+                "windows": P:/projects",
+                ...
+            }
+            ...
+        }
+        ```
+
+        ## Entered filepath
+        "P:/projects/project/asset/task/animation_v001.ma"
+
+        ## Entered template
+        "<{}>"
+
+        ## Output
+        "<OPENPYPE_PROJECT_ROOT_NAS>/project/asset/task/animation_v001.ma"
+
+        Args:
+            filepath (str): Full file path where root should be replaced.
+            template (str): Optional template for environment key. Must
+                have one index format key.
+                Default value if not entered: "${}"
+
+        Returns:
+            str: Path where root is replaced with environment root key.
+
+        Raise:
+            ValueError: When project's roots were not found in entered path.
+        """
+        success, rootless_path = self.find_root_template_from_path(filepath)
+        if not success:
+            raise ValueError(
+                "{}: Project's roots were not found in path: {}".format(
+                    self.project_name, filepath
+                )
+            )
+
+        data = self.root_environmets_fill_data(template)
+        return rootless_path.format(**data)
+
+
+class AnatomyTemplateUnsolved(TemplateUnsolved):
+    """Exception for unsolved template when strict is set to True."""
+
+    msg = "Anatomy template \"{0}\" is unsolved.{1}{2}"
+
+
+class AnatomyTemplateResult(TemplateResult):
+    rootless = None
+
+    def __new__(cls, result, rootless_path):
+        new_obj = super(AnatomyTemplateResult, cls).__new__(
+            cls,
+            str(result),
+            result.template,
+            result.solved,
+            result.used_values,
+            result.missing_keys,
+            result.invalid_types
+        )
+        new_obj.rootless = rootless_path
+        return new_obj
+
+    def validate(self):
+        if not self.solved:
+            raise AnatomyTemplateUnsolved(
+                self.template,
+                self.missing_keys,
+                self.invalid_types
+            )
+
+    def copy(self):
+        tmp = TemplateResult(
+            str(self),
+            self.template,
+            self.solved,
+            self.used_values,
+            self.missing_keys,
+            self.invalid_types
+        )
+        return self.__class__(tmp, self.rootless)
+
+
+class AnatomyTemplates(TemplatesDict):
+    inner_key_pattern = re.compile(r"(\{@.*?[^{}0]*\})")
+    inner_key_name_pattern = re.compile(r"\{@(.*?[^{}0]*)\}")
+
+    def __init__(self, anatomy):
+        super(AnatomyTemplates, self).__init__()
+        self.anatomy = anatomy
+        self.loaded_project = None
+
+    def __getitem__(self, key):
+        return self.templates[key]
+
+    def get(self, key, default=None):
+        return self.templates.get(key, default)
+
+    def reset(self):
+        self._raw_templates = None
+        self._templates = None
+        self._objected_templates = None
+
+    @property
+    def project_name(self):
+        return self.anatomy.project_name
+
+    @property
+    def roots(self):
+        return self.anatomy.roots
+
+    @property
+    def templates(self):
+        self._validate_discovery()
+        return self._templates
+
+    @property
+    def objected_templates(self):
+        self._validate_discovery()
+        return self._objected_templates
+
+    def _validate_discovery(self):
+        if self.project_name != self.loaded_project:
+            self.reset()
+
+        if self._templates is None:
+            self._discover()
+            self.loaded_project = self.project_name
+
+    def _format_value(self, value, data):
+        if isinstance(value, RootItem):
+            return self._solve_dict(value, data)
+
+        result = super(AnatomyTemplates, self)._format_value(value, data)
+        if isinstance(result, TemplateResult):
+            rootless_path = self._rootless_path(result, data)
+            result = AnatomyTemplateResult(result, rootless_path)
+        return result
+
+    def set_templates(self, templates):
+        if not templates:
+            self.reset()
+            return
+
+        self._raw_templates = copy.deepcopy(templates)
+        templates = copy.deepcopy(templates)
+        v_queue = collections.deque()
+        v_queue.append(templates)
+        while v_queue:
+            item = v_queue.popleft()
+            if not isinstance(item, dict):
+                continue
+
+            for key in tuple(item.keys()):
+                value = item[key]
+                if isinstance(value, dict):
+                    v_queue.append(value)
+
+                elif (
+                    isinstance(value, six.string_types)
+                    and "{task}" in value
+                ):
+                    item[key] = value.replace("{task}", "{task[name]}")
+
+        solved_templates = self.solve_template_inner_links(templates)
+        self._templates = solved_templates
+        self._objected_templates = self.create_ojected_templates(
+            solved_templates
+        )
+
+    def default_templates(self):
+        """Return default templates data with solved inner keys."""
+        return self.solve_template_inner_links(
+            self.anatomy["templates"]
+        )
+
+    def _discover(self):
+        """ Loads anatomy templates from yaml.
+        Default templates are loaded if project is not set or project does
+        not have set it's own.
+        TODO: create templates if not exist.
+
+        Returns:
+            TemplatesResultDict: Contain templates data for current project of
+                default templates.
+        """
+
+        if self.project_name is None:
+            # QUESTION create project specific if not found?
+            raise AssertionError((
+                "Project \"{0}\" does not have his own templates."
+                " Trying to use default."
+            ).format(self.project_name))
+
+        self.set_templates(self.anatomy["templates"])
+
+    @classmethod
+    def replace_inner_keys(cls, matches, value, key_values, key):
+        """Replacement of inner keys in template values."""
+        for match in matches:
+            anatomy_sub_keys = (
+                cls.inner_key_name_pattern.findall(match)
+            )
+            if key in anatomy_sub_keys:
+                raise ValueError((
+                    "Unsolvable recursion in inner keys, "
+                    "key: \"{}\" is in his own value."
+                    " Can't determine source, please check Anatomy templates."
+                ).format(key))
+
+            for anatomy_sub_key in anatomy_sub_keys:
+                replace_value = key_values.get(anatomy_sub_key)
+                if replace_value is None:
+                    raise KeyError((
+                        "Anatomy templates can't be filled."
+                        " Anatomy key `{0}` has"
+                        " invalid inner key `{1}`."
+                    ).format(key, anatomy_sub_key))
+
+                if not (
+                    isinstance(replace_value, numbers.Number)
+                    or isinstance(replace_value, six.string_types)
+                ):
+                    raise ValueError((
+                        "Anatomy templates can't be filled."
+                        " Anatomy key `{0}` has"
+                        " invalid inner key `{1}`"
+                        " with value `{2}`."
+                    ).format(key, anatomy_sub_key, str(replace_value)))
+
+                value = value.replace(match, str(replace_value))
+
+        return value
+
+    @classmethod
+    def prepare_inner_keys(cls, key_values):
+        """Check values of inner keys.
+
+        Check if inner key exist in template group and has valid value.
+        It is also required to avoid infinite loop with unsolvable recursion
+        when first inner key's value refers to second inner key's value where
+        first is used.
+        """
+        keys_to_solve = set(key_values.keys())
+        while True:
+            found = False
+            for key in tuple(keys_to_solve):
+                value = key_values[key]
+
+                if isinstance(value, six.string_types):
+                    matches = cls.inner_key_pattern.findall(value)
+                    if not matches:
+                        keys_to_solve.remove(key)
+                        continue
+
+                    found = True
+                    key_values[key] = cls.replace_inner_keys(
+                        matches, value, key_values, key
+                    )
+                    continue
+
+                elif not isinstance(value, dict):
+                    keys_to_solve.remove(key)
+                    continue
+
+                subdict_found = False
+                for _key, _value in tuple(value.items()):
+                    matches = cls.inner_key_pattern.findall(_value)
+                    if not matches:
+                        continue
+
+                    subdict_found = True
+                    found = True
+                    key_values[key][_key] = cls.replace_inner_keys(
+                        matches, _value, key_values,
+                        "{}.{}".format(key, _key)
+                    )
+
+                if not subdict_found:
+                    keys_to_solve.remove(key)
+
+            if not found:
+                break
+
+        return key_values
+
+    @classmethod
+    def solve_template_inner_links(cls, templates):
+        """Solve templates inner keys identified by "{@*}".
+
+        Process is split into 2 parts.
+        First is collecting all global keys (keys in top hierarchy where value
+        is not dictionary). All global keys are set for all group keys (keys
+        in top hierarchy where value is dictionary). Value of a key is not
+        overridden in group if already contain value for the key.
+
+        In second part all keys with "at" symbol in value are replaced with
+        value of the key afterward "at" symbol from the group.
+
+        Args:
+            templates (dict): Raw templates data.
+
+        Example:
+            templates::
+                key_1: "value_1",
+                key_2: "{@key_1}/{filling_key}"
+
+                group_1:
+                    key_3: "value_3/{@key_2}"
+
+                group_2:
+                    key_2": "value_2"
+                    key_4": "value_4/{@key_2}"
+
+            output::
+                key_1: "value_1"
+                key_2: "value_1/{filling_key}"
+
+                group_1: {
+                    key_1: "value_1"
+                    key_2: "value_1/{filling_key}"
+                    key_3: "value_3/value_1/{filling_key}"
+
+                group_2: {
+                    key_1: "value_1"
+                    key_2: "value_2"
+                    key_4: "value_3/value_2"
+        """
+        default_key_values = templates.pop("defaults", {})
+        for key, value in tuple(templates.items()):
+            if isinstance(value, dict):
+                continue
+            default_key_values[key] = templates.pop(key)
+
+        # Pop "others" key before before expected keys are processed
+        other_templates = templates.pop("others") or {}
+
+        keys_by_subkey = {}
+        for sub_key, sub_value in templates.items():
+            key_values = {}
+            key_values.update(default_key_values)
+            key_values.update(sub_value)
+            keys_by_subkey[sub_key] = cls.prepare_inner_keys(key_values)
+
+        for sub_key, sub_value in other_templates.items():
+            if sub_key in keys_by_subkey:
+                log.warning((
+                    "Key \"{}\" is duplicated in others. Skipping."
+                ).format(sub_key))
+                continue
+
+            key_values = {}
+            key_values.update(default_key_values)
+            key_values.update(sub_value)
+            keys_by_subkey[sub_key] = cls.prepare_inner_keys(key_values)
+
+        default_keys_by_subkeys = cls.prepare_inner_keys(default_key_values)
+
+        for key, value in default_keys_by_subkeys.items():
+            keys_by_subkey[key] = value
+
+        return keys_by_subkey
+
+    def _dict_to_subkeys_list(self, subdict, pre_keys=None):
+        if pre_keys is None:
+            pre_keys = []
+        output = []
+        for key in subdict:
+            value = subdict[key]
+            result = list(pre_keys)
+            result.append(key)
+            if isinstance(value, dict):
+                for item in self._dict_to_subkeys_list(value, result):
+                    output.append(item)
+            else:
+                output.append(result)
+        return output
+
+    def _keys_to_dicts(self, key_list, value):
+        if not key_list:
+            return None
+        if len(key_list) == 1:
+            return {key_list[0]: value}
+        return {key_list[0]: self._keys_to_dicts(key_list[1:], value)}
+
+    def _rootless_path(self, result, final_data):
+        used_values = result.used_values
+        missing_keys = result.missing_keys
+        template = result.template
+        invalid_types = result.invalid_types
+        if (
+            "root" not in used_values
+            or "root" in missing_keys
+            or "{root" not in template
+        ):
+            return
+
+        for invalid_type in invalid_types:
+            if "root" in invalid_type:
+                return
+
+        root_keys = self._dict_to_subkeys_list({"root": used_values["root"]})
+        if not root_keys:
+            return
+
+        output = str(result)
+        for used_root_keys in root_keys:
+            if not used_root_keys:
+                continue
+
+            used_value = used_values
+            root_key = None
+            for key in used_root_keys:
+                used_value = used_value[key]
+                if root_key is None:
+                    root_key = key
+                else:
+                    root_key += "[{}]".format(key)
+
+            root_key = "{" + root_key + "}"
+            output = output.replace(str(used_value), root_key)
+
+        return output
+
+    def format(self, data, strict=True):
+        copy_data = copy.deepcopy(data)
+        roots = self.roots
+        if roots:
+            copy_data["root"] = roots
+        result = super(AnatomyTemplates, self).format(copy_data)
+        result.strict = strict
+        return result
+
+    def format_all(self, in_data, only_keys=True):
+        """ Solves templates based on entered data.
+
+        Args:
+            data (dict): Containing keys to be filled into template.
+
+        Returns:
+            TemplatesResultDict: Output `TemplateResult` have `strict`
+                attribute set to False so accessing unfilled keys in templates
+                won't raise any exceptions.
+        """
+        return self.format(in_data, strict=False)
+
+
+class RootItem(FormatObject):
+    """Represents one item or roots.
+
+    Holds raw data of root item specification. Raw data contain value
+    for each platform, but current platform value is used when object
+    is used for formatting of template.
+
+    Args:
+        root_raw_data (dict): Dictionary containing root values by platform
+            names. ["windows", "linux" and "darwin"]
+        name (str, optional): Root name which is representing. Used with
+            multi root setup otherwise None value is expected.
+        parent_keys (list, optional): All dictionary parent keys. Values of
+            `parent_keys` are used for get full key which RootItem is
+            representing. Used for replacing root value in path with
+            formattable key. e.g. parent_keys == ["work"] -> {root[work]}
+        parent (object, optional): It is expected to be `Roots` object.
+            Value of `parent` won't affect code logic much.
+    """
+
+    def __init__(
+        self, root_raw_data, name=None, parent_keys=None, parent=None
+    ):
+        lowered_platform_keys = {}
+        for key, value in root_raw_data.items():
+            lowered_platform_keys[key.lower()] = value
+        self.raw_data = lowered_platform_keys
+        self.cleaned_data = self._clean_roots(lowered_platform_keys)
+        self.name = name
+        self.parent_keys = parent_keys or []
+        self.parent = parent
+
+        self.available_platforms = list(lowered_platform_keys.keys())
+        self.value = lowered_platform_keys.get(platform.system().lower())
+        self.clean_value = self.clean_root(self.value)
+
+    def __format__(self, *args, **kwargs):
+        return self.value.__format__(*args, **kwargs)
+
+    def __str__(self):
+        return str(self.value)
+
+    def __repr__(self):
+        return self.__str__()
+
+    def __getitem__(self, key):
+        if isinstance(key, numbers.Number):
+            return self.value[key]
+
+        additional_info = ""
+        if self.parent and self.parent.project_name:
+            additional_info += " for project \"{}\"".format(
+                self.parent.project_name
+            )
+
+        raise AssertionError(
+            "Root key \"{}\" is missing{}.".format(
+                key, additional_info
+            )
+        )
+
+    def full_key(self):
+        """Full key value for dictionary formatting in template.
+
+        Returns:
+            str: Return full replacement key for formatting. This helps when
+                multiple roots are set. In that case e.g. `"root[work]"` is
+                returned.
+        """
+        if not self.name:
+            return "root"
+
+        joined_parent_keys = "".join(
+            ["[{}]".format(key) for key in self.parent_keys]
+        )
+        return "root{}".format(joined_parent_keys)
+
+    def clean_path(self, path):
+        """Just replace backslashes with forward slashes."""
+        return str(path).replace("\\", "/")
+
+    def clean_root(self, root):
+        """Makes sure root value does not end with slash."""
+        if root:
+            root = self.clean_path(root)
+            while root.endswith("/"):
+                root = root[:-1]
+        return root
+
+    def _clean_roots(self, raw_data):
+        """Clean all values of raw root item values."""
+        cleaned = {}
+        for key, value in raw_data.items():
+            cleaned[key] = self.clean_root(value)
+        return cleaned
+
+    def path_remapper(self, path, dst_platform=None, src_platform=None):
+        """Remap path for specific platform.
+
+        Args:
+            path (str): Source path which need to be remapped.
+            dst_platform (str, optional): Specify destination platform
+                for which remapping should happen.
+            src_platform (str, optional): Specify source platform. This is
+                recommended to not use and keep unset until you really want
+                to use specific platform.
+            roots (dict/RootItem/None, optional): It is possible to remap
+                path with different roots then instance where method was
+                called has.
+
+        Returns:
+            str/None: When path does not contain known root then
+                None is returned else returns remapped path with "{root}"
+                or "{root[<name>]}".
+        """
+        cleaned_path = self.clean_path(path)
+        if dst_platform:
+            dst_root_clean = self.cleaned_data.get(dst_platform)
+            if not dst_root_clean:
+                key_part = ""
+                full_key = self.full_key()
+                if full_key != "root":
+                    key_part += "\"{}\" ".format(full_key)
+
+                log.warning(
+                    "Root {}miss platform \"{}\" definition.".format(
+                        key_part, dst_platform
+                    )
+                )
+                return None
+
+            if cleaned_path.startswith(dst_root_clean):
+                return cleaned_path
+
+        if src_platform:
+            src_root_clean = self.cleaned_data.get(src_platform)
+            if src_root_clean is None:
+                log.warning(
+                    "Root \"{}\" miss platform \"{}\" definition.".format(
+                        self.full_key(), src_platform
+                    )
+                )
+                return None
+
+            if not cleaned_path.startswith(src_root_clean):
+                return None
+
+            subpath = cleaned_path[len(src_root_clean):]
+            if dst_platform:
+                # `dst_root_clean` is used from upper condition
+                return dst_root_clean + subpath
+            return self.clean_value + subpath
+
+        result, template = self.find_root_template_from_path(path)
+        if not result:
+            return None
+
+        def parent_dict(keys, value):
+            if not keys:
+                return value
+
+            key = keys.pop(0)
+            return {key: parent_dict(keys, value)}
+
+        if dst_platform:
+            format_value = parent_dict(list(self.parent_keys), dst_root_clean)
+        else:
+            format_value = parent_dict(list(self.parent_keys), self.value)
+
+        return template.format(**{"root": format_value})
+
+    def find_root_template_from_path(self, path):
+        """Replaces known root value with formattable key in path.
+
+        All platform values are checked for this replacement.
+
+        Args:
+            path (str): Path where root value should be found.
+
+        Returns:
+            tuple: Tuple contain 2 values: `success` (bool) and `path` (str).
+                When success it True then path should contain replaced root
+                value with formattable key.
+
+        Example:
+            When input path is::
+                "C:/windows/path/root/projects/my_project/file.ext"
+
+            And raw data of item looks like::
+                {
+                    "windows": "C:/windows/path/root",
+                    "linux": "/mount/root"
+                }
+
+            Output will be::
+                (True, "{root}/projects/my_project/file.ext")
+
+            If any of raw data value wouldn't match path's root output is::
+                (False, "C:/windows/path/root/projects/my_project/file.ext")
+        """
+        result = False
+        output = str(path)
+
+        root_paths = list(self.cleaned_data.values())
+        mod_path = self.clean_path(path)
+        for root_path in root_paths:
+            # Skip empty paths
+            if not root_path:
+                continue
+
+            if mod_path.startswith(root_path):
+                result = True
+                replacement = "{" + self.full_key() + "}"
+                output = replacement + mod_path[len(root_path):]
+                break
+
+        return (result, output)
+
+
+class Roots:
+    """Object which should be used for formatting "root" key in templates.
+
+    Args:
+        anatomy Anatomy: Anatomy object created for a specific project.
+    """
+
+    env_prefix = "OPENPYPE_PROJECT_ROOT"
+    roots_filename = "roots.json"
+
+    def __init__(self, anatomy):
+        self.anatomy = anatomy
+        self.loaded_project = None
+        self._roots = None
+
+    def __format__(self, *args, **kwargs):
+        return self.roots.__format__(*args, **kwargs)
+
+    def __getitem__(self, key):
+        return self.roots[key]
+
+    def reset(self):
+        """Reset current roots value."""
+        self._roots = None
+
+    def path_remapper(
+        self, path, dst_platform=None, src_platform=None, roots=None
+    ):
+        """Remap path for specific platform.
+
+        Args:
+            path (str): Source path which need to be remapped.
+            dst_platform (str, optional): Specify destination platform
+                for which remapping should happen.
+            src_platform (str, optional): Specify source platform. This is
+                recommended to not use and keep unset until you really want
+                to use specific platform.
+            roots (dict/RootItem/None, optional): It is possible to remap
+                path with different roots then instance where method was
+                called has.
+
+        Returns:
+            str/None: When path does not contain known root then
+                None is returned else returns remapped path with "{root}"
+                or "{root[<name>]}".
+        """
+        if roots is None:
+            roots = self.roots
+
+        if roots is None:
+            raise ValueError("Roots are not set. Can't find path.")
+
+        if "{root" in path:
+            path = path.format(**{"root": roots})
+            # If `dst_platform` is not specified then return else continue.
+            if not dst_platform:
+                return path
+
+        if isinstance(roots, RootItem):
+            return roots.path_remapper(path, dst_platform, src_platform)
+
+        for _root in roots.values():
+            result = self.path_remapper(
+                path, dst_platform, src_platform, _root
+            )
+            if result is not None:
+                return result
+
+    def find_root_template_from_path(self, path, roots=None):
+        """Find root value in entered path and replace it with formatting key.
+
+        Args:
+            path (str): Source path where root will be searched.
+            roots (Roots/dict, optional): It is possible to use different
+                roots than instance where method was triggered has.
+
+        Returns:
+            tuple: Output contains tuple with bool representing success as
+                first value and path with or without replaced root with
+                formatting key as second value.
+
+        Raises:
+            ValueError: When roots are not entered and can't be loaded.
+        """
+        if roots is None:
+            log.debug(
+                "Looking for matching root in path \"{}\".".format(path)
+            )
+            roots = self.roots
+
+        if roots is None:
+            raise ValueError("Roots are not set. Can't find path.")
+
+        if isinstance(roots, RootItem):
+            return roots.find_root_template_from_path(path)
+
+        for root_name, _root in roots.items():
+            success, result = self.find_root_template_from_path(path, _root)
+            if success:
+                log.info("Found match in root \"{}\".".format(root_name))
+                return success, result
+
+        log.warning("No matching root was found in current setting.")
+        return (False, path)
+
+    def set_root_environments(self):
+        """Set root environments for current project."""
+        for key, value in self.root_environments().items():
+            os.environ[key] = value
+
+    def root_environments(self):
+        """Use root keys to create unique keys for environment variables.
+
+        Concatenates prefix "OPENPYPE_ROOT" with root keys to create unique
+        keys.
+
+        Returns:
+            dict: Result is `{(str): (str)}` dicitonary where key represents
+                unique key concatenated by keys and value is root value of
+                current platform root.
+
+        Example:
+            With raw root values::
+                "work": {
+                    "windows": "P:/projects/work",
+                    "linux": "/mnt/share/projects/work",
+                    "darwin": "/darwin/path/work"
+                },
+                "publish": {
+                    "windows": "P:/projects/publish",
+                    "linux": "/mnt/share/projects/publish",
+                    "darwin": "/darwin/path/publish"
+                }
+
+            Result on windows platform::
+                {
+                    "OPENPYPE_ROOT_WORK": "P:/projects/work",
+                    "OPENPYPE_ROOT_PUBLISH": "P:/projects/publish"
+                }
+
+            Short example when multiroot is not used::
+                {
+                    "OPENPYPE_ROOT": "P:/projects"
+                }
+        """
+        return self._root_environments()
+
+    def all_root_paths(self, roots=None):
+        """Return all paths for all roots of all platforms."""
+        if roots is None:
+            roots = self.roots
+
+        output = []
+        if isinstance(roots, RootItem):
+            for value in roots.raw_data.values():
+                output.append(value)
+            return output
+
+        for _roots in roots.values():
+            output.extend(self.all_root_paths(_roots))
+        return output
+
+    def _root_environments(self, keys=None, roots=None):
+        if not keys:
+            keys = []
+        if roots is None:
+            roots = self.roots
+
+        if isinstance(roots, RootItem):
+            key_items = [self.env_prefix]
+            for _key in keys:
+                key_items.append(_key.upper())
+
+            key = "_".join(key_items)
+            # Make sure key and value does not contain unicode
+            #   - can happen in Python 2 hosts
+            return {str(key): str(roots.value)}
+
+        output = {}
+        for _key, _value in roots.items():
+            _keys = list(keys)
+            _keys.append(_key)
+            output.update(self._root_environments(_keys, _value))
+        return output
+
+    def root_environmets_fill_data(self, template=None):
+        """Environment variable values in dictionary for rootless path.
+
+        Args:
+            template (str): Template for environment variable key fill.
+                By default is set to `"${}"`.
+        """
+        if template is None:
+            template = "${}"
+        return self._root_environmets_fill_data(template)
+
+    def _root_environmets_fill_data(self, template, keys=None, roots=None):
+        if keys is None and roots is None:
+            return {
+                "root": self._root_environmets_fill_data(
+                    template, [], self.roots
+                )
+            }
+
+        if isinstance(roots, RootItem):
+            key_items = [Roots.env_prefix]
+            for _key in keys:
+                key_items.append(_key.upper())
+            key = "_".join(key_items)
+            return template.format(key)
+
+        output = {}
+        for key, value in roots.items():
+            _keys = list(keys)
+            _keys.append(key)
+            output[key] = self._root_environmets_fill_data(
+                template, _keys, value
+            )
+        return output
+
+    @property
+    def project_name(self):
+        """Return project name which will be used for loading root values."""
+        return self.anatomy.project_name
+
+    @property
+    def roots(self):
+        """Property for filling "root" key in templates.
+
+        This property returns roots for current project or default root values.
+        Warning:
+            Default roots value may cause issues when project use different
+            roots settings. That may happen when project use multiroot
+            templates but default roots miss their keys.
+        """
+        if self.project_name != self.loaded_project:
+            self._roots = None
+
+        if self._roots is None:
+            self._roots = self._discover()
+            self.loaded_project = self.project_name
+        return self._roots
+
+    def _discover(self):
+        """ Loads current project's roots or default.
+
+        Default roots are loaded if project override's does not contain roots.
+
+        Returns:
+            `RootItem` or `dict` with multiple `RootItem`s when multiroot
+            setting is used.
+        """
+
+        return self._parse_dict(self.anatomy["roots"], parent=self)
+
+    @staticmethod
+    def _parse_dict(data, key=None, parent_keys=None, parent=None):
+        """Parse roots raw data into RootItem or dictionary with RootItems.
+
+        Converting raw roots data to `RootItem` helps to handle platform keys.
+        This method is recursive to be able handle multiroot setup and
+        is static to be able to load default roots without creating new object.
+
+        Args:
+            data (dict): Should contain raw roots data to be parsed.
+            key (str, optional): Current root key. Set by recursion.
+            parent_keys (list): Parent dictionary keys. Set by recursion.
+            parent (Roots, optional): Parent object set in `RootItem`
+                helps to keep RootItem instance updated with `Roots` object.
+
+        Returns:
+            `RootItem` or `dict` with multiple `RootItem`s when multiroot
+            setting is used.
+        """
+        if not parent_keys:
+            parent_keys = []
+        is_last = False
+        for value in data.values():
+            if isinstance(value, six.string_types):
+                is_last = True
+                break
+
+        if is_last:
+            return RootItem(data, key, parent_keys, parent=parent)
+
+        output = {}
+        for _key, value in data.items():
+            _parent_keys = list(parent_keys)
+            _parent_keys.append(_key)
+            output[_key] = Roots._parse_dict(value, _key, _parent_keys, parent)
+        return output
diff --git a/openpype/pipeline/context_tools.py b/openpype/pipeline/context_tools.py
index 4a147c230b..047482f6ff 100644
--- a/openpype/pipeline/context_tools.py
+++ b/openpype/pipeline/context_tools.py
@@ -14,11 +14,8 @@ from pyblish.lib import MessageHandler
 import openpype
 from openpype.modules import load_modules, ModulesManager
 from openpype.settings import get_project_settings
-from openpype.lib import (
-    Anatomy,
-    filter_pyblish_plugins,
-)
-
+from openpype.lib import filter_pyblish_plugins
+from .anatomy import Anatomy
 from . import (
     legacy_io,
     register_loader_plugin_path,
diff --git a/openpype/pipeline/load/utils.py b/openpype/pipeline/load/utils.py
index 99e5d11f82..e813b7934f 100644
--- a/openpype/pipeline/load/utils.py
+++ b/openpype/pipeline/load/utils.py
@@ -9,10 +9,10 @@ import numbers
 import six
 from bson.objectid import ObjectId
 
-from openpype.lib import Anatomy
 from openpype.pipeline import (
     schema,
     legacy_io,
+    Anatomy,
 )
 
 log = logging.getLogger(__name__)
diff --git a/openpype/plugins/load/delete_old_versions.py b/openpype/plugins/load/delete_old_versions.py
index c3e9e9fa0a..7465f53855 100644
--- a/openpype/plugins/load/delete_old_versions.py
+++ b/openpype/plugins/load/delete_old_versions.py
@@ -9,9 +9,8 @@ import qargparse
 from Qt import QtWidgets, QtCore
 
 from openpype import style
-from openpype.pipeline import load, AvalonMongoDB
+from openpype.pipeline import load, AvalonMongoDB, Anatomy
 from openpype.lib import StringTemplate
-from openpype.api import Anatomy
 
 
 class DeleteOldVersions(load.SubsetLoaderPlugin):
diff --git a/openpype/plugins/load/delivery.py b/openpype/plugins/load/delivery.py
index 7df07e3f64..0361ab2be5 100644
--- a/openpype/plugins/load/delivery.py
+++ b/openpype/plugins/load/delivery.py
@@ -3,8 +3,8 @@ from collections import defaultdict
 
 from Qt import QtWidgets, QtCore, QtGui
 
-from openpype.pipeline import load, AvalonMongoDB
-from openpype.api import Anatomy, config
+from openpype.lib import config
+from openpype.pipeline import load, AvalonMongoDB, Anatomy
 from openpype import resources, style
 
 from openpype.lib.delivery import (
diff --git a/openpype/plugins/publish/collect_anatomy_object.py b/openpype/plugins/publish/collect_anatomy_object.py
index 2c87918728..b1415098b6 100644
--- a/openpype/plugins/publish/collect_anatomy_object.py
+++ b/openpype/plugins/publish/collect_anatomy_object.py
@@ -4,11 +4,11 @@ Requires:
     os.environ -> AVALON_PROJECT
 
 Provides:
-    context -> anatomy (pype.api.Anatomy)
+    context -> anatomy (openpype.pipeline.anatomy.Anatomy)
 """
 import os
-from openpype.api import Anatomy
 import pyblish.api
+from openpype.pipeline import Anatomy
 
 
 class CollectAnatomyObject(pyblish.api.ContextPlugin):
diff --git a/openpype/plugins/publish/extract_jpeg_exr.py b/openpype/plugins/publish/extract_jpeg_exr.py
index a467728e77..42c4cbe062 100644
--- a/openpype/plugins/publish/extract_jpeg_exr.py
+++ b/openpype/plugins/publish/extract_jpeg_exr.py
@@ -19,7 +19,7 @@ class ExtractThumbnail(pyblish.api.InstancePlugin):
     label = "Extract Thumbnail"
     order = pyblish.api.ExtractorOrder
     families = [
-        "imagesequence", "render", "render2d",
+        "imagesequence", "render", "render2d", "prerender",
         "source", "plate", "take"
     ]
     hosts = ["shell", "fusion", "resolve"]
diff --git a/openpype/settings/defaults/project_settings/harmony.json b/openpype/settings/defaults/project_settings/harmony.json
index 1508b02e1b..d843bc8e70 100644
--- a/openpype/settings/defaults/project_settings/harmony.json
+++ b/openpype/settings/defaults/project_settings/harmony.json
@@ -1,4 +1,20 @@
 {
+    "load": {
+        "ImageSequenceLoader": {
+            "family": [
+                "shot",
+                "render",
+                "image",
+                "plate",
+                "reference"
+            ],
+            "representations": [
+                "jpeg",
+                "png",
+                "jpg"
+            ]
+        }
+    },
     "publish": {
         "CollectPalettes": {
             "allowed_tasks": [
diff --git a/openpype/settings/entities/schemas/projects_schema/schema_project_harmony.json b/openpype/settings/entities/schemas/projects_schema/schema_project_harmony.json
index c049ce3084..311f742f81 100644
--- a/openpype/settings/entities/schemas/projects_schema/schema_project_harmony.json
+++ b/openpype/settings/entities/schemas/projects_schema/schema_project_harmony.json
@@ -5,6 +5,34 @@
     "label": "Harmony",
     "is_file": true,
     "children": [
+        {
+            "type": "dict",
+            "collapsible": true,
+            "key": "load",
+            "label": "Loader plugins",
+            "children": [
+                {
+                    "type": "dict",
+                    "collapsible": true,
+                    "key": "ImageSequenceLoader",
+                    "label": "Load Image Sequence",
+                    "children": [
+                        {
+                            "type": "list",
+                            "key": "family",
+                            "label": "Families",
+                            "object_type": "text"
+                        },
+                        {
+                            "type": "list",
+                            "key": "representations",
+                            "label": "Representations",
+                            "object_type": "text"
+                        }
+                    ]
+                }
+            ]
+        },
         {
             "type": "dict",
             "collapsible": true,
diff --git a/openpype/tools/loader/widgets.py b/openpype/tools/loader/widgets.py
index 1f6d8b9fa2..13e18b3757 100644
--- a/openpype/tools/loader/widgets.py
+++ b/openpype/tools/loader/widgets.py
@@ -17,8 +17,7 @@ from openpype.client import (
     get_thumbnail_id_from_source,
     get_thumbnail,
 )
-from openpype.api import Anatomy
-from openpype.pipeline import HeroVersionType
+from openpype.pipeline import HeroVersionType, Anatomy
 from openpype.pipeline.thumbnail import get_thumbnail_binary
 from openpype.pipeline.load import (
     discover_loader_plugins,
diff --git a/openpype/tools/texture_copy/app.py b/openpype/tools/texture_copy/app.py
index 746a72b3ec..a695bb8c4d 100644
--- a/openpype/tools/texture_copy/app.py
+++ b/openpype/tools/texture_copy/app.py
@@ -6,8 +6,7 @@ import speedcopy
 
 from openpype.client import get_project, get_asset_by_name
 from openpype.lib import Terminal
-from openpype.api import Anatomy
-from openpype.pipeline import legacy_io
+from openpype.pipeline import legacy_io, Anatomy
 
 
 t = Terminal()
diff --git a/openpype/tools/workfiles/files_widget.py b/openpype/tools/workfiles/files_widget.py
index a7e54471dc..c92e4fe904 100644
--- a/openpype/tools/workfiles/files_widget.py
+++ b/openpype/tools/workfiles/files_widget.py
@@ -11,7 +11,6 @@ from openpype.tools.utils import PlaceholderLineEdit
 from openpype.tools.utils.delegates import PrettyTimeDelegate
 from openpype.lib import (
     emit_event,
-    Anatomy,
     get_workfile_template_key,
     create_workdir_extra_folders,
 )
@@ -22,6 +21,7 @@ from openpype.lib.avalon_context import (
 from openpype.pipeline import (
     registered_host,
     legacy_io,
+    Anatomy,
 )
 from .model import (
     WorkAreaFilesModel,
diff --git a/website/docs/admin_use.md b/website/docs/admin_use.md
index f84905c486..1c4ae9e01c 100644
--- a/website/docs/admin_use.md
+++ b/website/docs/admin_use.md
@@ -105,6 +105,10 @@ save it in secure way to your systems keyring - on Windows it is **Credential Ma
 This can be also set beforehand with environment variable `OPENPYPE_MONGO`. If set it takes precedence
 over the one set in keyring.
 
+:::tip Minimal permissions for DB user
+- `readWrite` role to `openpype` and `avalon` databases
+- `find` permission on `openpype`, `avalon` and `local`
+  
 #### Check for OpenPype version path
 When connection to MongoDB is made, OpenPype will get various settings from there - one among them is
 directory location where OpenPype versions are stored. If this directory exists OpenPype tries to