Overview

Project Anatomy is where you can configure the projects you work on with AYON.

Configurations included on the Anatomy page:

• Entity Naming: Configure how the name of a folder or task is generated from its label.

• Roots: Root storage path locations. You can add as many as you want.

• Templates: Defines file paths for workspaces and publish spaces. They can be relative to the root locations.

• Attributes: (Legacy) This is where you can set project attributes. This has been replaced by the Projects Dashboard.

• Folder Types: Types of folders you can create in your project hierarchy.

• Task Types: Types of tasks you can create in your project hierarchy.

• Statuses: The types of statuses you can set for entities within your project.

• Tags: The types of tags you can use in your project.

• Link Types: The types of links you can create in your project hierarchy.

Anatomy Presets

Anatomy presets are defined in the Studio Settings (S+S) within the Anatomy Presets tab. You can define many anatomy presets, but only one can be set as your primary anatomy preset.

When creating a new project, AYON will prompt you to pick an anatomy preset to apply.

Anatomy Scoping

Entity Naming

Entity Naming settings control how a folder or task name is automatically generated from its label. This is a suggestion that helps enforce consistent naming conventions across projects. You can always override the suggested name with your own custom name, as long as it follows the correct formatting.

The following options are available:

• Capitalization:

  • all lowercase: Converts all characters to lowercase.

  • ALL UPPERCASE: Converts all characters to uppercase.

  • Keep original capitalization: Retains the capitalization exactly as entered.

  • Capitalize Every Word: Capitalizes the first letter of each word.

  • capitalize Every Word Except The First: Capitalizes every word except the first.

• Separator:

  • underscore _: Replaces spaces with an underscore (e.g., hello_world).

  • dash -: Replaces spaces with a dash (e.g., hello-world).

  • dot .: Replaces spaces with a dot (e.g., hello.world).

  • none "": Removes all spaces (e.g., helloworld).

Entity Naming added in server version 1.2.1

Roots

Roots define the storage locations where you can store files. Root paths can point to any path, either local or to shared folders on a network storage. It is required to set the root path for each platform used in the studio. All paths must point to the same folder.

It is possible to set multiple roots when necessary. This may be useful when you need to store a specific type of data on another disk. Nothing really stops you from configuring this the way you need for example, you can define a dedicated root location for your work area and another for renders, or even more.

Roots are referenced in templates. For example, if you have a "work" root defined, you can reference it in the form {root[work]} in templates. This ensures that your templates start with a dedicated root location and that all paths are relative to that root.

Templates

AYON anatomy templates serve as the connection point between the AYON pipeline and your file storage. They allow you to configure how your project's folder structure and filenames will be organized on disk.

For example, while you can create the project folder hierarchy in the Project Overview Page, this action alone does not define the folder structure in your storage.

Each anatomy template is constructed using AYON context keys. For instance, a template starting with {root[work]}/{project[name]} means the file will be saved inside a directory named after your project, beneath a top-level root “work” directory.

AYON comes with a set of anatomy template categories, each dedicated to a particular use case.

Anatomy Templates Categories

Work

This template defines the work directory where the Workfiles tool will save workfiles. This is also referred to as the work area for a particular task.

You can add work template using the + button and each work template include:

• Name: The template name.

• Directory template: Defines the work location.

• File name template: Defines the workfile name.

Configuration:

To use work templates in your projects, you must specify them in the Core Addon settings' “workfile template profiles”: ayon+settings://core/tools/Workfiles/workfile_template_profiles

Here, you can specify which task types and hosts use which template. (Not specifying a task type means it works for all task types; not specifying a host means it works for all hosts.)

Publish

This defines the publish directory, which is the final destination where the published files will be stored.

You can add publish templates using the + button and each publish template include:

• Name: The template name.

• Directory template: Defines the publish location.

• File name template: Defines the published file name.

Configuration:

To use publish templates, specify them in the Core Addon settings' template name profiles: ayon+settings://core/tools/publish/template_name_profiles

Here, you can select the publish template and set conditions for its usage (based on product types, host name, task types, and task name).

Hero

This is the publish directory specifically dedicated to publishing Hero versions.

Configuration:

To use hero publish templates, specify them in the Core Addon settings' hero template name profiles: ayon+settings://core/tools/publish/hero_template_name_profiles

Here, you can select the publish template and set conditions for its usage (based on product types, host name, task types, and task name).

Delivery

This category is for defining delivery templates that can be used by the delivery action within the Desktop Browser tool.

Staging Directories

This category is for defining staging templates for storing staging files that are extracted in the staging step during the publishing.

Configuration:

To specify custom staging locations, set them in the Core Add-on settings' custom staging profiles: ayon+settings://core/tools/publish/custom_staging_dir_profiles

