omniverse-labs

Map unfamiliar or multi-repository codebases before refactoring, integration, or feature work. Use when Codex needs to analyze submodules, ownership boundaries, APIs, duplicate implementations, build/test surfaces, risk areas, and a practical refactor sequence before changing code.

Coordinate multiple AI agents or subagents on software work without duplicating effort or causing conflicts. Use when Codex is explicitly asked to delegate exploration, implementation, review, testing, integration, or parallel analysis across a codebase.

Maintain C ABIs and language bindings as exact, testable contracts. Use when evolving public headers, ctypes/cffi/pybind/Rust/JS bindings, shared libraries, struct layouts, GPU/native APIs, or any cross-language boundary where drift can cause crashes or silent corruption.

Debug rendering, viewer, shader, material, camera, lighting, and GPU integration bugs with reproducible visual evidence. Use when scenes render blank, only appear after camera motion, show incorrect shading, diverge across backends, crash in GUI mode, or need pixel/screenshot verification.

Refactor disjoint or duplicated projects into clear layered architecture with canonical contracts and thin adapters. Use when viewers, renderers, bindings, data libraries, plugins, or services overlap and need maintainable ownership boundaries without losing behavior.

Identify and remove obsolete legacy, fallback, staging, compatibility, duplicate, generated, and reference code before creating clean initial commits or new project history. Use when a repo is being reset, consolidated, or prepared for a cleaner public history.

Load USD scenes through NanoUSD and convert composed USD prims into renderer-ready geometry, material, light, camera, transform, instancing, texture, and diagnostic representations. Use when implementing, debugging, or validating NanoUSD-based scene ingestion, renderer scene structs, material/light extraction, texture path resolution, or loader parity against USD/OpenUSD semantics.

Design, debug, or validate physically based renderer behavior against a reference renderer. Use when Codex works on PBR materials, USD light semantics, shadows, transparency, GI, emissive sampling, tone mapping, AOVs, stochastic sampling, path tracing, ray tracing, or Omniverse Kit/Hydra/OVRTX visual parity.

Make native builds, command-line tools, viewers, plugins, shaders, test harnesses, and packaged artifacts portable across working directories, install trees, copied build trees, users, and machines. Use when Codex works on CMake/install rules, RPATH/RUNPATH, dynamic library lookup, shader or asset discovery, CLI resource paths, packaging, deployment, or bugs that only reproduce outside the repo root.

Port an existing nanoUSD renderer to a new GPU backend or API (e.g. Vulkan to Metal, DX12, or WebGPU) or stand up a second backend behind the shared renderer contract. Use when Codex adds a backend, translates shaders and RHI calls across graphics APIs, decides what to share versus reimplement versus stub, keeps backends at ABI and feature parity, or hits cross-API transform, struct-alignment, command-encoder, or resource-residency pitfalls.

Define and govern the shared renderer C ABI and backend capability contract so multiple backends stay interchangeable and parity is machine-checked. Use when Codex designs or changes the public renderer header, adds a capability/AOV/entry point, reports what a backend supports versus stubs, or wires renderer ABI conformance into CI. Pairs with contract-first-ffi (general FFI hygiene) and renderer-feature-validation-matrix (per-feature status).

Build a renderer backend to a hard resource or capability budget — low VRAM, raster-only (no hardware ray tracing), or a portable/embedded GPU like OpenGL ES — where features must be baked, capped, or degraded rather than ported wholesale from the high-end backend. Use when Codex builds a low-end/portable backend, fits a GPU-memory budget, bakes materials instead of codegen, or makes a no-RT fallback match a reference renderer.

Create and maintain renderer feature validation matrices for correctness, performance, backend parity, and test coverage. Use when Codex plans renderer milestones, delegates subagent work, compares against Kit/Hydra/reference output, or decides whether a renderer feature is implemented, degraded, missing, or untested.

Share renderer output zero-copy across GPU APIs and runtimes (Vulkan↔CUDA, Metal/MPS, DLPack to Warp/PyTorch) and own GPU resource lifetime and teardown across that boundary. Use when Codex wires external-memory/-semaphore interop, hands a render target to a training/compute consumer without a CPU bounce, or debugs interop fd ownership, cross-API sync, double-buffered overlap, ARC/handle lifetime, or teardown-order crashes.

Design, implement, and run golden-image renderer comparison harnesses for graphics and viewer projects. Use when Codex needs to capture renderer output, compare Vulkan/OpenGL/Metal or other backends against golden images, refresh baselines, choose image-difference thresholds, wire tests into CI/CTest, handle display/GPU constraints, inspect visual diffs, or report residual risk for renderer correctness.

