[Question] Is there documentation on how to implement a custom manager?

[H-Hisamichi]

Hello everyone,

In this discussion, I learned about a custom curriculum function to accurately measure an actor's movement distance. I believe this new curriculum is accessed via the curriculum manager. However, in my manager-based workflow, I’m unsure how to register the new curriculum with the curriculum manager.
Is there any documentation or guidance on this?

Thank you!

[RandomOakForest]

Thanks for posting this. Here is a summary for a soon-to-be-posted show-and-tell discussion I'm still working on. Hope this helps.

To register a custom curriculum term with the curriculum manager in Isaac Lab's manager-based workflow, you'll need to define your curriculum logic as a callable (typically a function or a class with a call method). This callable is then wrapped in a CurriculumTermCfg object and registered within your environment configuration, under the curriculum manager's configuration dictionary.

Step-by-Step Guide

1. Define Your Custom Curriculum Function or Class

If you're calculating a specific metric (like accumulated actor travel distance), define it as a function or a class inheriting from ManagerTermBase. The callable should have a signature similar to existing curriculum terms:

def my_custom_curriculum(env, env_ids, **kwargs):
    # Your logic here (e.g., update curriculum based on recorded actor positions)
    return updated_value

2. Create a CurriculumTermCfg Instance

Wrap your function/class in a CurriculumTermCfg (from isaaclab.managers), passing required params:

from isaaclab.managers import CurriculumTermCfg

my_curriculum_term = CurriculumTermCfg(
    func=my_custom_curriculum,
    params={
        "arg1": value1,
        "arg2": value2,
        # add any parameters needed for your curriculum function
    }
)

3. Register the Curriculum Term with the Curriculum Manager

In your environment configuration (usually a subclass of ManagerBasedRLEnvCfg), add your custom curriculum term to the curriculums block/dictionary. For example:

from isaaclab.managers import CurriculumCfg

class MyEnvCfg(ManagerBasedRLEnvCfg):
    # ... your config ...
    curriculum_manager = CurriculumCfg(
        enabled=True,
        terms={
            "my_custom_metric": my_curriculum_term
            # you can add other curriculum terms here as needed
        }
    )

When the environment is instantiated with this config, the curriculum manager will register and execute your custom curriculum term alongside any others.

4. Typical Usage Pattern

env_cfg = MyEnvCfg()
env = ManagerBasedRLEnv(cfg=env_cfg)

The curriculum_manager will automatically detect and use the listed terms during training¹.

Key Details

• The registration mechanism for curriculum terms is always via the terms dictionary in the curriculum manager's config¹².
• Terms are instances of CurriculumTermCfg where each term provides the curriculum function and its parameters.
• You do not need to call any explicit register or initialization code beyond including your term in the config—Isaac Lab's manager system loads and registers terms from config dictionaries at environment construction¹.

Example YAML/Python config snippet (abbreviated):

curriculums = {
    "travel_distance_curriculum": CurriculumTermCfg(
        func=my_travel_distance_curriculum_fn,
        params={"some_param": 42}
    )
    # ... add additional terms if needed ...
}

Your curriculum manager will now call your function at each curriculum update interval as specified in the manager-based workflow¹².

Footnotes

1. https://isaac-sim.github.io/IsaacLab/main/source/how-to/curriculums.html ↩ ↩² ↩³ ↩⁴

2. https://isaac-sim.github.io/IsaacLab/main/source/api/lab/isaaclab.envs.mdp.html#module-isaaclab.envs.mdp.curriculums ↩ ↩²

[H-Hisamichi]

Hello @RandomOakForest,

Thank you for providing the detailed documentation.
I have a question, what is "CurriculumManagerCfg"? It wasn’t found in the source code, so do I need to code it from scratch?

[Mayankm96]

@H-Hisamichi I think there's a typo above. It is the same as CurriculumCfg in the codebase. Please check the locomotion example to see how a curriculum term is specified:

https://github.com/isaac-sim/IsaacLab/blob/main/source/isaaclab_tasks/isaaclab_tasks/manager_based/locomotion/velocity/velocity_env_cfg.py#L277-L303

[H-Hisamichi]

Hello @RandomOakForest , @Mayankm96 ,

Thank you for your advice.
I'm currently working on the implementation, but I have a question about the implementation method for step 3.
The work I've done so far is as follows:

1. Implementation of the custom manager class (isaaclab/managers/traveled_distance_recorder_manager.py)
2. Implementation of the custom curriculum MDP (mdp/curriculums.py)

from __future__ import annotations

import torch
from collections.abc import Sequence
from typing import TYPE_CHECKING

from isaaclab.assets import Articulation
from isaaclab.managers import SceneEntityCfg
from isaaclab.terrains import TerrainImporter

if TYPE_CHECKING:
    from isaaclab.envs import ManagerBasedRLEnv

def terrain_levels_travel_dist(
    env: ManagerBasedRLEnv, env_ids: Sequence[int], asset_cfg: SceneEntityCfg = SceneEntityCfg("robot")
) -> torch.Tensor:
    # get the traveled distance from "TraveledDistanceRecorder"
    dist_recorder = env.managers("traveled_distance_recorder")
    distances = dist_recorder.get_episode_travel_dist(env_ids)
    #distances = env.curriculum_manager.get_episode_travel_dist(env_ids)
    
    # terrain management objects
    terrain: TerrainImporter = env.scene.terrain
    command = env.command_manager.get_command("base_velocity")
    
    # difficulty updates based on distance traveled
    move_up = distances > terrain.cfg.terrain_generator.size[0] / 2
    move_down = distances < torch.norm(command[env_ids, :2], dim=1) * env.max_episode_length_s * 0.5
    move_down *= ~move_up
    
    # terrain level updates
    terrain.update_env_origins(env_ids, move_up, move_down)
    return torch.mean(terrain.terrain_levels.float())

3. Specification of the custom curriculum (locomotion/velocity/velocity_env_cfg.py)

class CurriculumCfg:
    """Curriculum terms for the MDP."""

    terrain_levels = CurrTerm(func=mdp.terrain_levels_travel_dist)

I believe step 3 is necessary to register the custom manager class from List 1 to the environment, but I have not been able to understand the specific implementation method.

[RandomOakForest]

Thank you for following up. I will defer further advice to @Mayankm96. I'm going to move this post to our discussions for follow up.

[H-Hisamichi]

Hello @Mayankm96,

I've been tinkering with the implementation and came up with one idea.
What do you think about implementing this Custom Manager Class as a Recorder and making it accessible from the curriculum manager?
That said, with this approach, I believe we'd need to disable the Recorder's log export functionality.

I'll give this a try, but if you have any advice, please let me know!