Others

These are extra templates that you can use across the pipeline. They are mostly associated with custom addons that utilize these templates for specific pipeline functions.

Available Template Keys

These are the keys you can reference inside your templates.

AYON Context Keys

The data for AYON Context keys are collected when launching applications and include the current session information, such as the AYON context (project, folder path, task name, app) and the current user.

Publish Data keys

These data are collected at the time of publishing for each publish instance. The data are consistent and always exist regardless of the DCC (Digital Content Creation) application you are publishing from, though they may depend on your specific publish instance.

Dynamic Publish Data keys

These data are collected at the time of publishing for each publish instance. However, they are supported on a product-type basis for each DCC (Digital Content Creation) application. It's recommended to reference them as optional keys, for example, <{renderlayer}><_{aov}>.

Datetime keys

These keys are collected at the time of publishing. More specifically, their values are collected when the "Collect Datetime data" publish plugin is run.

Reference Template Keys

Here's how to reference template keys in different templates:

• Standard Keys: To reference anatomy keys, use Python string formatting style by enclosing the key in curly brackets: {template_key}. For example, you would use {root[work]} or {product[type]}.

• Optional Keys: To make a key optional, enclose it in angle brackets: < {template_key} >. You can also add characters that will only appear if the key is resolved. For example, the template < _{udim} > will add an underscore before the UDIM number only if it exists.

  • You can even nest optional segments, such as < {key1} <.{key2}> >. This will result in an empty string if the outer key (key1) isn't available.

  Note: Optional segments that don't contain a formatting key (e.g., <something>) will remain as they are. This can cause errors on Windows, as angle brackets and other characters (\/:*?"<>|) are not allowed in file and folder names.

• Case Sensitivity: The letter case of the key follows the case of the template itself. For example, {aov}, {Aov}, and {AOV} are all distinct keys.

• Special Keys (Frame & Version): The frame and version keys are special multi-digit numbers. Always prefix them with the @ symbol, like this: {@frame} and {@version}. You can also control the zero-padding and template for each.

  For instance, v001 is the typical output for version 1 since the version number is always prefixed with a "v" and has 3-digit zero-padding. The frame key, on the other hand, only has frame padding, so frame 10 would be formatted as 1001.

  
  It's highly recommended not to change the default version and frame templates because many parts of the pipeline expect their default template. For example, since it's expected that all versions start with a v, removing it from the template can be problematic.

  However, changing the version and frame padding should be fine.

Attributes

Project attributes are used as default values that project folders inherit. Attributes that are not project-specific always use values from the folders themselves.

Folder Types

These are the types of folders you can create within your project hierarchy.

When creating a new folder under your project, you are only allowed to choose from the defined folder types.

Task Types

These are the available task types for a project.

When creating a new task, you are only allowed to choose from the defined task types.

Statuses

Any entity type (such as Folder, Product, Version, Representation, Task, or Workfile) can have a status defined within its scope. This means Folders and Tasks may share the same set of statuses, while a Version may have a completely different set. Each entity can only have one status assigned at a time.

You can view and set statuses in multiple places within AYON, For example:

• In the Tasks (Home) Page:

  

• In The Details Panel:

  

Tags

Tags can be anything and are supported on all entity types, including Folder, Product, Version, Representation, Task, and Workfile. An entity can have multiple tags or none at all.

Tags can be anything and are supported on all entity types, including Folder, Product, Version, Representation, Task, and Workfile. An entity can have multiple tags or none at all.

When adding a tag to an entity, you can only choose from the predefined tags.

Link Types

Links are static relationships you can create between two entities in AYON. For example, you can create a link from Task A to Task B.

Link Types define the available links you can create in your project. Each link type definition includes a link type name, an input type, an output type, and a color. The color is used for visualization in the Node Graph addon.

You can create and manage links within AYON via the Links Manager.

Product Types

This configuration includes two options: Default Appearance and Appearance Overrides.

• Default Appearance: This styling is applied to all products unless an override is specified for a particular product type.

• Appearance Overrides: Here, you can define specific product types and set a favored color and icon for their display on the web UI.

FAQ

I Can’t Find the Anatomy Template in Settings

This situation typically occurs when you define your anatomy template in one location but try to reference it in a different scope that doesn't share that definition.

For example, a template defined in the Primary Anatomy Preset will be available for selection when configuring Studio Settings. However, that same template will generally not be available when configuring settings at the Project level, as Project Settings reference the project's own project anatomy.

To resolve this, ensure your template is defined within the specific anatomy that the settings section you are working in is referencing.

For additional information, please see the Anatomy Scoping section.