Using Ovnewton
NVIDIAOfficialCreated by Jan CariusDistributed by NVIDIA
- Skill
- Tool integration
- Automation and integrations
- Apache-2.0
- Medium risk
AutoGineer summary
Written by AutoGineer from the skill’s own files, not by the author
The ovnewton skill provides a bridge between the Newton physics engine and Omniverse stages. It enables developers to import populated stages into Newton, execute physics simulations, and synchronize state updates back to the stage for rendering or further processing. The tool manages the integration of physics solvers, collision handling, and simulation loops while maintaining consistency between the physics model and the USD-based stage representation.
What it does
- Imports populated ovstage data into the Newton physics engine
- Registers USD schemas for physics compatibility
- Supports integration with MuJoCo and VBD solvers
- Synchronizes simulation states back to the Omniverse stage
- Manages physics simulation loops and state updates
- Provides mechanisms for publishing simulation results for rendering
When to use it
- When integrating Newton physics into an Omniverse-based application
- When you need to run physics simulations on a populated USD stage
- When synchronizing physics simulation outputs with Omniverse rendering
- When managing complex physics state updates between a solver and a stage
Advantages
- Enables direct physics simulation of USD-based scenes
- Supports multiple solver types including MuJoCo and VBD
- Provides structured workflows for state synchronization and publication
- Allows for custom attribute registration within the simulation model
Usage examples
- “How do I initialize a basic Newton simulation with an Omniverse stage?”
- You install the package, call register_usd_schemas, populate your stage, and use the ModelBuilder to import the stage into Newton before finalizing the simulation.
- “How can I synchronize my physics simulation state back to the stage?”
- After each simulation step, you use the binding.update_to_ovstage method to publish the current state and seal it for the renderer.
Install
Download the skill as a ZIP:
https://mp-staging.autogineer.com/agent-skills/nvidia/using-ovnewton/downloadUnzip it into the cross-client skills folder of your project:
mkdir -p .agents/skills && unzip using-ovnewton.zip -d .agents/skills
Documentation by Jan Carius
Using ovnewton
Use ovnewton for the Newton ↔ ovstage bridge. The application owns model finalization, the solver, controls, collision handling, and the simulation loop. ovnewton reads a populated ovstage; Newton does not parse USD in this workflow. Standalone Newton simulations and generic Omniverse authoring do not need this skill.
Start from the supported examples
Install ovnewton in the application's environment. This workflow requires
Newton 1.7 or newer, OVStage 0.3, and OVRTX 0.6 when rendering. Let its package metadata
select compatible dependencies; do not replace the qualified ovstage dependency
with an arbitrary build.
pip install ovnewton
python -m ovnewton.examples.example_ovnewton_basic --device cpu --no-render --num-frames 8For rendering or MuJoCo-Warp, install "ovnewton[examples]". The basic example
accepts --solver mujoco or --solver vbd; VBD also supports CPU simulation.
Rendering needs a supported NVIDIA GPU and its own device selection.
Read the getting-started guide and adapt the basic example. For multiple robots, use the robot example. Use documentation and examples corresponding to the installed ovnewton release; repository main may describe a newer API.
Construct and bind the simulation
Call
ovnewton.register_usd_schemas()before the first USD schema read. Create anovstage.Stage()and populate the application-supplied USD withpopulation.open_usd_with_desc(stage, scene_path, ordinal=1, time=population.DEFAULT_TIME, descs=(ovnewton.population_desc(),)). Add apopulation.Desc(domains=PopulationDomain.RENDERING)descriptor when rendering.ovnewton.population_desc()preserves composed schema names so unsupported physics remains detectable even without its schema plugin. Seal population withstage.advance_write_floor(1).wait()before importing. For rendering, create stages withovstage.StageConfigselectingruntime_default_hierarchy_computation_model=ovstage.HierarchyComputationModel.GPU_INCREMENTAL, including CPU physics with a GPU renderer. This setting is process-wide; coexisting stages must use a consistent configuration. CPU-only runs do not need this setting. An existing populated stage must preserve the same composed schema metadata; attachment cannot recover schema names discarded during population. If the application already supplies a populated stage, reuse it and its sealed ordinal; do not reload the scene or assume its ordinal is 1.Create an empty
newton.ModelBuilder(). Configure defaults and register any solver-owned custom attributes before callingovnewton.add_ovstage(builder, stage, ordinal=population_ordinal). Compose all scene assets into one ovstage first: this entry point currently requires a builder without model entities and supports one stage per builder.For MuJoCo, register
SolverMuJoCo.register_custom_attributes(builder)before callingovnewton.add_ovstage(). For rigid-body VBD, registerSolverVBD.register_custom_attributes(builder)beforeovnewton.add_ovstage()and callbuilder.color()after that import, before finalization. UseSolverVBD(model, rigid_compliant_alm=True)for compliant rigid-body contacts, following the example's solver settings and contact-material tuning.Finalize with
builder.finalize(skip_validation_joints=import_result.has_orphan_joints), whereimport_resultis the result ofadd_ovstage. Construct the solver and bind withovnewton.attach_ovstage(stage, model=model, ordinal=population_ordinal).attach_ovstage(stage)is the convenience path when no builder customization is needed. When binding an existing model, body and joint labels must match stage paths.
Step and synchronize
Allocate two model states, controls, and contacts. Each substep clears forces, computes contacts, calls the solver, and swaps the states. Start from the example's collision pipeline and solver configuration rather than assuming every solver has identical preparation requirements.
After stepping, publish the current state with
binding.update_to_ovstage(state, ordinal=output_ordinal), then seal it with
stage.advance_write_floor(output_ordinal).wait(). Coordinate increasing write
ordinals with the application's other stage writers.
To consume application edits, seal them first and call
binding.update_from_ovstage(state, control) before stepping, using the same
control passed to the solver. This reads the latest sealed supported state and
drive-target fields. An explicit read ordinal is a consistency ceiling, not
historical playback. Selected Newton-native output can instead be read through
binding.query() and binding.read() without stage publication.
For rendering, publish and seal Newton output before the renderer consumes the stage. Newton's simulation device and OVRTX's rendering device are independent; follow the example's synchronization and device-selection options.
Check the support guide before promising support for authored physics. Unsupported physics may fail attachment; do not silently replace it with a different physical model. See the concepts guide and output-read guide for synchronization, diagnostics, read layouts, and lifetimes.
Files
- ATTRIBUTION.mdAdded by AutoGineer904 B
- BENCHMARK.md8.2 KiB
- LICENSELicence file added by AutoGineer11.2 KiB
- SKILL.md6.0 KiB
- evals/EVAL.md1.8 KiB
- evals/config.yml198 B
- evals/evals.json5.5 KiB
- skill-card.md5.4 KiB
- skill.oms.sig4.9 KiB
evals/evals.json
{
"skill_name": "using-ovnewton",
"evals": [
{
"id": "using-ovnewton-basic",
"prompt": "Use using-ovnewton to show a minimal CPU simulation that connects a USD scene to Newton through ovstage. Return runnable Python and the install and smoke commands; no rendering is needed.",
"expected_skill": "using-ovnewton",
"expected_output": "Registers schemas, populates through population.open_usd_with_desc with ovnewton.population_desc() and seals ordinal 1, calls add_ovstage, finalizes with has_orphan_joints, creates XPBD, model states/control/contacts, computes collisions, steps, swaps states, publishes and seals output. Includes pip install ovnewton and the packaged CPU smoke command.",
"assertions": [
"Reads using-ovnewton/SKILL.md.",
"Newton consumes ovstage rather than parsing USD.",
"Seals population before import and output after publication.",
"Application owns the solver and stepping loop.",
"Preserves composed schema names with ovnewton.population_desc() and supplies population.DEFAULT_TIME."
]
},
{
"id": "using-ovnewton-existing-stage",
"prompt": "Our application already populated an ovstage and sealed it at ordinal 12. Connect Newton physics to this Omniverse simulation without reloading USD, and publish the next result at ordinal 13. Return the integration snippet.",
"expected_skill": "using-ovnewton",
"expected_output": "Reuses the stage, passes ordinal=12 to add_ovstage and attach_ovstage, finalizes with the import result, then publishes and seals at ordinal 13. Explains that complete unsupported-physics validation requires composed apiSchemas metadata preserved during population.",
"assertions": [
"Reads using-ovnewton/SKILL.md.",
"Does not recreate the stage or reload USD.",
"Uses the actual sealed ordinal for import and binding.",
"Publishes and seals output at ordinal 13.",
"Explains the schema metadata prerequisite without recreating the supplied stage."
]
},
{
"id": "using-ovnewton-vbd",
"prompt": "Connect my USD scene in ovstage to Newton using VBD. Show builder construction and a headless CPU smoke command.",
"expected_skill": "using-ovnewton",
"expected_output": "Registers VBD custom attributes before add_ovstage, colors after population, finalizes using has_orphan_joints, creates SolverVBD with rigid_compliant_alm=True, attaches the model. Packaged CPU smoke uses --solver vbd --device cpu --no-render --num-frames 8.",
"assertions": [
"Reads using-ovnewton/SKILL.md.",
"Registers VBD attributes before population.",
"Colors the populated builder before finalization.",
"Explicitly enables compliant rigid-body contacts with rigid_compliant_alm=True.",
"Uses an application-owned solver and model."
]
},
{
"id": "using-ovnewton-stage-edits",
"prompt": "In our Newton/ovstage loop, the application edits drive targets after publishing a frame. Show how to consume the edits on the next step. Can an old ordinal replay earlier values?",
"expected_skill": "using-ovnewton",
"expected_output": "Seal edits, call update_from_ovstage(state, control) before stepping with the same control, and publish and seal output at coordinated increasing ordinals. Read ordinals constrain current payload consistency and cannot replay overwritten history.",
"assertions": [
"Reads using-ovnewton/SKILL.md.",
"Seals edits before consuming them.",
"Passes the solver control to update_from_ovstage.",
"Explains read ordinals are not historical playback."
]
},
{
"id": "using-ovnewton-rendering",
"prompt": "I want Newton physics driving an Omniverse ovstage rendered with OVRTX. Give installation and example commands and explain the frame handoff; assume I have a supported NVIDIA GPU.",
"expected_skill": "using-ovnewton",
"expected_output": "Installs ovnewton[examples], runs the packaged basic example with rendering, and explains publish/seal before rendering and independent physics/render device selection. Explains GPU_INCREMENTAL hierarchy configuration for caller-owned rendering stages, including CPU physics, and combines rendering and ovnewton population descriptors.",
"assertions": [
"Reads using-ovnewton/SKILL.md.",
"Installs the examples extra.",
"Uses public packaged examples rather than internal launchers.",
"Seals published output before rendering.",
"Uses compatible OVStage 0.3 and OVRTX 0.6 and explains process-wide GPU hierarchy configuration."
]
},
{
"id": "using-ovnewton-newton-only",
"prompt": "Show a standalone Newton XPBD rigid-body simulation built directly with ModelBuilder. No USD, ovstage, or Omniverse integration is needed.",
"expected_skill": null,
"expected_output": "Provides standalone Newton code without loading using-ovnewton or adding ovstage.",
"assertions": [
"Does not load using-ovnewton/SKILL.md.",
"Does not introduce ovnewton or ovstage."
]
},
{
"id": "using-ovnewton-omniverse-authoring",
"prompt": "How do I author cameras and lights in USD for Omniverse rendering? I am not adding a physics engine.",
"expected_skill": null,
"expected_output": "Addresses camera/light authoring without loading using-ovnewton or adding a Newton bridge.",
"assertions": [
"Does not load using-ovnewton/SKILL.md.",
"Does not add a Newton simulation loop."
]
}
]
}
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
Security
What our scanner noticed· Medium risk
- Large base64-encoded blobs
- Instructions that use the network
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
- Jan Carius
- Publisher
- NVIDIA (Official)
- Distributed by
- NVIDIA
- Source
- NVIDIA/skills · skills/ovnewton-usage · 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 Jan Carius or NVIDIA.
Download ZIP
The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download using-ovnewton.zip