Generated banner for Omniverse Usd Performance Tuning
Generated logo for Omniverse Usd Performance Tuning

Omniverse Usd Performance Tuning

NVIDIAOfficialCreated by NVIDIA Omniverse

  • Skill
  • Workflow
  • Software development
  • Apache-2.0
  • Medium risk
  • Has scripts

From the author

Diagnose and optimize USD stages for slow loading, high memory, low FPS or validation; preserve asset boundaries and reuse shared definitions.
— the description by NVIDIA Omniverse

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill provides a structured workflow for diagnosing and optimizing USD stages. It focuses on improving performance metrics like load times, memory footprint, and frame rates by identifying and optimizing unique asset definitions, reusing shared definitions, and pruning unnecessary data. The process emphasizes preserving original asset boundaries, animation, and interface requirements, ensuring that downstream applications remain functional after optimization.

What it does

  • Inspects USD stages to identify performance bottlenecks and structural inefficiencies.
  • Classifies assets into atomic, package, or aggregate structures to guide optimization.
  • Performs native USD optimization operations on disjoint scopes.
  • Publishes semantic libraries to enable efficient asset reuse.
  • Validates composition, ownership, and interface accessibility of the optimized output.
  • Profiles the final output against the original baseline to report measured improvements.

When to use it

  • When a USD stage suffers from slow loading times or high memory consumption.
  • When rendering performance (FPS) needs improvement in a production environment.
  • Before finalizing a USD assembly for downstream consumption.
  • When you need to standardize asset structures according to factory-level guidelines.

Advantages

  • Maintains asset boundaries and critical metadata during optimization.
  • Reduces scene complexity through intelligent reuse of shared definitions.
  • Provides verifiable reports on performance gains and composition integrity.
  • Supports large-scale scene optimization by processing independent definition scopes.

Usage examples

“Inspect the USD stage at /data/factory.usdc for performance issues and prepare a review workspace.”
The agent initializes the workspace, runs the inspection script, and provides a summary of candidates for optimization.
“Submit the optimization decisions for the factory stage based on the generated JSON.”
The agent processes the boundary decisions, executes the optimization operations, and generates the final optimized USD assembly.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/nvidia/omniverse-usd-performance-tuning/download
  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip omniverse-usd-performance-tuning.zip -d .agents/skills

Documentation by NVIDIA Omniverse

Omniverse USD Performance Tuning

Purpose

Improve loading, memory use or rendering for the requested workload. Preserve the prim paths, appearance, placement and behavior required by downstream applications. Follow the component/subcomponent model in NVIDIA's Factory-Level USD Structuring guide. Apply the relevant parts of that model; a static asset does not need new animation or physics.

Inputs

Required: the source USD stage. When no workload is specified, use factory layout planning and visualization and record that assumption in the request/report. Explicit workload and preservation requirements take precedence. Optional: an output workspace, preservation requirements, physical error budget, existing library indexes and recorded runtime evidence. Use values from the current user request; reuse recorded values only while they remain applicable. Follow setup when no output path is supplied.

Prerequisites

Verify the selected runtime and required capabilities using setup. Keep its preflight record with the run; installation and remote access are conditional steps described there.

Instructions

  1. Inspect. Establish the workload, preservation requirements and output workspace. Set up progress and dashboard access before assessment. Verify setup and inspect the selected source configuration.

  2. Judge boundaries. Review equipment, service-system sections and architectural elements in the selected configuration, including animation and interiors. Record owners, editable interfaces, equipment categories and optional families using boundary guidance.

  3. Classify and author. Classify accepted assets children before parents. Capture or reuse the original profile before authoring. Prepare reusable definitions, materials and occurrence opinions using asset authoring.

  4. Optimize unique definitions. Run supported native operations concurrently on disjoint scopes with the recorded physical budget.

  5. Publish semantic libraries. Use one writer per category layer and remap consumer references.

  6. Check composition. Check authored ownership, references, bindings, placement, animation and interface accessibility through the written-output checks.

  7. Profile and report. Compare the final consumer with the original baseline under comparable conditions and report measured benefits, completion and operations by asset definition.

