> This page is for version Release 3.0 (default).
> For other versions, use one of these documentation indexes:
> - Release 3.0 (default): https://docs.nvidia.com/isaaclab/3.0/llms.txt
> - Release 2.3: https://docs.nvidia.com/isaaclab/2.3/llms.txt
> - Release 2.2: https://docs.nvidia.com/isaaclab/2.2/llms.txt
> - Release 2.1: https://docs.nvidia.com/isaaclab/2.1/llms.txt

> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.nvidia.com/isaaclab/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.nvidia.com/isaaclab/_mcp/server.

# Newton

Newton is a Warp-native backend that can run without Isaac Sim. Its Isaac Lab
integration supports multiple solver families. Configure the
backend with [NewtonCfg](https://isaac-sim.github.io/IsaacLab/release/3.0.0/source/api/lab_newton/isaaclab_newton.physics.html#isaaclab_newton.physics.NewtonCfg) and choose a solver
configuration through its `solver_cfg` field.

Check task `--help` or [the environment catalog ](https://isaac-sim.github.io/IsaacLab/release/3.0.0/source/isaaclab/environments.html)
for supported presets. Before tuning a new asset, follow
[/source/how-to/prepare_asset_for_newton](/isaaclab/3.0/isaac-lab/prepare-an-asset-for-newton-with-mj-warp).

## Solver options

Use the links below for Isaac Lab configuration and tuning. Newton's
[solver guide](https://newton-physics.github.io/newton/latest/solvers/index.html)
explains the algorithms, features, and contact models. Isaac Lab's API references
list configuration fields and defaults.

| Isaac Lab configuration                                                                                                                                                                                                                                                                                                                               | Workflow                                                                                                                                                     |
| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| [MJWarpSolverCfg](https://isaac-sim.github.io/IsaacLab/release/3.0.0/source/api/lab_newton/isaaclab_newton.physics.html#isaaclab_newton.physics.MJWarpSolverCfg)                                                                                                                                                                                      | [Tune MJWarp](/isaaclab/3.0/isaac-lab/tune-mj-warp) for the primary validated solver path                                                                    |
| [KaminoPADMMSolverCfg](https://isaac-sim.github.io/IsaacLab/release/3.0.0/source/api/lab_newton/isaaclab_newton.physics.html#isaaclab_newton.physics.KaminoPADMMSolverCfg) and [KaminoDVISolverCfg](https://isaac-sim.github.io/IsaacLab/release/3.0.0/source/api/lab_newton/isaaclab_newton.physics.html#isaaclab_newton.physics.KaminoDVISolverCfg) | [Tune Kamino](/isaaclab/3.0/isaac-lab/tune-kamino) for Kamino configuration                                                                                  |
| [VBDSolverCfg](https://isaac-sim.github.io/IsaacLab/release/3.0.0/source/api/lab_newton/isaaclab_newton.physics.html#isaaclab_newton.physics.VBDSolverCfg)                                                                                                                                                                                            | [VBD Solver](/isaaclab/3.0/isaac-lab/vbd-solver) for cloth, soft bodies, and coupled scenes                                                                  |
| [MPMSolverCfg](https://isaac-sim.github.io/IsaacLab/release/3.0.0/source/api/lab_newton/isaaclab_newton.physics.html#isaaclab_newton.physics.MPMSolverCfg)                                                                                                                                                                                            | [Implicit MPM](/isaaclab/3.0/concepts/implicit-mpm) for how the integration works and [MPM Solver](/isaaclab/3.0/isaac-lab/mpm-solver) for parameter studies |

Additional solver configurations are
[XPBDSolverCfg](https://isaac-sim.github.io/IsaacLab/release/3.0.0/source/api/lab_newton/isaaclab_newton.physics.html#isaaclab_newton.physics.XPBDSolverCfg) and
[FeatherstoneSolverCfg](https://isaac-sim.github.io/IsaacLab/release/3.0.0/source/api/lab_newton/isaaclab_newton.physics.html#isaaclab_newton.physics.FeatherstoneSolverCfg). Use their generated
API references and the Newton solver guide when evaluating a task-specific
preset.

## Related workflows

Use [/source/how-to/transfer_policies_between_physx_and_newton](/isaaclab/3.0/isaac-lab/transfer-policies-between-phys-x-and-newton) to
validate a policy across backends. Related guides cover
[Deformables](/isaaclab/3.0/concepts/deformables), [Warp Environments](/isaaclab/3.0/experimental-features/warp-environments), and [Migrating Existing Environments](/isaaclab/3.0/experimental-features/warp-environments#migrating-existing-environments).
Backend developers can also read
[/source/developer-tools/extending_newton_solvers](/isaaclab/3.0/developer-tools/extending-newton-solvers).

## Native access

Use native access when the shared asset and sensor APIs do not expose the data
or operation you need. Reuse an Isaac Lab-owned handle when its selection matches;
create raw access only for additional capabilities. Native writes can bypass Isaac
Lab's caches and validation, so follow the ownership and synchronization rules below.

### Mental model

The Newton backend exposes its engine-owned [Model](https://newton-physics.github.io/newton/stable/api/_generated/newton.Model.html), [State](https://newton-physics.github.io/newton/stable/api/_generated/newton.State.html), [Control](https://newton-physics.github.io/newton/stable/api/_generated/newton.Control.html), and optional
`Contacts` objects through [isaaclab_newton.physics.NewtonManager](https://isaac-sim.github.io/IsaacLab/release/3.0.0/source/api/lab_newton/isaaclab_newton.physics.html#isaaclab_newton.physics.NewtonManager). Their Warp arrays are
the live engine data, rather than values pulled into a separate per-asset view buffer. The model
owns structural and static arrays and labels; a state owns evolving simulation arrays; and a
control owns actuation inputs. Contacts are optional and depend on the active solver and collision
path.

### Lifecycle prerequisite

Access Newton data after the simulation context has initialized the physics backend and built its
model. Treat the objects as invalid after a model rebuild and reacquire them after Isaac Lab has
reinitialized the simulation. This API is intended for code that can own the necessary lifecycle
and synchronization responsibilities.

### Reuse Isaac Lab-owned access

Use the manager accessors to obtain the current Newton objects:

```python
from isaaclab_newton.physics import NewtonManager

model = NewtonManager.get_model()
state = NewtonManager.get_state_0()
control = NewtonManager.get_control()
contacts = NewtonManager.get_contacts()

body_poses = state.body_q
joint_forces = control.joint_f
```

[isaaclab_newton.physics.NewtonManager.get_model](https://isaac-sim.github.io/IsaacLab/release/3.0.0/source/api/lab_newton/isaaclab_newton.physics.html#isaaclab_newton.physics.NewtonManager.get_model) returns the active Newton physics model, or
`None` before the Newton backend has built it; render-only models used by visualizers are not
returned here. The write semantics in this section apply only when Newton is the active,
authoritative physics backend.

Isaac Lab's Newton-backed assets expose the same generic
`newton.selection.ArticulationView` selection helper. For example, reuse an articulation's
root selection instead of constructing the matching selection again:

```python
robot = scene["robot"]
selection = robot.root_view
joint_positions = selection.get_dof_positions(state)
```

Newton uses this generic, label-based selection concept for Isaac Lab articulations, rigid objects,
rigid-object collections, and cables. It is a selection helper over model indices, not per-asset
typed storage.

### Create raw access

Code that owns a matching model can construct its own selection from a model and a label pattern:

```python
from newton.selection import ArticulationView

selection = ArticulationView(
    model,
    pattern="/World/envs/env_*/Robot",
)
```

### Read/write semantics

Selections provide typed convenience methods as well as generic string-keyed
`get_attribute()` and `set_attribute()` methods. The generic methods expose
engine properties that do not have dedicated selection methods. Clone a
selected value before modifying it when you want the write to remain explicit:

```python
import warp as wp
from newton import ModelFlags
from isaaclab_newton.physics import NewtonManager

rolling_friction = wp.clone(
    selection.get_attribute("shape_material_mu_rolling", model)
)
# Modify rolling_friction with a Warp kernel before writing it back.
selection.set_attribute(
    "shape_material_mu_rolling",
    model,
    rolling_friction,
)
NewtonManager.add_model_change(ModelFlags.SHAPE_PROPERTIES)
```

The string names a Newton model attribute rather than an Isaac Lab field. This
example uses rolling friction because it has no dedicated selection method.
Notify the manager with the flag appropriate to the property changed; other
model writes can require a different flag. State writes that change generalized
coordinates instead require forward-kinematics synchronization through
`NewtonManager.invalidate_fk()` and `NewtonManager.forward()`.

### Ownership, synchronization, and invalidation

Direct writes bypass Isaac Lab caches and shape/order validation. Some Newton solvers swap current
and next state buffers, so reacquire
[isaaclab_newton.physics.NewtonManager.get_state_0](https://isaac-sim.github.io/IsaacLab/release/3.0.0/source/api/lab_newton/isaaclab_newton.physics.html#isaaclab_newton.physics.NewtonManager.get_state_0) when code needs the current authoritative
state on a later step. A selection can survive state-buffer swaps because it describes model
indices, but it must be recreated after a model rebuild. Solver-specific generalized- and
maximal-coordinate conventions remain authoritative.

### Authoritative references

* [Model reference](https://newton-physics.github.io/newton/stable/api/_generated/newton.Model.html)
* [State reference](https://newton-physics.github.io/newton/stable/api/_generated/newton.State.html)
* [Control reference](https://newton-physics.github.io/newton/stable/api/_generated/newton.Control.html)
* [ArticulationView selection reference](https://newton-physics.github.io/newton/stable/api/_generated/newton.selection.ArticulationView.html)
* [Newton articulation guide](https://newton-physics.github.io/newton/stable/concepts/articulations.html)