Load Published Files


Locate published files and reference them into your scene.
Latest Version: v1.21.0 (prod)
For our version numbers, we follow the Semantic Versioning standard.
System Name: tk-multi-loader2

Please Note: This document describes functionality only available if you have taken control over a Toolkit configuration. Please refer to the Shotgun Integrations User Guide for more details.
Overview Summary
                  The tree view
                  Filtering publishes
                  Help, no actions are showing up!
                  Managing actions
Installation, Updates and Development
Configuration Options
Release Notes History

The Shotgun Loader lets you quickly overview and browse the files that you have published to Shotgun. A searchable tree view navigation system makes it easy to quickly get to the task, shot or asset that you are looking for and once there the loader shows a thumbnail based overview of all the publishes for that item. Through configurable hooks you can then easily reference or import a publish into your current scene.

Overview Video

The following video gives a quick overview of features and functionality.


This document describes functionality only available if you have taken control over a Toolkit configuration. Please refer to the Shotgun Integrations User Guide for details.


The loader is highly configurable and you can set it up in many different ways. There are two main configuration areas:

  • Setting up what tabs and what content to display in the left hand side tree view.
  • Controlling which actions to display for different publishes and controlling what the actions actually do.

The following sections will give a high level overview how you can configure the loader. For technical minutiae relating to the configuration, please see the separate section further down in the documentation.

The tree view

The tree view is highly configurable and you can control the content of the various tabs using standard Shotgun filter syntax. Each tab consists of a single Shotgun API query which is grouped into a hierarchy. You can add arbitrary filters to control which items are being shown, and you can use the special keywords {context.entity}, {context.project}, {context.project.id}, {context.step}, {context.task} and {context.user} to scope a query based on the current context. Each of these keywords will be replaced with the relevant context information, either None, if that part of the context is not populated or a standard Shotgun link dictionary containing the keys id, type and name.

By default, the loader will show assets and shots belonging to the current project. By reconfiguring, this could easily be extended to for example show items from other projects (or a specific asset library project for example). You could also for example use filters to only show items with certain approval status or group items by status or by other Shotgun fields. Below are some sample configuration settings illustrating how you could set up your tree view tabs:

<a name="An asset library tab which shows assets from a specific"></a>
# An asset library tab which shows assets from a specific
<a name="Shotgun project"></a>
# Shotgun project
caption: Asset Library
entity_type: Asset
hierarchy: [sg_asset_type, code]
- [project, is, {type: Project, id: 123}]

<a name="Approved shots from the current project"></a>
# Approved shots from the current project
caption: Shots
hierarchy: [project, sg_sequence, code]
entity_type: Shot
- [project, is, '{context.project}']
- [sg_status_list, is, fin]

<a name="All assets for which the current user has tasks assigned"></a>
# All assets for which the current user has tasks assigned
caption: Assets
entity_type: Task
hierarchy: [entity.Asset.sg_asset_type, entity, content]
- [entity, is_not, null]
- [entity, type_is, Asset]
- [task_assignees, is, '{context.user}']
- [project, is, '{context.project}']

Filtering publishes

It is possible to apply a Shotgun filter to the publish query that the loader carries out when it loads publish data from Shotgun. This is controlled via the publish_filters parameter and can be used for example to hide publishes that have not been approved or where their associated review version has not been approved.

Help, no actions are showing up!

The loader comes with a number of different actions for each engine. For example, in the case of Nuke, there are two actions: "import script" and "create read node". Actions are defined in hooks, meaning that you can modify their behaviour or add additional actions if you wanted to. Then, in the configuration for the loader, you can bind these actions to certain publish types you have. Binding an action to a publish type basically means that the action will appear on the actions menu for all items of that type inside the loader.

As an example, by default, the mappings for Nuke are set up like this:

  Nuke Script: [script_import]
  Rendered Image: [read_node]

If you are finding that no action menus are showing up, it may be because you have chosen different names for the publish types that you are using. In that case, go into the config and add those types in order to have them show up inside the loader.

Managing actions

For each application that the loader supports, there is an actions hook which implements the actions that are supported for that application. For example, with something like Maya, the default hook will implement the reference, import and texture_node actions, each carrying out specific Maya commands to bring content into the current Maya scene. As with all hooks, it is perfectly possible to override and change these, and it is also possible to create a hook that derives from the built in hook, making it easy to add additional actions to a built-in hook without having to duplicate lots of code.