Sequence a nanoUSD renderer build from nothing into a correct, scalable backend using only the renderer skill set. Use when Codex starts a new renderer or backend, plans renderer milestones and phase order, decides what must be correct before the next layer, or needs the contracts-first build order and reduced-fixture corpus that turn the other renderer skills into a buildable plan with no reference renderer to copy from.

Design, review, or refactor high-performance renderer architecture for large USD scenes. Use when Codex needs to reason about target-quality/SOTA renderer architecture, instancing, batching, draw calls, frame-time budgets, geometry streaming, GPU buffer residency, texture/material upload, acceleration structures, shadows, forward/deferred render paths, readback, telemetry, performance validation, or replacing dead-end renderer paths.

Design real-time, headless, multi-camera renderers that produce reproducible sensor data for simulation and RL training. Use when Codex builds or reviews a renderer feeding a physics/RL loop (IsaacLab, Newton, MuJoCo), works on determinism/reproducibility, sensor AOVs (depth/segmentation/normals), multi-camera tiling, or the fidelity-versus-throughput target for a training sensor rather than an offline beauty render.

Keep host C/C++ structs and the shaders that read them byte-for-byte in sync — SSBO/UBO/push-constant layout, binding indices, and shared constants across GLSL/MSL/SPIR-V. Use when Codex adds or changes a struct shared between host code and a shader, wires descriptor/binding layouts, shares a push-constant block across pipelines, or debugs "wrong pixels with no crash" layout-drift bugs.

Drive a renderer from a physics/RL simulation loop (IsaacLab, Newton, MuJoCo) — per-step transform/visibility updates from physics state, time handling, frame pacing, and the consumer contract. Use when Codex integrates a renderer into a training/sim loop, plumbs physics transforms or time into the scene, or debugs bodies-render-at-origin, stale-frame, per-env update, or pacing problems.

Reset renderer/reference parity work when beauty images, scalar metrics, repeated local tweaks, or narrow target slices stop improving. Use when signed residuals stay structured, AOVs disagree with beauty, noise or denoising hides lighting/shadow detail, equal-spp comparisons are misleading, reference metadata is uncertain, or several exposure/material/light/denoiser/transport experiments have been rejected without progress.

Design renderer features from the target-quality architecture first, including radical subsystem replacement when incremental slices are exhausted. Use when Codex implements or plans path tracing, denoising, lighting, sampling, acceleration structures, scene residency, instancing, texture systems, material systems, render graphs, or major renderer features where state-of-the-art/proven production techniques are needed.

Plan and execute code changes with focused verification at each layer. Use when implementing fixes or refactors that need builds, tests, smoke runs, screenshots, logs, benchmarks, or clear residual-risk reporting before handoff.

Use to generate or densify an OpenUSD stage from sketch-stage inputs (bounds / scale / densification mode / asset pack / intent), with the LLM driving placement one object at a time through collision-gated spatial-query tools while the user watches a live 2D+3D browser viz. Trigger phrases include "generate a USD stage", "densify a scene", "fill an area with assets from <pack>", "scene generation with LLM", "watch placement live", "incremental placement", "absorb a USD as a sketch template".

Use this skill when presenting benchmark results that compare the generated skillgraph nanousd backend against nanousd's default backend or another baseline backend.

Use this skill when implementing or verifying a generated read-only backend for nanousd's C API.

Use this skill when implementing runtime stage-open orchestration for composed USD stages.

Use this skill when implementing or verifying the central composition arbitrator that forms composed prim and property opinion stacks before stage population.

Use this skill when implementing or verifying USD layer/spec/field storage.

Use this skill when implementing or verifying USD value storage independent of USDA syntax.

Use this skill when implementing or verifying USD identifier and name handling.

Use this skill when implementing or verifying the first inherits-composition namespace source backed by a composed base namespace source.

Use this skill when implementing or verifying the generic boundary that opens a resolved USD layer resource and dispatches it to a registered layer-format handler.

Use this skill when implementing or verifying the first composed namespace source backed by a root document-model layer and its already-opened recursive sublayers.

Use this skill when implementing or verifying recursive local sublayer loading from resolved layer resources into a layer-stack namespace source.

Use this skill when implementing authored list operation values as they appear in a single layer.

Use this skill when implementing or verifying USD path syntax, construction, and ordering.

Use this skill when implementing or verifying the first direct loaded payload opinion source backed by supplied payload arc sites and already-opened payload layers.

Use this skill when implementing or verifying the first reference-composition namespace source backed by a base namespace source and already-opened referenced layers.

Use this skill when implementing or verifying the first relocates-composition namespace source backed by a composed base namespace source.