Bifrost rigging modules are fully integrated with Maya, allowing you to connect and interact with module inputs and outputs directly from the Maya scene.

You can generate a full Maya rig from exposed rigging modules, making it easy to author procedural rigs in Bifrost and convert them into native Maya controls, joints, and attributes.

In addition, you can control rigging module nodes from Maya, including enabling or disabling terminal flags and toggling optimization settings.

A bifrostRigging command is also available for more technical users, allowing you to use the same features through scripted workflows or custom tools.

Accessing Module Data From Maya

You can expose the inputs, outputs, and parents ports of a rigging module at the top level of the Bifrost graph. Once exposed, these ports become accessible in Maya as compound attributes.

Each compound attribute mirrors the structure of their respective rigging module types, making it easy to navigate and interact with. You can query values, set values, or connected to the nested attributes by hand or scripting, just like with any standard Maya node.

This enables seamless interaction between Bifrost modules and Maya, allowing you to access module data to generate Maya objects and attributes, and drive modules directly from them.

Rigging Menu and Shelf Tools

Tools for working with Bifrost rigging modules can be accessed from the Bifrost Rigging menu when Maya’s menu set is set to Rigging. The same tools are also available as shelf buttons in the Bifrost shelf tab.

These tools operate on all Bifrost graphs in the scene if nothing is selected. If one or more graphs are selected, the tools apply only to the selected graphs. Both bifrostGraphShape and bifrostBoard node types are supported.

The available tools include:

• Create Rig From Modules: Creates a Maya rig from exposed rigging modules. Rig creation options can be adjusted through the Option Box.

• Optimize Modules: Sets modules into a high-performance state by disabling the edit_mode and profile_evaluation parameters.

• Module Terminals: Enables or disables the modules' terminal D flags.

• Selection Rerouting Behaviour: Toggles the optionVar that defines automatic selection behavior when working with Bifrost Rigging Manipulators. This applies only to rigs created using the cycleFree setup method.

Creating a Maya Rig

You can generate a Maya rig from rigging modules by using the Create Rig From Modules tool, or the bifrostRigging command with the -createRig flag.

The tool analyzes exposed module data and automatically creates the corresponding Maya controls, joints, attributes, and connects them to their respective Bifrost graph inputs and outputs.

All generated rig content is organized under a top-level group called a container. Within it, each type of object (pins, controls, joints, and operators) is placed into its own dedicated subgroup for clarity and structure.

Requirements

To create a Maya rig from modules, both the inputs and outputs ports of each module must be exposed at the top level of the graph. This ensures that Maya can access the required data.

If either port is unconnected or if a dependent module is not exposed, the corresponding module will be ignored during rig creation. Warnings will be reported in Maya's Script Editor, indicating which modules were skipped and why.

Lastly, any graph you run the tool on must contain at least one module that produces either a control or a joint. If no eligible modules are found, no rig will be generated.

Pins

When creating a rig from modules, any default pin defined on a module's inputs port will be used to create locator objects in Maya.

For each module, a subcontainer named after the module will be created within the pins subcontainer. All pins belonging to that module will be placed inside this subcontainer and named according to their respective pin names.

Pin values are not lost if the rig is deleted. You can safely remove and recreate the rig, and the pins will be regenerated at their last known positions, using the previously set attribute data.

You can move the pins at any time to adjust the rest state of your rig. Due to the procedural nature of Bifrost transforms, this workflow is non-destructive, even if the rig is already animated or used for skinning.

Control and Joint Objects

When generating a rig, Maya controls and joints are created based on the definitions provided by each module's setup, using data passed to the outputs.setup nested attributes.

• Controls are standard Maya transform nodes, with shapes parented underneath, if specified.

• Joints are native Maya joint nodes.

Generated objects are organized into dedicated subcontainers:

• Controls are placed inside the controls subcontainer.

• Joints are placed inside the joints subcontainer.

• If the rig uses the cycleFree setup method, two additional subcontainers, controlOperators and jointOperators, are created to store intermediate operator nodes.