sequenceDiagram
    participant A as Agent
    participant T as USD tools
    participant W as Definition workers
    participant L as Library publisher
    participant D as Read-only progress dashboard
    Note over A,L: One compact progress state also renders text progress
    T-->>D: Recorded phase, assessment rounds, counters and decision reasons
    A->>T: Inspect original selected configuration
    T->>T: Collect cached child-to-parent summaries and repetition nominations
    T->>T: Load supplied indexes once and batch authored product clues
    T-->>A: Product review groups, member context, animation and reuse evidence
    loop Until boundaries and interiors are reviewed
        A->>A: Select asset boundaries, then identify required internal prims and properties
        A->>T: Submit boundary decisions with reviewed scope, required edits, category and optional family
        T->>T: Reuse unchanged source evidence, recompute boundary-dependent results
        opt Geometry ownership requires reconstruction
            T->>T: Regroup or native split, remap paths and reassess affected regions
        end
        T-->>A: Remaining candidates and member exceptions
    end
    T->>T: Classify selected child assets before parent assets, confirm reuse
    T->>T: Capture or reuse original baseline profile
    T->>T: Confirm accepted product identities from source and supplied indexes; reconcile complete parent-child groups
    T->>T: Skip worker inputs for confirmed groups; author remaining materials, editable prims and occurrence overrides
    T->>T: Determine merge groups on prepared interiors; preserve selected child assets and required prims
    T->>W: Read-only input USD layers for existing-library matching
    par Independent preparation jobs
        W->>W: Confirm remaining product, exact source or authorized normalized reuse; preserve occurrence placement
        W->>W: Consolidate accepted product or compatible exact/normalized leaf inputs; retain every occurrence
    end
    W-->>T: Confirmed library hits and definitions requiring optimization
    T->>W: Owned geometry prim paths in read-only input layers
    par Independent definition scopes
        W->>W: Remove small meshes when authorized; apply asset representation: reserve merge inputs or fit analytic prims; reduce, merge (native clustering if required), prune, flatten, prune
    end
    W->>L: Geometry outputs and assembly authoring outcomes
    L->>L: Share eligible static whole definitions within current category publication
    L->>L: Share remaining whole meshes; write USD reuse metadata and compact index
    L->>T: Output USD stage with rewritten references and dependencies
    T->>T: Check authored composition, ownership, animation and interfaces
    T->>T: Profile final output USD stage and report results by asset definition
    T-->>A: Measured changes, coverage and unresolved work
    T-->>D: Final verdict and report/library paths

Use the provided tools for traversal, native operations, authoring and checks; the agent supplies engineering judgments. Preserve current variant selections, authored animation, required materials and interfaces. Trust supported USD Optimize operations with valid settings and scopes. Deep geometric comparisons and whole-scene edit trials belong in development tests, not ordinary execution.

Complete when every unique definition has an executed or evidenced unchanged outcome, every asset has justified ownership and structure, and the written consumer passes composition checks. Retain native failures, unresolved judgments and missing required capabilities as incomplete work. Repeat only affected work when evidence changes.

Scope and authorization

  • Diagnosis and validation requests remain read-only. An optimization request authorizes work in a separate output workspace within its stated preservation limits.

  • Never overwrite source layers or inherited libraries without explicit authorization.

  • Reuse authorization already given. Ask only for a missing decision that changes identity, required appearance or a loss budget; explain the affected component and consequence.

  • Report only observed changes. Measure rendering before claiming higher FPS or lower GPU use.

Load only the relevant guidance

RequestRead
Validation onlySetup, then the validation section of operations
Approved operation chainSetup, operations, verification
Existing or persistent asset libraryAdd the library index requirements to the assessment
Missing standalone runtimeInstallation
Remote stageRemote access before the first open
Report from completed evidenceVerification

