nanousd-labs is an experimental project published as part of NVIDIA Omniverse Labs that demonstrates how AI agents can generate purpose-built OpenUSD (USD) runtimes directly from the USD Core Specification. The core idea is to treat the formal, machine-readable specification as a contract: agents implement and test the behavior the standard requires instead of adapting a large existing codebase.
Why OpenUSD and why the Core Specification matter
OpenUSD is an extensible, open framework that provides a common scene description language for physical AI systems. It lets teams bring CAD data, simulation assets, and real-world telemetry into a shared, physically accurate view of the world. The USD Core Specification, maintained by the Alliance for OpenUSD (AOUSD), is a versioned standard that defines how USD data models are composed and resolved across layer stacks. Because the specification is precise and machine-readable, agents can be directed to produce exactly the behavior required by a workload.
The nanousd-labs methodology
nanousd-labs relies on the single principle that the Core Specification is the contract. Agents consume the spec section by section, generate code that implements specified behaviors, and validate outputs against a test suite derived from the same standard. This process is iterative: agents produce code, run the tests, and refine until the implementation meets the spec. Compliance is therefore a property of the workflow rather than of any single codebase.
In practice, agents handle the mechanical spec-to-code tasks—parsing, scene composition, and value resolution across layers—while engineers remain responsible for performance, trade-offs, and architecture. The approach does not claim full automation nor complete coverage of the entire specification today, but because the standard defines correct behavior precisely, each implementation task has a clear testable definition of correctness.
What is nanousd?
nanousd is an independent implementation of the USD runtime data model—the rules that determine how a USD scene behaves when loaded and queried—derived directly from the USD Core Specification. It is written in C++ and exposed via a stable C application binary interface (ABI), so any language can call its public C API.
nanousd is a data layer, not a renderer: it parses, composes, queries, and writes scene data, stopping before pixel generation. The intent is for the runtime to include only what a particular workload needs and to expose it through a stable C ABI so the backend implementation can be swapped without changing client code. This makes it possible to run the same client tests while swapping different backends to iterate toward the memory, ABI, or performance characteristics that fit a deployment.
Two ways to get started
Developers building physical AI pipelines who need a lightweight, purpose-built USD runtime have two entry points:
- Clone and build nanousd directly. That provides a compiled implementation with a C API ready to point at existing USD stages. Most users will start with nanousd-python, a Python package built on the nanousd C API; it runs headless on any machine and requires no GPU. Install it with:
python -m pip install -e ./nanousd-python
Examples in the project show opening a stage, traversing prims, reading attributes, assembling referenced assets, and animating time-sampled transforms. These examples illustrate how agents can be grounded in the Core Specification to author and validate stages.
- Learn and apply the methodology directly. The first time agents are instructed to build against the Core Specification, human-authored instructions are turned into reusable skills in a skill-graph. Structured recipes, prompts, and tests capture how to produce spec-compliant behavior. A roughly 10-minute tutorial walks through generating a USDA (ASCII) parser that meets part of the Core Specification, giving a starting point for further implementation. The skill graph is growing: it doesn’t yet generate everything, but it captures the durable workflow so teams don’t reinvent the process for each implementation.
Validation and authoring with agents
Agents can be asked to author a stage or validate an existing asset by composing files and checking resolved values against the spec. For example, an agent can ingest a warehouse stage with referenced parts and time-sampled animation, compose it via nanousd-labs to ensure it resolves correctly, and report the composed prim tree and any corrections it applied (for instance, noting when prims should be marked instanceable to enable scene-graph instancing).
Similarly, when given an exported robot.usda file, the agent composes it, walks the resolved scene, and returns exactly where and why the file diverges from the Core Specification along with the correct result according to the spec. This gives developers a clear compliance signal instead of relying on tool-specific interpretations.
Contribution and next steps
nanousd-labs is open and experimental: developers can contribute new skills, additional language bindings, and physical AI use cases on GitHub. Organizations that are AOUSD members can participate in the Core Spec Working Group and help shape the standard. The Core Specification is the durable foundation; nanousd-labs demonstrates an approach that becomes possible when agents are grounded in open standards.
Resources and upcoming events mentioned by the project include the USD Core Specification, the nanousd-labs repository, the Core Spec Working Group, the Learn OpenUSD learning path, and a Physical AI Day session at SIGGRAPH 2026.
