Rez Package Manager

A context bundle is a relocatable, standalone directory containing a Rez context (an .rxt file) and a local package repository.

Unlike a standard context that uses absolute references to shared package repositories on disk, a bundle stores all required packages within its own ./packages directory. This makes bundles ideal for:

• Copying to remote servers.
• Including in containers.
• Ensuring no external dependencies on shared network storage.

Rez is a cross-platform package manager designed to create standalone environments configured for a specific set of packages.

Unlike traditional package managers that install package files directly into an environment, Rez uses a central repository where all package versions are stored. When you create an environment, Rez dynamically constructs it by resolving dependencies and referencing the existing packages in the central repository.

Key Benefits:

• Lightweight Environments: Environments are not heavy copies of files; they are configurations that reference a central store.
• Speed: Because environments are constructed via references rather than file copies, they can be created in seconds, even when containing hundreds of packages.
• Versatility: Rez supports various software types, including compiled binaries, Python packages, applications, and libraries.

A context is a lightweight JSON-formatted store (with the .rxt extension) that represents a resolved environment. Instead of storing actual package files, a context stores handles that allow Rez to fetch package definitions and contents.

A context includes:

• The initial list of requested packages.
• The resolve (the specific list of variants chosen during resolution).
• A visual graph of the resolve.

When you run rez-env, Rez creates a temporary context file on disk. You can find the path to this file in the $REZ_RXT_FILE environment variable.

$ rez-env foo bah

> $ echo $REZ_RXT_FILE
/tmp/rez_context_0tMS4U/context.rxt

A package is a self-contained, versioned piece of software. Every package must include a definition file, typically named package.py, located at the root of the package installation directory. This file describes the package's metadata, dependencies, and how it modifies the environment.

Common attributes in package.py include:

• name: The package name.
• version: The version string.
• requires: A list of package dependencies (e.g., "python-2.6").
• tools: A list of tools provided by the package.
• commands(): A Python function that defines environment modifications.

name = "foo"
version = "1.0.0"
description = "Something that does foo-like things."
requires = [
   "python-2.6",
   "utils-1.1+<2"
]
tools = [
   "fooify"
]

def commands():
    env.PYTHONPATH.append("{root}/python")
    env.PATH.append("{root}/bin")

The tools available in a suite context are determined by the tools attribute in the package's package.py file.

Important Note on Dependencies: Only packages listed in the context requests (that are not weak or conflict requests) have their tools exposed. Packages pulled in as dependencies do not. If you need to control the version of a package without exposing its command-line tools, add it as a weak reference to the request list.

You can explicitly hide tools using the rez-suite --hide argument during suite creation.

# in maya package.py
tools = [
   "maya",
   "mayapy",
   "fcheck"
]

The Rez Python API is available for programmatic interaction with Rez, but users should be aware of the following constraints:

• No Compatibility Guarantees: There are no guaranteed compatibility guarantees between different versions of Rez. Code written for one version may break in another.
• Configuration Limitations: The Python API does not support rereading configuration files or switching to new configuration files once the API has been initially imported. If your workflow requires dynamic configuration reloading, use the Rez CLI instead.

All configuration settings support the following string expansions:

• Environment Variables: Using the ${VAR_NAME} syntax (e.g., ${HOME}).
• System Properties: Using the {system.property} syntax (e.g., {system.platform}).

Rez uses a solving algorithm that converts a request (a list of package requests) into a resolve (a final list of specific package versions).

Key behaviors of the solver:

1. Goal: It aims to provide the latest possible version of each package.
2. Conflict Avoidance: It avoids version conflicts (ensuring no two different versions of the same package are present simultaneously).
3. Constraint Satisfaction: If the latest version of a package causes a conflict with another dependency, the solver will automatically try the next latest version to find a valid solution.
4. Failure: If no combination of versions can satisfy the request without conflict, the resolve fails and Rez reports the conflict.