Once you have defined a list of actions in your actions hook, you can then bind these actions to Publish File types. For example, if you have a Publish File type in your pipeline named "Maya Scene" you can bind this in the configuration to the reference and import actions that are defined in the hook. By doing this, Toolkit will add a reference and an import action to each Maya Scene publish that is being shown. Separating the Publish Types from the actual hook like this makes it easier to reconfigure the loader for use with a different publish type setup than the one that comes with the default configuration.

The loader uses Toolkit's second generation hooks interface, allowing for greater flexibility. This hook format uses an improved syntax. You can see this in the default configuration settings that are installed for the loader, looking something like this:

actions_hook: '{self}/tk-maya_actions.py'

The {self} keyword tells Toolkit to look in the app hooks folder for the hook. If you are overriding this hook with your implementation, change the value to {config}/loader/my_hook.py. This will tell Toolkit to use a hook called hooks/loader/my_hook.py in your configuration folder.

Another second generation hooks feature that the loader is using is that hooks no longer need to have an execute() method. Instead, a hook is more like a normal class and can contain a collection of methods that all makes sense to group together. In the case of the loader, your actions hook will need to implement the following two methods:

def generate_actions(self, sg_publish_data, actions, ui_area)
def execute_multiple_actions(self, actions)

For more information, please see the hook files that come with the app. The hooks also take advantage of inheritance, meaning that you don't need to override everything in the hook, but can more easily extend or augment the default hook in various ways, making hooks easier to manage.

Note that in versions previous to v1.12.0, the application invoked the execute_action hook to execute an action. Newer versions invoke the execute_multiple_actions hook. In order to provide backward compatibility with existing hooks, the execute_multiple_actions hook actually invokes execute_action for each actions provided. If the application is reporting that the execute_multiple_actions hook is not defined after upgrading to v1.12.0 or later, make sure that the actions_hook setting in your environment correctly inherits from the builtin hook {self}/{engine_name}_actions.py. To learn more about how you can derive custom hooks from the builtin ones, see our Toolkit reference documentation.

By using inheritance in your hook, it would be possible to add additional actions to the default hooks like this:

import sgtk
import os

<a name="toolkit will automatically resolve the base class for you"></a>
# toolkit will automatically resolve the base class for you
<a name="this means that you will derive from the default hook that comes with the app"></a>
# this means that you will derive from the default hook that comes with the app
HookBaseClass = sgtk.get_hook_baseclass()

class MyActions(HookBaseClass):

    def generate_actions(self, sg_publish_data, actions, ui_area):
        Returns a list of action instances for a particular publish.
        This method is called each time a user clicks a publish somewhere in the UI.
        The data returned from this hook will be used to populate the actions menu for a publish.

        The mapping between Publish types and actions are kept in a different place
        (in the configuration) so at the point when this hook is called, the loader app
        has already established *which* actions are appropriate for this object.

        The hook should return at least one action for each item passed in via the
        actions parameter.

        This method needs to return detailed data for those actions, in the form of a list
        of dictionaries, each with name, params, caption and description keys.

        Because you are operating on a particular publish, you may tailor the output
        (caption, tooltip etc) to contain custom information suitable for this publish.

        The ui_area parameter is a string and indicates where the publish is to be shown.
        - If it will be shown in the main browsing area, "main" is passed.
        - If it will be shown in the details area, "details" is passed.
        - If it will be shown in the history area, "history" is passed.

        Please note that it is perfectly possible to create more than one action "instance" for
        an action! You can for example do scene introspection - if the action passed in
        is "character_attachment" you may for example scan the scene, figure out all the nodes
        where this object can be attached and return a list of action instances:
        "attach to left hand", "attach to right hand" etc. In this case, when more than
        one object is returned for an action, use the params key to pass additional
        data into the run_action hook.

        :param sg_publish_data: Shotgun data dictionary with all the standard publish fields.
        :param actions: List of action strings which have been defined in the app configuration.
        :param ui_area: String denoting the UI Area (see above).
        :returns List of dictionaries, each with keys name, params, caption and description

        # get the actions from the base class first
        action_instances = super(MyActions, self).generate_actions(sg_publish_data, actions, ui_area)

        if "my_new_action" in actions:
            action_instances.append( {"name": "my_new_action",
                                      "params": None,
                                      "caption": "My New Action",
                                      "description": "My New Action."} )

        return action_instances

    def execute_action(self, name, params, sg_publish_data):
        Execute a given action. The data sent to this be method will
        represent one of the actions enumerated by the generate_actions method.

        :param name: Action name string representing one of the items returned by generate_actions.
        :param params: Params data, as specified by generate_actions.
        :param sg_publish_data: Shotgun data dictionary with all the standard publish fields.
        :returns: No return value expected.

        # resolve local path to publish via central method
        path = self.get_publish_path(sg_publish_data)

        if name == "my_new_action":
            # do some stuff here!

            # call base class implementation
            super(MyActions, self).execute_action(name, params, sg_publish_data)

