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.
Scan	Signals gathered from one walk of the config tree (see scan()).
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.
report_activity(activity)	Report what the startup path is doing right now.
scan(cfg[, launcher_args])	Walk cfg once, collecting all launch signals and applying --physics.

Simulation Launcher

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

Context manager that launches the appropriate simulation runtime for cfg.

Walks the config tree once (resolving --physics, validating the physics/renderer/visualizer combination, and deciding whether Isaac Sim Kit is needed), then starts the launcher each required runtime’s config names (closed on exit) or does nothing for kitless ones. Cameras are auto-enabled for Kit-renderer sensors.

Yields the resolved physics config, so a script can pass a bare placeholder and pick the backend from the command line:

with launch_simulation(PhysicsCfg(), args_cli) as physics_cfg:
    sim = SimulationContext(SimulationCfg(physics=physics_cfg))

Callers that do not need the value simply omit as.

Parameters:

• cfg – Config tree to scan for 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: "physx" (Isaac Sim PhysX when Kit is required, else OvPhysX), "isaacsim_physx", "newton_mjwarp", "newton_vbd", or "ovphysx".

  • 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.

  • visualizer_intent: Visualizer intent the config cannot express, e.g. {"has_kit_visualizer": True}; it is combined with the intent of cfg.

isaaclab.app.add_launcher_args(parser: ArgumentParser) → None

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

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)

Start the runtime.

Parameters:

launcher_args – Parsed launcher arguments.

close(exit_code: int = 0) → None

Stop the runtime.

Parameters:

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

class isaaclab.app.AppLauncher

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)

static add_app_launcher_args(parser: ArgumentParser) → None

Add the launcher arguments, see add_launcher_args().

isaaclab.app.scan(cfg, launcher_args: Namespace | dict | None = None) → Scan

Walk cfg once, collecting all launch signals and applying --physics.

When the physics key is present in launcher_args, every physics config is replaced by the requested backend (see launch_simulation()): nested configs in place, a root config via Scan.effective_cfg (it cannot be mutated in place). Automatic PhysX configurations and RTX renderer placeholders (renderer_type="auto_rtx") are also resolved at this stage using the full launcher_args context.

The walk mutates cfg in place, and resolving a placeholder consumes it, so a second walk of the same config observes the same signals and reaches the same launch decision.

class isaaclab.app.Scan

Signals gathered from one walk of the config tree (see scan()).

Every field starts as a plain snapshot computed during that single walk. Automatic PhysX configurations and RTX placeholders are also recorded so launch-time resolution can update the physics- and renderer-related fields without traversing the config tree again. needs_kit is the headline launch decision after automatic selections are resolved: a Kit-renderer camera or Isaac Sim PhysX requires Kit (the launcher additionally forces Kit when --visualizer kit is requested).

Methods:

__init__(resolved_physics_cfg, ...[, ...])

__init__(resolved_physics_cfg: ~isaaclab.physics.physics_manager_cfg.PhysicsCfg | None, effective_cfg: ~typing.Any, visualizer_intent: dict[str, bool], has_ovrtx: bool, has_kit_camera: bool, has_kit_physics: bool, has_ovphysx_physics: bool, needs_kit: bool, launcher_types: list[str] = <factory>) → None

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

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.

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

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

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)

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).