Use upstream package guidance for selected operation mechanics and proxy workflows. Keep large logs on disk as specified in setup.

Limitations

Convert CAD input with the source converter's workflow and NVIDIA's CAD conversion guidance. Render profiling requires NVIDIA/omniperf or the user's available profiler; USD open and traversal timings alone do not establish rendering improvements.

Troubleshooting

For unavailable imports, operations or remote assets, follow setup. For incomplete execution or failed composition checks, follow verification; retain the failed artifacts and report the missing capability or failed check.

Examples

After runtime preflight, use the verified Python interpreter from setup to inspect a stage:

python scripts/successor_assessment.py inspect --source /data/factory.usdc --workspace /data/factory-review

Review the generated candidates using boundary guidance, fill the generated decision template, then submit it:

python scripts/successor_assessment.py decide --workspace /data/factory-review --decisions /data/factory-review/decisions.json

These commands perform assessment; continue through the instructions above only when review is complete. Run from the skill directory; generated data stays in the workspace.

Output Format

Maintain live progress and editable steering throughout execution.

For end-to-end optimization, provide the written USD assembly, validated report JSON, and generated Markdown and HTML reports. State the runtime, operations actually executed, preservation and coverage results, measured changes, source-write status, and artifact paths. Diagnosis-only work may return a findings summary stating that no optimized stage was written.

Files

references/library-reuse.md

Persistent library reuse

Set persistent_indexes in the workflow request to the library index files to inspect. The tools load them once per batch. Existing libraries remain immutable.

Execution order

During assessment, explicit product/model identifiers, authored names and CAD label tokens nominate published entries in candidates.json. Existing indexes without label keys retain content-based lookup. These clues support grouped review; they do not automatically confirm reuse or establish asset boundaries. On retained assets, record product_identity only when cited values identify the interchangeable product and its relevant configuration for the workload. Identify the actual model, part, revision, dimensions or handedness values in the existing reason; a generic assurance of interchangeability is not an explanation. A genuine product identifier may occur in a prim name, displayName, assetInfo or a custom attribute. A generic description repeated in exporter metadata remains one clue, not independent corroboration. Use the nominated library product key when accepting its identity; otherwise preserve the distinguishing values in the key. Manufacturer alone, family membership, bounds alone, or an equipment category or description do not establish product identity; omit product_identity and use existing content matching. Missing identifiers and different category labels do not exclude reuse.

Before optimization, persistent confirmation first confirms an accepted product key against published product metadata, without hashing geometry content. The identity record asserts corresponding asset-local frames and explains the accepted representation substitution; occurrence placement does not change the key. Publication integrity, units, required relative interfaces and authored animation still apply. The result is product_identity_hit, not a claim of identical source geometry.

If no accepted product entry confirms, prepared-input confirmation uses the existing original-source content and root-frame lookup. Newly published assets retain these content identities alongside any accepted product metadata, so a different product key does not prevent exact or normalized reuse. Reuse the existing published definition regardless of current decimation settings, tolerance or representation preferences. An explicit library update is separate from scene optimization. Confirmation checks completed publication, required relative prim paths, dependency fingerprints and composed reopening. A hit reports the existing disposition exact_cache_hit and skips optimization. Current published geometry supplies output accounting; historical mesh maps are unnecessary.

When the workload explicitly permits small constant-colour rounding substitutions, set allow_constant_colour_rounding: true in the request. This also enables source identity comparison for one static enclosing Xform child whose name and transform represent occurrence placement. Root display names remain on occurrences; material-subset labels may differ when their exact face memberships and effective materials agree. Geometry and internal transforms still match exactly; required internal editable prims, child asset boundaries and animation exclude this comparison. Constant RGB values in [0,1] are compared in the same 8-bit interval (floor(channel * 255 + 1e-5) / 255); textures, opacity and other shader inputs remain exact. Matching material display labels and HOOPS material-description metadata are not required. Do not enable this option from a generic optimization request.