We could then bind this new action to a set of publish types in the configuration:

  Maya Scene: [import, reference, my_new_action]
  Maya Rig: [reference, my_new_action]
  Rendered Image: [texture_node]

By deriving from the hook as shown above, the custom hook code only need to contain the actual added business logic which makes it easier to maintain and update.


The following methods are available on the app instance.


Presents an 'Open File' style version of the Loader that allows the user to select a publish. The selected publish is then returned. The normal actions configured for the app are not permitted when run in this mode.

app.open_publish( str title, str action, list publish_types )

Parameters and Return Value

  • str title - The title to be displayed in the open publish dialog.
  • str action - The name of the action to be used for the 'open' button.
  • list publish_types - A list of publish types to use to filter the available list of publishes. If this is empty/None then all publishes will be shown.
  • Returns: A list of Shotgun entity dictionaries that were selected by the user.


>>> engine = sgtk.platform.current_engine()
>>> loader_app = engine.apps.get["tk-multi-loader2"]
>>> selected = loader_app.open_publish("Select Geometry Cache", "Select", ["Alembic Cache"])
>>> print selected

Related Apps and Documents

Scene Breakdown

The Scene Breakdown App shows you a list of items you have loaded (referenced) in your scene and tells you which ones are out of date. From this overview, you can select multiple objects and click the update button which will update all your selected items to use the latest published version.


The Publish app allows artists to publish their work so that it can be used by artists downstream. It supports traditional publishing workflows within the artist’s content creation software as well as stand-alone publishing of any file on disk. When working in content creation software and using the basic Shotgun integration, the app will automatically discover and display items for the artist to publish. For more sophisticated production needs, studios can write custom publish plugins to drive artist workflows.

Shotgun Panel

The Shotgun Panel lets you quickly access Shotgun information from an embedded panel. It provides easy access to information about the task that the user is currently working on and you have instant access to the activity stream, notes, tasks, versions and publishes. Play back versions sent to review by other members of your team. Reply to notes directly from inside your application. If you pipeline tracks dependency information, you can browse this directly from the Shotgun Panel as well.

Shotgun Workfiles

This application forms the basis for file management in the Shotgun Pipeline Toolkit. It lets you jump around quickly between your various Shotgun entities and gets you started working quickly. No path needs to be specified as the application manages that behind the scenes. The application helps you manage your working files inside a Work Area and makes it easy to share your work with others.

Admin Guide

This is the Admin Guide for Shotgun Integrations.

Shotgun Pipeline Tutorial

This document provides a step-by-step tutorial for Technical Directors (TDs) wishing to set up a simple, end-to-end pipeline using Shotgun integrations and the Toolkit platform. The goal of the tutorial is to provide users with an understanding of the fundamental aspects of the integrations and platform as well as the know how to build and customize a Shotgun-base pipeline to fit their studio's specific needs.

User Guide

This is the User Guide for Shotgun Integrations.

Installation and Updates

Adding this App to the Shotgun Pipeline Toolkit

If you want to add this app to Project XYZ, in an environment named asset, execute the following command:

> tank Project XYZ install_app asset tk-maya tk-multi-loader2

Updating to the latest version

If you already have this item installed in a project and you want to get the latest version, you can run the update command. You can either navigate to the tank command that comes with that specific project, and run it there:

> cd /my_tank_configs/project_xyz
> ./tank updates

Alternatively, you can run your studio tank command and specify the project name to tell it which project to run the update check for:

> tank Project XYZ updates

Collaboration and Evolution

If you have access to the Shotgun Pipeline Toolkit, you also have access to the source code for all apps, engines and frameworks in Github where we store and manage them. Feel free to evolve these items; use them as a base for further independent development, make changes (and submit pull requests back to us!) or simply tinker with them to see how they have been built and how the toolkit works. You can access this code repository at https://github.com/shotgunsoftware/tk-multi-loader2.

