APIs and build system#

Isaac Sim 7.0.0a1 libraries expose public C, C++, and Python APIs. Call a library directly to use its full API, or use the OV SIM client API when the same simulation code must support in-process and distributed deployments.

Supported API languages#

Not every module exposes every language. Each module page lists the languages available for that module and links to its generated API reference.

Language

How it is provided

How it is consumed

C

Public C11 headers and exported functions from a shared library. Modules that promise a stable C ABI maintain an explicit exported-symbol baseline.

Include the installed .h headers and link the module’s imported CMake target from the distribution SDK.

C++

Public C++17 headers backed by a compiled or header-only module.

Use find_package(<distribution> CONFIG REQUIRED), include the installed .hpp headers, and link an isaacsim:: imported target.

Python

A typed pure-Python implementation, a nanobind binding over a native module, or a facade that combines both.

Install the distribution wheel and import its public leaf module from the shared isaacsim namespace.

For example, a C++ consumer can locate a distribution and link one of its modules without depending on its source tree:

find_package(isaacsim_common CONFIG REQUIRED)
target_link_libraries(application PRIVATE isaacsim::common-logging)

A Python consumer imports the public module directly:

from isaacsim.foundation.objects import Cube, Stage

The library inventory links to the consolidated C and C++ API and Python API indexes.

Python bindings with nanobind#

Native modules expose Python APIs with nanobind. A module keeps its binding definition under bindings/python and registers it with isaacsim_add_nanobind after registering the native target. The build helper:

  • compiles a private bindings._bindings extension;

  • uses the CPython stable ABI unless the module records an explicit exception;

  • stages the native shared-library closure required by the binding;

  • generates a _bindings.pyi stub from the compiled extension; and

  • installs the extension, stub, and authored py.typed marker with the module’s Python package.

The private extension is an implementation detail. A module’s public __init__.py facade re-exports the supported names, so users import the documented isaacsim.<distribution>.<module> path rather than importing bindings._bindings. Richer Python behavior and annotations can live in ordinary Python wrappers around the native operations.

Direct library APIs and the OV SIM API#

The direct and OV SIM surfaces serve different integration needs:

Characteristic

Direct library API

OV SIM client API

Surface

The complete public API owned by a particular library module.

A common simulation interface for authoring, control, and data access.

Access

Include and link a C or C++ module, or directly import its Python module.

Create a client with isaacsim.ovsim.api.make_client or the C++ makeClient factory.

Execution boundary

Calls the selected library in the application’s process.

Selects an in-process implementation or a remote gRPC session without changing the calling interface.

Best suited for

Feature-specific functionality, native types, and direct composition of libraries in one process.

Code that must move between local execution and a distributed simulation service, or that needs a deliberately transport-neutral boundary.

Use a direct import when your application needs a library’s full API. The OV SIM API defines a smaller, common client contract so orchestration code can use the same control logic whether the simulation runs locally or remotely.

OV SIM client structure#

make_client returns the same interface for both available client implementations:

  • control.authoring creates, opens, saves, imports, exports, and closes USD stages; defines and edits prims and attributes; and exchanges provider-specific authoring parameters.

  • control.simulation plays, pauses, stops, initializes, invalidates, and manually steps a simulation. It also exchanges provider-specific simulation parameters.

  • data reads and writes named attributes for one or more prim paths, with an optional time value.

Select "in-process" or its "local" alias to call the local provider in the current process. Select "grpc" and provide an endpoint to connect to an OV SIM server in another process or on another machine:

from isaacsim.ovsim.api import make_client

client = make_client("in-process")
remote_client = make_client("grpc", {"endpoint": "127.0.0.1:50051"})

client.control.authoring.create_stage()
client.control.simulation.initialize()
client.control.simulation.step()
values = client.data.read("/World/Cube", "xformOp:translate")

The C++ contract defines function signatures shared by the client implementations. Compile-time checks verify that the local provider implements those signatures. The gRPC client translates the same calls through the OV SIM protocol to a hosted simulation server. The Python API is a nanobind facade over the C++ factory and exposes the same authoring, simulation, and data groups.

The API is designed around providers. Common operations have a fixed shape, while set_parameter and get_parameter allow a selected provider to expose capabilities that are not yet part of the common contract. Because the libraries are still in alpha, the common interface and its package boundaries can evolve between milestones.

Build system#

source/libraries is a standalone CMake project. build.sh on Linux and build.bat on Windows provide the supported entry points. They bootstrap the repository-pinned tools, prepare dependencies, configure a CMake preset, and drive compilation, tests, SDK packaging, and wheel assembly. The root CMakeLists.txt explicitly adds each distribution; distribution and module directories are never discovered implicitly.

Shared CMake helpers define the supported module shapes:

  • isaacsim_add_module builds a compiled C and/or C++ shared library.

  • isaacsim_add_header_module defines a header-only native module.

  • isaacsim_add_python_module stages a typed pure-Python module.

  • isaacsim_add_nanobind adds Python bindings to a registered native module.

  • isaacsim_add_usd_schema_module generates and packages a USD schema.

  • isaacsim_add_group registers an independently installable distribution and its exact module inventory.

CMake owns compiled targets, installed headers and libraries, runtime closure, install components, and the native SDK package configuration. A distribution’s pyproject.toml owns its Python project metadata. Wheel assembly installs the already-built distribution’s Python component into a staging directory and packages that payload without configuring or compiling CMake again.

Dependency model#

Dependencies are declared at the layer that consumes them:

Dependency type

Authoritative declaration

Contract

Toolchain and public build dependencies

Root pixi.toml and pixi.lock

Pin the reproducible Python, CMake, Ninja, binding, test, and public native build environment used by the standalone build.

Private or patched native dependencies

deps/isaacsim-libraries.packman.xml

Install into the isolated library dependency root and remain separate from the Isaac Sim application dependency graph.

Native target dependencies

Each module’s CMakeLists.txt

PUBLIC_DEPENDENCIES propagate through public headers, PRIVATE_DEPENDENCIES remain implementation details, and PACKAGE_DEPENDENCIES are located by an installed CMake package.

Isaac Sim distribution dependencies

isaacsim_add_group_dependency

Permit cross-distribution target links and require the exact shared version from source/libraries/VERSION.

External Python runtime dependencies

[project.dependencies] in pyproject.toml

Declare supported PEP 508 ranges that become wheel Requires-Dist metadata.

Internal Python distribution dependencies

The shared dynamic metadata provider configured by pyproject.toml

Convert named internal dependencies into exact requirements at the shared version, such as isaacsim-common==7.0.0a1.

Language and tool requirements

source/libraries/system_requirements.toml

Define the repository-wide C, C++, Python, and CMake version contract.

CMake consumes prepared dependencies and does not download them during configuration. Configure-time validation rejects undeclared cross-distribution links and inconsistent package metadata. Install-contract and wheel tests then verify that dependencies, versions, public headers, native targets, Python imports, and typing information remain valid after relocation.