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

Download the skill as a ZIP:
https://autogineer.com/agent-skills/nvidia/omniverse-usd-performance-tuning/download

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

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.
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.
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.
Optimize unique definitions. Run supported native operations concurrently on disjoint scopes with the recorded physical budget.
Publish semantic libraries. Use one writer per category layer and remap consumer references.
Check composition. Check authored ownership, references, bindings, placement, animation and interface accessibility through the written-output checks.
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

Request	Read
Validation only	Setup, then the validation section of operations
Approved operation chain	Setup, operations, verification
Existing or persistent asset library	Add the library index requirements to the assessment
Missing standalone runtime	Installation
Remote stage	Remote access before the first open
Report from completed evidence	Verification

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

ATTRIBUTION.mdAdded by AutoGineer964 B
BENCHMARK.md12.0 KiB
CHANGELOG.md2.4 KiB
LICENSELicence file added by AutoGineer11.2 KiB
SKILL.md10.2 KiB
agents/openai.yaml375 B
assets/progress-dashboard/app.jsScript9.8 KiB
assets/progress-dashboard/index.html2.4 KiB
assets/progress-dashboard/styles.css3.8 KiB
config/skillspector-baseline.yaml7.3 KiB
evals/README.md1.8 KiB
evals/evals.json12.4 KiB
evals/files/completed-run/after.usda399 B
evals/files/completed-run/before.usda399 B
evals/files/completed-run/evidence.json745 B
evals/files/factory/cases/factory.usda13.6 KiB
evals/files/factory/materials.usda1.8 KiB
references/asset-authoring.md10.1 KiB
references/component_scope.pyScript18.0 KiB
references/geometry_tolerance.pyScript2.1 KiB
references/install-standalone.md2.4 KiB
references/library-reuse.md7.6 KiB
references/operations.md22.4 KiB
references/operations/README.md7.9 KiB
references/operations/operations.json52.4 KiB
references/operations/registry-args.json2.1 KiB
references/operations/scripts/operations.schema.json6.2 KiB
references/optimization-report/scripts/apply_palette.pyScript13.3 KiB
references/optimization-report/scripts/asset_results.pyScript5.9 KiB
references/optimization-report/scripts/definition_verification.pyScript7.1 KiB
references/optimization-report/scripts/descent_convergence_common.pyScript9.0 KiB
references/optimization-report/scripts/optimization-report.schema.json39.4 KiB
references/optimization-report/scripts/structure_conformance.pyScript15.2 KiB
references/optimization-report/scripts/validate_report.pyScript55.2 KiB
references/remote-assets.md1.6 KiB
references/report-templates/optimization-report.html.template14.9 KiB
references/report-templates/optimization-report.md.template6.2 KiB
references/report-templates/render_preview.pyScript17.9 KiB
references/report-templates/theme.css711 B
references/setup-usd-performance-tuning/scripts/probe-snapshot.schema.json1.7 KiB
references/setup-usd-performance-tuning/scripts/setup-preflight.schema.json6.4 KiB
references/setup.md3.3 KiB
references/structure.md20.8 KiB
references/upstreams/usd-optimize.md6.3 KiB
references/usd-optimize-run-operations/scripts/asset_authoring.pyScript54.9 KiB
references/usd-optimize-run-operations/scripts/batch-plan.schema.json7.5 KiB
references/usd-optimize-run-operations/scripts/category_publication.pyScript6.3 KiB
references/usd-optimize-run-operations/scripts/current_run_reuse.pyScript11.6 KiB
references/usd-optimize-run-operations/scripts/material_optimization.pyScript4.9 KiB
references/usd-optimize-run-operations/scripts/material_publication.pyScript9.5 KiB
references/usd-optimize-run-operations/scripts/native_reconstruction.pyScript7.9 KiB
references/usd-optimize-run-operations/scripts/native_worker.pyScript68.4 KiB
references/usd-optimize-run-operations/scripts/pack_definitions.pyScript1.6 KiB
references/usd-optimize-run-operations/scripts/persistent_library.pyScript20.3 KiB
references/usd-optimize-run-operations/scripts/persistent_reuse.pyScript31.1 KiB
references/usd-optimize-run-operations/scripts/prim_regroup.pyScript14.9 KiB
references/usd-optimize-run-operations/scripts/run_batch.pyScript32.5 KiB
references/usd-optimize-run-operations/scripts/semantic_library.pyScript48.2 KiB
references/usd-optimize-run-operations/scripts/shared_geometry.pyScript25.5 KiB
references/usd-optimize-run-operations/scripts/status.schema.json7.9 KiB
references/usd-structure-assessment/references/apply-restructure/scripts/apply-restructure-manifest.schema.json35.3 KiB
references/usd-structure-assessment/references/usd-hierarchy-dedupe-candidates/scripts/instance_candidate_finder.pyScript12.7 KiB
references/usd-structure-assessment/references/usd-mesh-fragmentation-candidates/scripts/mesh_fragmentation_finder.pyScript13.8 KiB
references/usd-structure-assessment/scripts/atomic_placement.pyScript4.9 KiB
references/usd-structure-assessment/scripts/audit-report.schema.json2.3 KiB
references/usd-structure-assessment/scripts/boundary_reasoning.pyScript36.0 KiB
references/usd-structure-assessment/scripts/discovery_preview.pyScript8.6 KiB
references/usd-structure-assessment/scripts/optimization-plan.schema.json1.5 KiB
references/usd-structure-assessment/scripts/structure_assessment.pyScript112.2 KiB
references/usd-structure-assessment/scripts/usd-structure-assessment-report.schema.json14.0 KiB
references/usd-validation-runner/references/validator-concepts.json35.8 KiB
references/usd-validation-runner/scripts/usd_validation_executor.pyScript37.4 KiB
references/usd-validation-runner/scripts/validation-report.schema.json3.5 KiB
references/usd-validation-runner/scripts/validation-scope-note.schema.json2.6 KiB
references/usd-validation-runner/scripts/validator-concepts.schema.json3.8 KiB
references/verification.md11.9 KiB
scripts/animation_context.pyScript6.8 KiB
scripts/composition_verification.pyScript16.9 KiB
scripts/failure_reporting.pyScript2.7 KiB
scripts/product_clues.pyScript6.2 KiB
scripts/progress_dashboard.pyScript12.6 KiB
scripts/stage_profile.pyScript15.7 KiB
scripts/successor_assessment.pyScript34.1 KiB
scripts/successor_execution.pyScript15.7 KiB
scripts/successor_progress.pyScript22.3 KiB
scripts/successor_reconstruction.pyScript19.6 KiB
scripts/successor_workflow.pyScript55.0 KiB
scripts/usd_tuning.pyScript24.7 KiB
skill-card.md5.5 KiB
skill.oms.sig26.5 KiB