Special Requirements

  • You need Shotgun Pipeline Toolkit Core API version v0.19.1 or higher to use this.


Below is a summary of all the configuration settings used. These settings need to be defined in the environment file where you want to enable this App or Engine.


Type: str

Default Value: Load

Description: Name to appear on the ShotGrid menu.


Type: str

Default Value: Loader

Description: Name to appear on the title of the UI Dialog.


Type: hook

Default Value: {self}/{engine_name}_actions.py

Description: Hook which contains all methods for action management.


Type: hook

Default Value: {self}/filter_publishes.py

Description: Specify a hook that, if needed, can filter the raw list of publishes returned from ShotGrid for the current location.


Type: bool

Default Value: True

Description: Controls whether thumbnails should be downloaded from ShotGrid or not. We strongly recommend that thumbnails are downloaded since this greatly enhances the user experience of the loader, however in some situations this may be difficult due to bandwidth or infrastructural restrictions.


Type: dict

Description: Associates published file types with actions. The actions are all defined inside the actions hook.


Type: dict

Description: Associates entity types with actions. The actions are all defined inside the actions hook.


Type: list

Default Value: [{'caption': 'Project', 'type': 'Hierarchy', 'root': '{context.project}', 'publish_filters': []}, {'caption': 'My Tasks', 'type': 'Query', 'entity_type': 'Task', 'publish_filters': [], 'filters': [['task_assignees', 'is', '{context.user}'], ['project', 'is', '{context.project}']], 'hierarchy': ['entity', 'content']}]

Description: This setting defines the different tabs that will show up on the left hand side. Each tab represents a ShotGrid query, grouped by some ShotGrid fields to form a tree. This setting is a list of dictionaries. Each dictionary in the list defines one tab. Dictionaries with their type key set to 'Hierarchy' should have they following keys: caption specifies the name of the tab, root specifies the path to the root of the project hierarchy to display. Dictionaries with their type key set to 'Query' should have they following keys: caption specifies the name of the tab, entity_type specifies the ShotGrid entity type to display. filters is a list of standard API ShotGrid filters. hierarchy is a list of ShotGrid fields, defining the grouping of the tree. Optionally, you can specify a publish_filters key, containing ShotGrid API filters to apply to the publishes listing as it is being loaded in the main view.


Type: list

Description: List of additional ShotGrid filters to apply to the publish listings. These will be applied before any other filtering takes place and would allow you to for example hide things with a certain status.

Release Notes

Welcome to the release notes for this App. Below you will find an overview of all the changes we did for each release. We try to be as detailed as possible and include all bugs we have fixed, features we have added and things that may have changed. If you have questions about a particular release, don't hesitate to contact our support team!



Rebranded to ShotGrid



Adds Python 3 support for the Nuke hook.



Adds Python 3 support for the Maya hook.



Adds Python 3 support for the Photoshop hook.



Adds Python 3 support.



Publishes now show the entity display name instead of the entity name.



The application does not ship with the Blur Python based hooks for 3dsMax anymore.


The tk-3dsmax engine implementation has been upgraded to use pymxs. As such, the old Blur Python based hooks are not compatible anymore with the engine. They can be downloaded from here.



Internal changes impacting metrics properties.


No change in user-facing functionality.



Fixes button styling issues evident in Houdini 17.


Houdini 17's stylesheet forces a specific size for QToolButton widgets. This change sets a minimum size for those buttons in the loader app so that they maintain a usable size.



Added Mp4 to Valid Extensions



Small change to the publish type model as part of a fix for the reload menu option.



Adds support for importing publishes as clips in Nuke Studio and Hiero.



Adds support for complex filters to be used when setting the tab filters.


Previously you would not be able to add a filter to a tab through the settings that used sub conditions and filter operators. With the update you can now do something like this:

      - [project, is, "{context.project}"]
      - filter_operator: "any"
          - [entity, type_is, Asset]
          - [entity, type_is, Shot]



Adds support for version driven browsing.


This fixes a bug which previously prevented you to configure the loader in a way so that you would be browsing Versions in the left hand side tree and when you clicked a version you would see the publishes associated with that version.



solved problems loading utf-8 files



Updated metrics logged



Implements image sequence frame range detection in Nuke when no template is available.


In a zero config project there is no access to templates. When we're in that situation, we now fall back on parsing the file name without a template to try to determine the start/end frame of an image sequence.



Play in sg panel now navigates to media player