By default, controls and joints are created as object hierarchies. You can also create them in a flattened structure by enabling the Flatten Controls and Flatten Joints options during rig creation.

Flattening can improve scene performance by reducing Maya's transformation stack evaluation. Even when flattened, hierarchical relationships are preserved because the transforms are fully driven by Bifrost.

Transform and Attribute Connections

When creating a rig, control and joint transforms are connected to the Bifrost graph both as input and output.

To drive Bifrost module transforms, control and joint objects feed their matrix attributes into the graph as an operator_matrix, and are simultaneously inheriting module output transforms (local_matrix or world_matrix) through their offsetParentMatrix attributes.

The way these connections are established depends on the Setup Method:

• In cycleFree mode, two Maya transforms are created per entity: an operator transform (used as input, for manipulation and keyframing), and a visible control or joint (used as output, for selection and visualization).

• In na`tive mode, a single transform is created per entity, connected both as input and output of the Bifrost graph.

Custom control attributes defined in modules are automatically created on controls during rig generation, and their values are connected to the Bifrost graph's input, allowing attributes to drive the logic inside the user_animation sub-compound.

• In cycleFree mode, attributes are created on the operator and mirrored onto the control as proxy attributes. Only the operator attributes are connected to the graph's inputs.
• In native mode, attributes are added to the control.

Working with a Synced Container

When generating a rig, you have the option to create it within a synced container. A synced container monitors changes made to modules within connected Bifrost graphs and automatically deletes and rebuilds the rig whenever a module's setup is recomputed.

This is especially useful during rig development, as it allow you to freely modify the rig structure, such as adding or removing modules, changing control shapes, adjusting parenting relationships, or altering the number of joints and controls.

All changes are applied in real time without requiring you to manually recreate the rig. However, synced containers should be used with care and are generally recommended only during rig development.

A synced container also lets you adjust rig creation settings directly from the Attribute Editor. Any changes to these attributes will trigger a full rig reconstruction.

The autoUpdate attribute controls whether automatic updates are performed. It is enabled by default when the rig is first created but will automatically be disabled when the scene is reopened, as a safety precaution. By extension, a synced container does not perform automatic updates when loaded as a reference.

Understanding Setup Methods

The setupMethod option defines how Maya objects are created and connected to the Bifrost graphs when generating a rig.

Each method offers a different balance between usability, evaluation predictability, and performance. The best choice depends on which aspect you prioritize for your project.

cycleFree

The cycleFree mode completely eliminates cyclic dependencies in the Maya scene, ensuring predictable evaluation and improved runtime performance. However, it disrupts the interaction behavior in Maya.

In this mode, each Bifrost transform generates two Maya nodes: an operator object that feeds its matrix into the graph as input, and a primary object (control or joint) that is driven by the graph’s output.

• The primary object (control or joint) is visible in the viewport and reflects the final evaluated transform, but it is not directly manipulatable. It primarily serves for visualization and selection.
• The operator object is invisible in the viewport but is manipulatable and keyframable. It drives the Bifrost graph and the corresponding primary object.

Because the selectable object (primary) and the manipulatable object (operator) are different, cycleFree relies on two mechanisms to ensure intuitive interaction:

• Selection Rerouting: When a primary object is selected, Maya automatically reroutes the selection to the corresponding operator, depending on the rerouting mode. This ensures that manipulation and keyframing always operate on the correct underlying node.
• Custom Manipulators: A special connection (manipulator message attribute) is established between operator and primary objects. When manipulating an operator, a custom manipulator is used, and its gizmo appears at the location of the corresponding primary object.

The selection rerouting behavior can be configured through the Bifrost Rigging menu, with three available modes:

• On Tool Active: Rerouting occurs only when a manipulator tool (Move, Rotate, Scale) is active.
• Always: Rerouting occurs whenever primary objects are selected, regardless of the current tool.
• Off: No automatic rerouting is performed.

The cycleFree mode is recommended for production rigs where evaluation predictability and performance are a priority, even if it disrupts interaction workflows compared to Maya’s default behavior.

native

In native mode, for each Bifrost transform, a single Maya object is created (either a control or a joint) that drives the Bifrost graph while being simultaneously driven by it.

This approach preserves Maya’s standard interaction behavior:

• The transform node is visible, selectable, manipulatable, and keyframable directly.
• No selection rerouting or custom manipulators are required.

However, because a single object is simultaneously driving and driven by the graph, the native mode introduces cyclic dependencies between nodes. These cycles are harmless but cause the evaluation to become non-deterministic. In the worst case, it may result in a 1-frame evaluation delay on affected transforms.

Additionally, the native mode introduces a small scene performance overhead due to extra matrix operations: inverseMatrix and multMatrix.

Since the transform inherits the final state from the Bifrost graph, its own matrix contribution must be canceled to prevent double transformation.

The native mode is recommended when maintaining Maya's traditional interaction and workflow is a priority, even if it comes at the cost of less predictable evaluation and increased runtime overhead.

Summary

The setup method should be chosen carefully, depending on whether you prioritize usability, evaluation behavior, or scene performance in Maya.

Notes on Performance

There are important considerations to ensure optimal scene performance when using Bifrost rigging modules in production.

Optimize Modules

Before using a rig for animation, it is strongly recommended to switch modules into their high-performance state.

This can be done automatically by using the Optimize Modules tool from the Bifrost Rigging menu or shelf, or manually by setting each module’s edit_mode and profile_evaluation parameters to false.

Disabling these features prevents unnecessary recomputation of module setups and significantly improves evaluation performance.

Module Terminals

Rigging modules provide a Diagnostics (D) terminal that can be used to quickly visualize generated data, such as pins, controls, joints, and their transforms.

While diagnostic terminals are helpful during rig development and debugging, they introduce significant performance overhead due to geometry generation and viewport drawing.

It is strongly recommended to disable all diagnostic terminals once a rig is finalized and ready for animation. You can quickly disable them across graphs by using the Disable Module Terminals tool from the Bifrost Rigging menu or shelf.

Flattening Controls and Joints

If you don't need to export the skeleton or don't require Selection Walking for control manipulation, enabling Flatten Controls and Flatten Joints can improve scene performance.

Flattening removes transform hierarchies in Maya, reducing the transformation stack evaluation overhead while still preserving logical hierarchies procedurally through the Bifrost graph.

Flattening is recommended for rigs with many objects and deep hierarchies, where transformation evaluation costs on the Maya side could become significant.

BifrostBoard versus bifrostGraphShape

Both bifrostBoard and bifrostGraphShape nodes can host rigging modules, but for optimal performance, it is strongly recommended to use bifrostBoard nodes.

• bifrostGraphShape nodes are designed primarily to provide direct viewport drawing and renderability of geometry. While powerful, this additional functionality introduces unnecessary overhead for rigging graphs.
• bifrostBoard nodes are simpler DG nodes without direct viewport outputs or extra draw overhead. They are better suited for rigging, where performance and lightweight evaluation are critical.

Breaking Rigs Into Multiple Graphs

As a general rule, it is preferable to do more work inside fewer Bifrost graphs rather than spreading it across many graphs. However, as rigs grow in complexity, it can sometimes be beneficial to split the rig into multiple Bifrost graph nodes.

Modules can still communicate across graphs through attribute connections on the Bifrost nodes. Although this introduces additional data translation overhead, splitting graphs can improve performance in certain cases by:

• Allowing Maya’s Evaluation Manager to parallelize graph evaluation more efficiently.
• Reducing update costs by limiting recomputation to only the affected parts of the rig.

It is not recommended to create one graph per module as this may increases overhead instead of reducing it. A better strategy is to group related body parts into different graphs. For example:

• One graph for the root, spine, neck, and head.
• One graph for the left arm, hand, and fingers.
• One graph for the right arm, hand, and fingers.
• One graph for the left leg and foot.
• One graph for the right leg and foot.