references/verification.md

Measurement, preservation and reporting

Capture the original baseline before mutation and compare the final written consumer assembly against it. For a later pass, load the original baseline record and record the current input separately. A repacked baseline is an additional storage comparison, never a replacement for the original. If the original record is missing, report that comparison as unavailable. Use the recorded runtime, load policy, variants, tolerances, occurrence mappings and output inventory. Check the assessment's requirements against the written assembly; do not redefine retained prims or choose replacement operations during verification.

Native operation reports measure geometry counts and stored array sizes. Reuse the preceding operation's measurements when its scope is unchanged; measure again after each operation. Do not hash geometry arrays before and after every native operation. Source integrity and authored opinions outside the operation scope remain separate checks. A reported reduction is a measured count or storage change, not proof of surface equivalence.

Comparable measurements

Record runtime/package identity, source/dependency fingerprints, load policy, variants, time samples, storage location and cache context. Use stage_profile.py for fresh-process opening and traversal measurements, preserving its original baseline output. Record separate prim counts for ordinary traversal and traversal that includes instance proxies. For rendered geometry, walk composed occurrences from the stage roots; do not add prototype definitions to their instances. Derive geometry bounds from composed points when authored extents may be stale.

Time a bare traversal without extra per-prim filtering or geometry work inside its loop. Run baseline and after timing in fresh processes under the same conditions. For each stage, record one first open, one unreported warmup, then at least five warm opens; report their median as warm_open_ms, with warm_open_samples_ms, warm_open_sample_count, warm_open_spread_pct and open_timing_context. A first open is not guaranteed OS-cold. Mark same-process/cache-contaminated measurements accordingly.