This changes the behaviour of the sg panel so that if you click the play icon for a version, it will navigate you to the sg media center page rather than screening room which was previously the case. Back when we originally wrote this code, the media center was not yet released and they did not have proper urls that you can navigate to. This change aligns the behaviour in the panel with what you get in other parts of Shotgun.



Stops app init when there's no GUI. This resolves issues when PySide is not available.



Improvement to the tk-flame functionalities and bug fixes.



Improve error handling in tk-flame actions



Add support for Flame



Adds texture node loading in 3dsmax



A banner is now displayed to give a visual indication that a custom action has been executed.



Now supports project item display in hierarchy.



Hierarchy support and new default actions for maya, nuke and houdini.


  • Adds hierarchy support to loader, including hierarchy based searching
  • Updates the defaults to use a hierarchy tab instead of the shot and asset tabs
  • Added houdini file COP support
  • Added maya image plane support
  • Added nuke open project support



Adds support for entity level actions.


Added entity actions. You can now define custom actions on entities (the folders showing up in the loader) just like you can define actions on publishes. This makes it possible to create workflows where you operate on a shot or an asset. Quick examples of workflows that can be realised by adding custom entity actions include

  • Ability to trigger a remote transfer for a shot.
  • Ability to change the status of something.
  • Ability to operate on all publishes inside a shot or asset.
  • Ability to find a cut for a sequence and load it in.



Removes problematic profiles from png files used as icons.


This will silence libpng warnings from Qt when the png files are loaded as pixmaps. This is a second attempt as this profile stripping, and uses ImageMagick's "mogrify" command to achieve the desired result, which maintains color consistency.



Rolls back the use of a hierarchy model for the loader tree view.


Issues discovered on the back end result in the hierarchy model being unable to access some data in Shotgun when the default "Artist" permissions set is used. Until that has been resolved, the hierarchy model won't be used in the loader app.



Adds support for tk-photoshopcc.



New setting option to define left hand side tabs driven by the Shotgun hierarchy model.



Do not display empty action menus in the publish view.



Bug fix to better handle optimized shotgun model.


Fixes an issue where subfolders were not appearing in the middle view in the UI when you clicked a node in the tree that had not yet been expanded.



Updated to use open sans font.



Updated to use v5 of the shotgun utils framework with improved data loading performance.



'Show in the file system' available only when a folder widget has some paths.


Add 'Show in the file system' to a folder Actions menu only when there are some paths associated with its Shotgun entity. This is done at runtime when the folder is selected.



Left hand side tree view is now ordered in a case insensitive fashion.



Adds multi-selection support to the loader and UI tweaks and left hand tree view is now sorted alphabetically.



Upon selecting multiple items, a user can now right-click on a selection to see the set of actions that can be executed on all publishes.

This change is backwards compatible with the existing hooks. To learn more about how you can leverage the new execute_multiple_actions hook method, please visit our support page.



Tab UI Bug fix. Added support for context.project.id token in configuration.



fixes No data retrievers registered warnings


The background task manager that uses the CachedShotgunSchema was not registered which generated the following warning if the schema cache did not exist:

Shotgun Warning: No data retrievers registered with this schema manager. Cannot load shotgun schema

The background task manager is now registered correctly.



Only allows Alembic imports in Max 2016+.


Native Alembic support was added to 3ds Max in the 2016 release. As a result, we have to exclude pre-2016 versions of 3ds Max from Alembic support.



Adds Alembic import support for tk-3dsmaxplus.



Added user activity metrics for particular actions



QA fix removes alembic load support



QA fix for UNC path on windows



Adds support for loading Alembic caches into Nuke.



Adds support for loading Alembic caches into Houdini.



Adds support for context changes.



Fixed a minor regression causing some updates in nuke to not appear in the UI.



Updated to use v4.x.x of the Shotgun Utils Framework



Upgraded to use new versions of the frameworks


This fixes an issue where a tile would be missing in the loader if the user who created the shot or asset had been deleted.


The 'filter_publishes' hook is now also applied to the version history view.


Allow access to the status (sg_status_list) field in a filter_publishes hook


Show task information for publishes in the list view.


Improved thumbnail performance - NOTE - this change is coupled with v2.4.0 of the shotgun-utils framework and will not run correctly without it. When the app update asks you if you want to install v2.4.0 of the shotgun utils framework, please make sure to accept the update.