A confirmed normalized_cache_hit keeps the existing library appearance, skips native optimization and records the authorization, original/canonical colour values and placement correction in its reuse receipt. The workflow preserves the occurrence root placement and applies the frame correction above surviving geometry. A failed match follows ordinary optimization; the agent must not assert equivalence from names.

The workflow also consolidates accepted product identities within the current run, preserving required interfaces, animation and occurrence placement. For content-based reuse, it consolidates matching leaf inputs when source identity, root frame, units, operation scopes and required editable interfaces agree. Exact identity includes authored animation, relationships and appearance; it supports multiple children without colour-rounding authorization. Authorized normalized identity follows the enclosing-child and appearance rules above. One representative is optimized and published while each occurrence retains its placement and interfaces. Cached parent selections take precedence. within_run_reuse receipts record original and representative definition IDs and the identity basis. Supplied-library reporting counts confirmed definition lookups separately from distinct referenced library entries.

Index and USD metadata

Index format 2 contains one entry per independently published asset: library identifier, prim path, exact cache key, optional normalized source key, optional accepted product key and product identification clues (explicit IDs and namespaced label/token keys). Library records hold file locations, fingerprints, coordinate/time conventions and dependency identifiers. Each dependency location and fingerprint is stored once. Internal shared mesh sources do not create asset index entries.

The authoritative usdPerformance:reuse customData dictionary on each definition root holds lookup keys, entry identity, category, asset structure, source signatures and publication completion. Accepted product identity, cited source facts and substitution reason are retained in product_identity_json; the index projects only its key. Opted-in normalized identities retain their source frame and compact colour decision evidence before geometry optimization. Original product metadata remains in USD. Operation history, assessments, measurements and source-to-output maps stay in run artifacts; they are not persistent lookup data. persistent_library.py::rebuild_index() reconstructs the index from published USD and its dependencies without input stages, prior reports or optimization.

Readers accept format 1 through the same source-identity checks. Libraries lacking source signatures require republication from saved source matching records; their combined policy hashes cannot recover source identity. Republished legacy definitions receive compact metadata in an owned copy. Prior files are never rewritten.

Placement and delivery

Preserve local coordinate frames and current required occurrence edits. Root and ancestor transforms, including animation and transform-stack resets, participate in exact input identity. Arbitrary hierarchy remapping and independently re-tessellated shape recognition are outside this matcher.

Confirmed current-format entries remain external and read-only by default, with relative library and index paths. Retain the directory layout when moving the delivery; dependencies inside supplied libraries must also be relocatable. Set portable_output: true for a localized dependency snapshot. Publish library files and their index together, with stable definition entrypoints. Reopen consumers and check composition and placement through the ordinary workflow checks.

MDL modules remain at their original absolute locations in nonportable outputs. USD dependency tools do not inspect imports or texture paths inside MDL modules. The index records this incomplete resource closure; exact cache confirmation excludes those definitions. Portable publication with MDL dependencies remains incomplete until an MDL-aware collector can preserve that closure.

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs Python, Needs Node.js

The author says: Requires a verified standalone Usd Optimize/OpenUSD runtime for operations, usd-validation-nvidia for supported checks, and a writable output workspace. Remote assets require a working resolver. Render profiling is an external handoff.

Security

What our scanner noticed· Medium risk

  • Large base64-encoded blobs
  • Scripts that your agent may run

This skill includes scripts that your agent may run. Read them before you use it.

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by
NVIDIA Omniverse
Publisher
NVIDIA (Official)
Source
NVIDIA/skills · skills/omniverse-usd-performance-tuning · commit fce3cca
Licence
Apache License 2.0 (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE-APACHE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by NVIDIA Omniverse or NVIDIA.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download omniverse-usd-performance-tuning.zip