isaaclab.app#

Sub-package containing app-specific functionalities.

These include:

  • Ability to launch the simulation app with different configurations

  • Run tests with the simulation app

Classes

AppLauncher

Start Isaac Sim / Kit for scripts that have not moved to launch_simulation().

LoadingScreen

Staged progress display that owns the console while a run starts up.

SimulationLauncher

Starts the process runtime a resolved simulation config requires, and stops it.

Functions

add_launcher_args(parser)

Add simulation-launcher CLI arguments (--device, --viz, etc.) to parser.

launch_simulation(cfg[, launcher_args])

Context manager that launches the appropriate simulation runtime for cfg.

validate_launch(cfg[, launcher_args])

Prepare configured consumers and reject incompatible runtimes without starting them.

report_activity(activity)

Report what the startup path is doing right now.

Simulation Launcher#

isaaclab.app.launch_simulation(cfg, launcher_args: Namespace | dict | None = None) → Generator[PhysicsCfg | None, None, None][source]#

Context manager that launches the appropriate simulation runtime for cfg.

Resolves configured consumers before starting their required runtimes. Each runtime starts once and closes on exit. Cameras are auto-enabled for Kit-renderer sensors.

Resolve viewer and physics choices on the same config used to construct the simulation:

sim_cfg = SimulationCfg()
with launch_simulation(sim_cfg, args_cli):
    sim = SimulationContext(sim_cfg)

Yields the resolved physics config when a caller needs to adjust solver settings before construction.

Parameters:
  • cfg – Concrete config tree declaring backend, renderer, and sensor requirements.

  • launcher_args –

    Parsed launcher arguments, typically the script’s args_cli. Besides the arguments added by add_launcher_args(), the following keys are read when a script contributes them:

    • physics: Backend selector applied to every physics config in cfg.

    • require_kit: Whether the caller needs Kit for a reason cfg cannot express, e.g. a tool that reaches a Kit-only extension API. This is additive – it can only turn a kitless launch into a Kit one, never the reverse, so a config that already needs Kit still launches it when the key is absent or False.

isaaclab.app.validate_launch(cfg, launcher_args: Namespace | dict | None = None) → tuple[tuple[Any, ...], tuple[str, ...]][source]#

Prepare configured consumers and reject incompatible runtimes without starting them.

Applies launcher selections and resolves automatic physics/renderer configurations in place. Task-run enumeration and launch_simulation() use this same preparation step.

Parameters:
  • cfg – Configuration tree declaring physics, renderers, visualizers, and recorders.

  • launcher_args – Parsed launcher arguments; derived runtime options are written back.

Returns:

Resolved runtime configurations and the components requiring Isaac Sim / Kit.

Raises:

ValueError – If selections are invalid or configured runtimes cannot share one process.

isaaclab.app.add_launcher_args(parser: ArgumentParser) → None[source]#

Add simulation-launcher CLI arguments (--device, --viz, etc.) to parser.

The arguments are defined by the Kit launcher, which consumes most of them.

class isaaclab.app.SimulationLauncher[source]#

Starts the process runtime a resolved simulation config requires, and stops it.

A backend package subclasses this and names the subclass in its config’s launcher_type. launch_simulation() constructs it, which starts the runtime, and calls close() when the simulation ends.

Attributes:

device

Simulation device chosen by the runtime, or None to keep the config's device.

Methods:

__init__([launcher_args])

Start the runtime.

close([exit_code])

Stop the runtime.

device: str | None = None#

Simulation device chosen by the runtime, or None to keep the config’s device.

__init__(launcher_args: Namespace | dict | None = None)[source]#

Start the runtime.

Parameters:

launcher_args – Parsed launcher arguments.

close(exit_code: int = 0) → None[source]#

Stop the runtime.

Parameters:

exit_code – Exit status of the simulation, for runtimes that end the process.

class isaaclab.app.AppLauncher[source]#

Start Isaac Sim / Kit for scripts that have not moved to launch_simulation().

Deprecated since version Use: add_launcher_args() and with launch_simulation(cfg, args_cli):, which start only the runtime the config needs.

Methods:

__init__([launcher_args])

add_app_launcher_args(parser)

Add the launcher arguments, see add_launcher_args().

__init__(launcher_args: Namespace | dict | None = None, **kwargs)[source]#
static add_app_launcher_args(parser: ArgumentParser) → None[source]#

Add the launcher arguments, see add_launcher_args().

