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 |
C++ |
Public C++17 headers backed by a compiled or header-only module. |
Use |
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 |
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._bindingsextension;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.pyistub from the compiled extension; andinstalls the extension, stub, and authored
py.typedmarker 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 |
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.authoringcreates, opens, saves, imports, exports, and closes USD stages; defines and edits prims and attributes; and exchanges provider-specific authoring parameters.control.simulationplays, pauses, stops, initializes, invalidates, and manually steps a simulation. It also exchanges provider-specific simulation parameters.datareads 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_modulebuilds a compiled C and/or C++ shared library.isaacsim_add_header_moduledefines a header-only native module.isaacsim_add_python_modulestages a typed pure-Python module.isaacsim_add_nanobindadds Python bindings to a registered native module.isaacsim_add_usd_schema_modulegenerates and packages a USD schema.isaacsim_add_groupregisters 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 |
Pin the reproducible Python, CMake, Ninja, binding, test, and public native build environment used by the standalone build. |
Private or patched native dependencies |
|
Install into the isolated library dependency root and remain separate from the Isaac Sim application dependency graph. |
Native target dependencies |
Each module’s |
|
Isaac Sim distribution dependencies |
|
Permit cross-distribution target links and require the exact shared
version from |
External Python runtime dependencies |
|
Declare supported PEP 508 ranges that become wheel |
Internal Python distribution dependencies |
The shared dynamic metadata provider configured by |
Convert named internal dependencies into exact requirements at the
shared version, such as
|
Language and tool requirements |
|
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.