ovnewton

ovnewton connects the Newton physics engine with the Omniverse library ecosystem.

Experimental: ovnewton is currently experimental. Its API and packaging may change before version 1.0.

Overview

ovnewton builds Newton models from scenes populated in ovstage. The application owns the Newton solver and simulation loop. A binding publishes simulation state to the stage, applies sealed stage updates to Newton, or exposes selected Newton outputs without publishing.

Use add_ovstage() to populate an application-owned builder, or attach_ovstage(stage) to create and finalize the model automatically.

USD ──ovpopulation──▶ ovstage ──ovnewton──▶ Newton
                          ▲                    │
                          └── simulation state ┘

Newton does not parse the USD file in this workflow.

Requirements

• Python 3.11 through 3.14
• Linux on x86-64 and aarch64 for non-rendering workflows
• CPU or NVIDIA CUDA GPU for supported non-rendering workflows
• A compatible NVIDIA RTX-capable GPU and supported driver for OVRTX rendering, even when physics runs on the CPU

Package installation resolves the required dependencies. Detailed version requirements are in the support guide.

Installation

Install the current public release of ovnewton and its runtime dependencies from PyPI:

pip install ovnewton

Run the installed example without rendering:

python -m ovnewton.examples.example_ovnewton_basic --device cpu --no-render

The example loads the scene_rigid_bodies.usda scene included in the ovnewton wheel. Install the examples extra for ovrtx rendering and MuJoCo-Warp:

pip install "ovnewton[examples]"
python -m ovnewton.examples.example_ovnewton_basic

The same example can build the scene through ovnewton and advance it with the MuJoCo-Warp or VBD backend on CUDA or CPU:

python -m ovnewton.examples.example_ovnewton_basic --solver mujoco
python -m ovnewton.examples.example_ovnewton_basic --solver vbd

The simulation runs on cuda:0 by default. Pass --device cpu to simulate on the CPU. The wheel also includes a complete cartpole scene:

python -m ovnewton.examples.example_ovnewton_basic --stage scene_cartpole

To watch several Ant robots from Newton's installed assets fall onto a ground plane:

python -m ovnewton.examples.example_ovnewton_robot

Quickstart

The USD scene in this example is supplied by the application.

ovnewton.population_desc() selects physics data and preserves composed schema names. Combine it with a rendering descriptor as shown below.

import newton
import ovnewton
import ovstage
from ovstage import PopulationDomain, population

scene_path = "/path/to/scene.usd"

ovnewton.register_usd_schemas()
stage = ovstage.Stage()
population.open_usd_with_desc(
    stage,
    scene_path,
    ordinal=1,
    time=population.DEFAULT_TIME,
    descs=(population.Desc(domains=PopulationDomain.RENDERING), ovnewton.population_desc()),
)
stage.advance_write_floor(1).wait()

builder = newton.ModelBuilder()
import_result = ovnewton.add_ovstage(builder, stage)
model = builder.finalize(skip_validation_joints=import_result.has_orphan_joints)
solver = newton.solvers.SolverXPBD(model)
binding = ovnewton.attach_ovstage(stage, model=model)
state_0 = model.state()
state_1 = model.state()
newton.eval_fk(model, model.joint_q, model.joint_qd, state_0)
control = model.control()
collision_pipeline = newton.CollisionPipeline(model)
contacts = collision_pipeline.contacts()

dt = 1.0 / 60.0
state_0.clear_forces()
collision_pipeline.collide(state_0, contacts)
solver.step(state_0, state_1, control, contacts, dt)

binding.update_to_ovstage(state_1, ordinal=2)
stage.advance_write_floor(2).wait()

Call binding.update_from_ovstage(state, control) when you intend to resynchronize all supported state and drive targets from the sealed stage. This can overwrite live simulation state with older stage values. To update only joint targets while preserving live simulation state, pass attributes=("jointPositionTarget", "jointVelocityTarget"). The same selector supports body pose/velocity and single-DOF joint state; see the getting-started guide for the field list and synchronization semantics. Use binding.query() and binding.read() to expose selected read-only Newton state without publishing it.

See the getting-started guide for the full simulation loop and MuJoCo/VBD model preparation.

Supported features and limits

ovnewton supports rigid bodies, articulations, primitive and mesh colliders, physics materials, collision filtering, and a limited subset of surface-cloth inputs. Applications can synchronize state with ovstage and read selected Newton outputs on CPU or CUDA.

Physics instancing, Newton actuators, cables and volume deformables are not supported. Joint-state updates, material bindings and cloth inputs have additional restrictions; see the support guide for the full list.

Malformed data and unsupported physics that would materially change the model raise an error. Recoverable import decisions use the standard ovnewton Python logger; see the concepts guide for details.

License

ovnewton is licensed under the Apache License 2.0. The complete license text is included in the distribution.

Contributing

This project is currently not accepting contributions.