Seasonal loading greetings#

The loading screen includes bundled default greetings that work offline. Seasonal greetings are selected by greetings/manifest.json in the nvidia/isaaclab-docs-assets dataset on Hugging Face. Each greeting pairs 24 by 12 and 74 by 12 terminal cell variants; resizing keeps the selected artwork family. Each variant contains one static ANSI frame string, with cols and rows specifying its dimensions.

Startup reuses validated cached greetings immediately and refreshes them in the background. The cache lives under isaaclab/greetings/ in XDG_CACHE_HOME, then LOCALAPPDATA if the former is unset, or ~/.cache otherwise, with separate entries for each greeting source URL. If no cache directory can be resolved, remote greetings are disabled and bundled artwork is used. Unavailable or invalid remote data leaves bundled defaults or usable cached greetings in place. Selecting the default collection uses bundled artwork without downloading remote greeting assets.

Set ISAACLAB_REMOTE_GREETINGS=0 to use bundled artwork without remote requests or greeting cache access.

Maintainers can change the calendar without an Isaac Lab release by editing greetings/manifest.json in the dataset’s main branch. Dates use UTC globally, include both endpoints, and are reevaluated at each startup, including when using a cached catalog. Event IDs must be unique, collections must exist in the catalog, and date windows must not overlap. Outside those windows, active_collection applies; keep it set to default for the bundled greetings. For example, the catalog’s schedule object can contain:

{
  "timezone": "UTC",
  "events": [
    {
      "id": "christmas-2027",
      "collection": "christmas",
      "start": "2027-12-20",
      "end": "2027-12-27"
    }
  ]
}

Additional Public Classes#

The following classes are part of the public isaaclab.app API.

LoadingScreen

Staged progress display that owns the console while a run starts up.

SettingsManager

A settings manager that provides a carb.settings-like interface without requiring Omniverse.

class isaaclab.app.LoadingScreen[source]#

Bases: object

Staged progress display that owns the console while a run starts up.

While the screen is open, the startup path writes to standard output and error are spooled to a temporary file instead of the console, so they cannot break the progress bar. POSIX also captures native writes to the underlying file descriptors; Windows and macOS preserve their console descriptors and capture Python-level output. Alongside the bar the screen shows the step currently running, as reported by report_activity(), and a clock that keeps ticking through long silent steps. The spool is replayed when startup fails and dropped when it succeeds. Closing the screen hands the console back, so whatever runs next (typically an RL library’s training log) prints undisturbed.

While active, the context replaces builtins.input() process-wide. An interactive prompt restores normal output and replays captured context before waiting for input. Later stages and summaries use plain console output.

The screen degrades to plain stage lines, with no redirection, when it is disabled – for a non-interactive console or a verbose run – so nothing is hidden from a captured log.

Example:

with LoadingScreen(2) as screen:
    screen.summary("Isaac Lab", {"Task": task})
    screen.stage("Launching simulation")
    ...
    screen.stage("Creating environment")
    ...
    screen.close()

Methods:

__init__(num_stages, *[, enabled, logo])

Initialize the screen.

__new__(*args, **kwargs)

__init__(num_stages: int, *, enabled: bool | None = None, logo: bool = True) → None[source]#

Initialize the screen.

Parameters:
  • num_stages – Number of stages the progress bar counts up to.

  • enabled – Whether to draw a live progress bar and spool startup output. Defaults to None, which enables both when standard output is a terminal.

  • logo – Whether summary() shows a responsive greeting beside the run summary. Defaults to True.

classmethod __new__(*args, **kwargs)#
class isaaclab.app.SettingsManager[source]#

Bases: object

A settings manager that provides a carb.settings-like interface without requiring Omniverse.

This class can work in two modes: - Standalone mode: Uses a Python dictionary to store settings - Backed mode: Delegates to the backend given to set_backend()

The interface is designed to be compatible with the carb.settings API.

This is implemented as a singleton to ensure only one instance exists across the application, even when used in different execution contexts (e.g., Hydra). The singleton is stored in sys.modules to survive module reloads.

Methods:

__new__(cls)

Singleton pattern - always return the same instance, stored in sys.modules to survive reloads.

__init__()

Initialize the settings manager (only runs once due to singleton pattern).

static __new__(cls)[source]#

Singleton pattern - always return the same instance, stored in sys.modules to survive reloads.

__init__()[source]#

Initialize the settings manager (only runs once due to singleton pattern).