If sample spread exceeds 15% of the median or the before/after delta lies within that spread, warm-open evidence is inconclusive. Keep its verdict neutral; do not claim a warm-load regression without comparable, corroborating evidence. Report absolute and percentage deltas. The existing significance convention is >5% improvement/regression, ±5% neutral and >20% critical regression, subject to noise and workload relevance. Mixed outcomes remain visible.

Report scene USD and referenced resources, persistent reuse-index overhead, and total delivery bytes separately. Count each file once. Index overhead is a cost of reuse on subsequent runs, not stage-open or rendering cost; show confirmed reuse and avoided work separately. The existing storage score uses total delivery and must be labelled as such. Report the original-to-re-crated encoding delta separately from the re-crated-to-output delta. The latter combines geometry, composition and packing changes; it does not isolate geometry savings. RAM, VRAM, FPS, frame time and shader costs need actual external profiling; leave them unavailable when unmeasured.

Written-output checks

Trust supported native USD Optimize operations with validated settings and scopes. Record their completion, errors, outputs and changed/unchanged results. Runtime checks focus on the composition our tools author:

Reopen published outputs through a fresh consuming reference. Check default prims, dependencies, current variant configuration and required loading interfaces.
Reconcile source ownership, output definitions and occurrence mappings with the manifest. Check justified atomic/package/aggregate structures, composed model kinds, required prims and coverage. Detect duplicate rendered composition, including accidentally promoted referenced over holders.
Check reference and material-binding remaps, including subsets, inherited bindings, required shader/texture dependencies and retained inline geometry. Valid displayColor needs no new material; exact palette checks apply only to requested palettes.
Check authored occurrence placement, transform chains, time samples, time metadata, required visibility, relationships and connections. Preserve local frames and independently animated interfaces; do not bake to the current frame.
Check recorded editable interfaces exist, retain their properties and remain accessible outside instance proxies. This structural check does not simulate edits or certify physics behavior.
Recheck source/inherited-library integrity and invalidate evidence affected by writes. Reuse unchanged inventories within a phase; resumption requires matching inputs, dependencies, runtime, settings and composition context.

Check operation outcomes and final published references and coverage. For reconstruction, check input/output integrity, source context, ordered root-path mappings and required interfaces. Do not replay per-property preservation comparisons for regrouping. Trust supported native geometry operations; do not add independent surface comparisons during execution or after packaging. Retain the written-output checks above, including animation and material bindings. Confirm source compatibility before sharing or reusing definitions. Missing outputs, native failures, unresolved ownership and broken composition leave the run incomplete.

The physical budget is a configured limit, not an independently measured result. Report actual measurement coverage; native success and equal aggregate bounds do not prove a maximum surface deviation.

Preserve existing report fields for operation scopes, merge identity/locality, rendered geometry counts and storage attribution. Counts describe outcomes; unchanged mesh or point counts are not preservation requirements. Record validate_usd_minimum as pass, fail or skipped and retain the reason and affected scope.

Progress and steering

Assessment and execution write one compact progress.json beside progress.md from the same phase events, scheduler counts and recorded decisions. Progress never rescans USD. Counts describe the current activity or worker jobs; an unknown total has no percentage. Accepted decisions remain visible across assessment rounds.

For browser progress, start the packaged read-only server in a separate terminal before assessment and give the user its printed localhost URL:

python "$SKILL/scripts/progress_dashboard.py" --workspace "$RUN" --port 8765