This implements async thumb loading, which was added to the Shotgun Utils Framework v2.4.0. Thumbnails will be loaded in a worker thread rather in the main thread. This improves performance, especially in the case when thumbnails are located on a remote storage.


Added an improved publish quick-filter UI


  • Adds a case insensitive quickfilter UI which lets a user quickly cull the list of publishes based on an expression.
  • Tweaked the nuke publish hook so that it handles upper case file extensions.
  • Fixed an issue with the selection clearing at exit, which was causing errors in Maya.


Added additional file formats to the default nuke hook.


Added psd to the list of supported file extensions in the default nuke hook.


Added a list view mode for more compact browsing.


This adds a new mode for the main publish view. More compact than the thumbnail mode, this allows for fast vertical browsing of larger lists of items.


Fixed a bug causing user thumbnails sometimes to show up instead of the main thumbnail.


Fix 3ds Max when merging objects


Fixes crashing issues relating to qt dialogs and max modal.


Added support for the new 3DS Max Engine supporting MaxPlus and Max version 2015.


Minor improvements for the Open Publish version of the Loader UI


  • Actions defined for the main loader are no longer available when just opening a publish
  • Double-click on a publish or publish version will now perform the default open action


Added Mari support


  • Mari hooks now support loading published geometry into Mari
  • Maya hooks add support for loading Mari UDIM textures into Maya 2015
  • Added an 'open_publish' method to the app that opens the loader in a modal 'file-open' mode. This allows an artist to select a publish and then click the 'Open' button which will return the selected publish to the calling code. This is used by the new Mari New Project command.
  • Updated to require core v0.14.66


Fixed a bug causing publishes with the same name and type but with different tasks to be obscured in the main view.


Various minor improvements and bug fixes


  • Added right-click refresh buttons in views.
  • History UI and main UI now pass consistent shotgun data to actions hook
  • Multi entity link field values now formatted better.
  • Changed the display name from "Publish Loader" to just "Loader"
  • Added houdini default hooks and merge support for hip files.
  • Fixes a bug causing duplicates to show up in the type list. Previously, the type list showed a raw dump of the shotgun data. This meant that if you had two types in this list both named "maya anim", you would have two "maya anim" entries showing up, which is confusing. This is common if you still use the tank types (or in some cases have converted from from the tank types). This change collapses type entries with the same name down to a single entry.
  • Unix timestamps are now converted before being passed to hook. The unix timestamp handling is to mitigate various shortcomings in the QT/PySide/SG API serialization capabilities and means that all time stamps in the model data are cached as unix timestamps (number of seconds since 1 Jan 1970 in UTC time zone - http://en.wikipedia.org/wiki/Unix_time). This means that all data currently being returned by the sg model comes back with this time data format rather than the standard SG Time stamp. (there is no easy way to slap an interface around the return data). This fix converts these unix timestamps back to sg timestamps prior to passing shotgun data to the action hooks, making it more familiar for TDs and developers.
  • Fixed pixmap:scaled errors.
  • Version history now constrains by task and project. When displaying the version history based on an existing publish, the associated fields to display are now determined based on more commonality than before - previously, it was only name, type and associated entity. With this change, project and task are also included. This means that you can have two publishes with the same type and same name for the same shot, but with different tasks associated, and the loader will treat their version histories as completely independent.
  • Added support for per-profile publish filters. Adds a new parameter to the config such that you can specify a publish filter for each tab on the left hand side.


Updated to use v2.x of the Shotgun Utils framework and v1.x of the QT Widgets framework. Added an option to disable thumbnail loading.


Bug fixes and UI improvements.


  • Added 3dsmax reference action (XRef Scene) and modified the existing import action to perform a merge.
  • Fixed incorrect sort order in publish history.
  • Show publish name and type when in "show subfolders" mode to match default display behavior.
  • Fixed broken photoshop "open file" action.


UI Polish and minor tweaks.

Details: - Changed the copy in some of the hooks. - Fixed a typo in a tooltip. - Added a try/catch around the closeEvent() in the main dialog to ensure graceful exit.


Added maya import action.


Improved breadcrumb behaviour.


Fixed an bug where the wrong publishes would be displayed in some cases.


Tweaked app manifest.


Improved icons and information screens.


Candidate for official first release.


Updated Photoshop action to Add as a Layer


  • It is now possible to load another PSD, PSB or image in the current Photoshop document.
  • The loaded media is embedded in a new layer.
  • This works in all supported versions of Photoshop.