The server follows $RUN/assessment and $RUN/execution when present, otherwise $RUN itself. Supply --assessment, --execution and --common-library when those locations differ; a running workflow records its common-library path automatically. The browser shows the current phase, nested assessment rounds, activity counters, worker activity, accepted decisions, elapsed time and full artifact paths. Click a phase to inspect its recorded state, then Follow current phase to return.

No update for 90 seconds is labelled stale, with process status unknown. A browser connection failure is separate from a recorded workflow failure. Completion comes from the workflow verdict, never from worker counts or a report file's presence. Closing the browser or stopping this server does not stop optimization. The server has no run controls and requires only Python's standard library.

Explain consequential choices from accepted boundary/structure/reuse records in asset groups: independent use, selected structure, reason and whether the decision was requested, observed or inferred. Link the manifest for detail. Distinguish these judgments from measured tool results and keep unresolved work visible.

Create steering.md once with source, workload, preservation requirements, accepted decisions and an editable changes-for-next-run section. Preserve the user's edits on updates or resumption. The user can revise and submit it as the next prompt; the running workflow never executes instructions from the log automatically.

Generate the reports

Write report JSON using the existing schema. Read relevant definitions and validate the result; do not load the entire schema by default or invent fields. Preserve score/report compatibility, validation coverage and restructure manifests. Allowed verdicts are improved, neutral, regressed and mixed; workflow_mode records the actual supported mode: full, structural_only or no_op.

Present one overall verdict (Improved, Mixed, Unchanged or Regressed) using the recorded measured-result verdict, with completion and verification status alongside it. When neutral is a placeholder for incomplete measurements, show Insufficient measurements rather than Unchanged. Show delivery size as a normal metric; do not render numeric score widgets or score sections. Preserve numeric fields in JSON for report compatibility. Group scores follow the existing rubric: 10 at 75% improvement, 8.5 at 50%, 7 at 25%, 6 at 10% and 5 within ±5%. For storage regressions, increases of 10%, 20% and 100% map to 3, 1 and 0 respectively. Use the shared score_from_change helper in the report validator for piecewise linear interpolation between these anchors. This storage proxy does not establish usability; preservation and completion checks remain separate. Explain interpolation and caveats. Compute the weighted mean over non-null scores with positive weights, rounded to one decimal. Labels are excellent ≥9, strong ≥7.5, moderate ≥5.5, neutral ≥4.5, mixed ≥2.5, otherwise regressed. A score cannot override failed preservation or incomplete target coverage.

From the skill directory, validate and generate both report formats from the same JSON:

python references/optimization-report/scripts/validate_report.py "$REPORT_JSON" --manifest "$MANIFEST_JSON"
python references/report-templates/render_preview.py --fixture "$REPORT_JSON" --template references/report-templates/optimization-report.md.template --output "$REPORT_MD"
python references/report-templates/render_preview.py --fixture "$REPORT_JSON" --output "$REPORT_HTML"

For a completed successor run, use manifest.json in its execution workspace; authored-manifest.json describes intermediate inputs.

Supply each applicable manifest; omit --manifest only when no restructure occurred and the report schema and validator permit it. Never hand-write the Markdown or HTML report. Report operations by unique asset definition using asset_results, joined from the manifest and worker receipts. Show its recorded name (otherwise source prim name), category, source prim path, structural type, optional equipment family, boundary and structure reasons, occurrence paths, own-geometry before/after counts, and ordered operation outcomes. Report child definitions separately; report shared material work once. Retain failed and unchanged attempts. Label missing reasons or timings as unrecorded, and show prior_native_operations from persistent reuse receipts as separate provenance, excluding their timings from this run’s operations.

Lead with readable measured benefits, then explain what changed, why, checks performed and measurement limits. Separate scene bytes from reuse-index overhead and within-scene sharing from reuse of existing libraries. Collapse operation details and show unchanged metrics and failures. Use recorded unresolved findings for editable next-run instructions; do not invent recommendations or require mesh-by-mesh reasoning. No extra USD scan or geometry verification is needed for reporting. If validation/rendering fails, report the failure and keep the run incomplete. Final completion requires every manifest definition and required preservation check to pass, regardless of score or number of iterations.

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

2026-11-09

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