Installation#

This guide covers the recommended way to install Newton from PyPI. For installing from source or using uv, see the Development guide.

System Requirements#

Minimum Requirements#

Requirement	Minimum	Notes
Python	3.10	3.11+ recommended
OS	Linux (x86-64, aarch64), Windows (x86-64), or macOS (CPU only)	macOS has no GPU acceleration
NVIDIA GPU	Compute capability 5.0+ (Maxwell)	Any GeForce GTX 9xx or newer
NVIDIA Driver	545 or newer (CUDA 12)	550 or newer (CUDA 12.4) recommended for best performance
CUDA	12, 13	No local CUDA Toolkit required; Warp bundles its own runtime. See CUDA Compatibility for version-specific notes.

Platform-Specific Requirements#

Linux aarch64 (ARM64)

On ARM64 Linux systems (such as NVIDIA Jetson Thor and DGX Spark), installing the examples extras currently requires X11 development libraries to build imgui_bundle from source:

sudo apt-get update
sudo apt-get install -y libx11-dev libxrandr-dev libxinerama-dev libxcursor-dev libxi-dev libgl1-mesa-dev

For tested configurations and CUDA version-specific notes, see Compatibility and Support.

Installing Newton#

Basic installation:

pip install newton

Install with the examples extra to run the built-in examples (includes simulation and visualization dependencies):

pip install "newton[examples]"

We recommend installing Newton inside a virtual environment to avoid conflicts with other packages:

macOS / Linux

python -m venv .venv
source .venv/bin/activate
pip install "newton[examples]"

Windows (console)

python -m venv .venv
.venv\Scripts\activate.bat
pip install "newton[examples]"

Windows (PowerShell)

python -m venv .venv
.venv\Scripts\Activate.ps1
pip install "newton[examples]"

Note

Users on Python 3.10 may experience issues when installing imgui_bundle (a dependency of the examples extra). If you encounter installation errors, we recommend upgrading to a later Python version, or follow the Development guide to install Newton using uv.

Running Examples#

After installing Newton with the examples extra, launch the default basic_pendulum example — you can browse other examples from the side panel:

python -m newton.examples

Run an example that runs RL policy inference. Choose the extra matching your NVIDIA driver’s CUDA support (torch-cu12 for CUDA 12.x, torch-cu13 for CUDA 13.x) and the corresponding pytorch wheel (e.g, 128 for CUDA 12.8); run nvidia-smi to check the supported CUDA version (shown in the top-right corner of the output):

pip install newton[torch-cu12] --extra-index-url https://download.pytorch.org/whl/cu128
python -m newton.examples robot_anymal_c_walk

Note

The torch-cu12 extra installs PyTorch built against CUDA 12.8. If your driver only supports CUDA 12.4 or 12.5 (check with nvidia-smi), you need to install PyTorch 2.6.0 manually instead:

pip install "newton[examples]"
pip install torch==2.6.0 --extra-index-url https://download.pytorch.org/whl/cu124

See a list of all available examples (also browsable from the viewer’s side panel):

python -m newton.examples --list

Quick Start#

After installing Newton with the base package, you can build models, create solvers, and run simulations directly from Python. This example uses only the required dependencies installed by pip install newton:

import warp as wp
import newton

# Build a model
builder = newton.ModelBuilder()
body = builder.add_body(
    xform=wp.transform((0.0, 1.0, 0.0), wp.quat_identity()),
    mass=1.0,
)
builder.add_shape_sphere(body, radius=0.25)
builder.add_ground_plane()
model = builder.finalize()

# Create a solver and allocate state
solver = newton.solvers.SolverXPBD(model)
state_0 = model.state()
state_1 = model.state()
control = model.control()
contacts = model.contacts()

newton.eval_fk(model, model.joint_q, model.joint_qd, state_0)

# Step the simulation
for step in range(120):
    state_0.clear_forces()
    model.collide(state_0, contacts)
    solver.step(state_0, state_1, control, contacts, 1.0 / 60.0)
    state_0, state_1 = state_1, state_0

The following workflow uses SolverMuJoCo, so install the optional simulation dependencies first:

pip install "newton[sim]"

Then build a robot template, replicate it across many worlds, and step them all simultaneously on the GPU:

# Build a single robot template
template = newton.ModelBuilder()
template.add_mjcf("humanoid.xml")

# Replicate into parallel worlds
builder = newton.ModelBuilder()
builder.replicate(template, world_count=1024)
builder.add_ground_plane()
model = builder.finalize()

# The solver steps all 1024 worlds in parallel
solver = newton.solvers.SolverMuJoCo(model)

See the Newton Physics Documentation guide and Isaac Lab Integration for more details.

Extra Dependencies#

Newton’s only mandatory dependency is NVIDIA Warp. Additional optional dependency sets are defined in pyproject.toml:

Set	Purpose
`sim`	Simulation dependencies, including MuJoCo
`importers`	Asset import and mesh processing dependencies
`remesh`	Remeshing dependencies (Open3D, pyfqmr) for `newton.utils.remesh_mesh()`
`examples`	Dependencies for running examples, including visualization (includes `sim` + `importers`)
`torch-cu12`	PyTorch (CUDA 12.8+) for running RL policy examples (includes `examples`); see note above for CUDA 12.4–12.5
`torch-cu13`	PyTorch (CUDA 13) for running RL policy examples (includes `examples`)
`notebook`	Jupyter notebook support with Rerun visualization (includes `examples`)
`dev`	Dependencies for development and testing (includes `examples`)
`docs`	Dependencies for building the documentation

Some extras transitively include others. For example, examples pulls in both sim and importers, and dev pulls in examples. You only need to install the most specific set for your use case.

Next Steps#

Run python -m newton.examples --list to see all available examples and check out the Visualization guide to learn how to interact with the example simulations.
See the Compatibility and Support guide for Newton’s supported platforms, versioning scheme, and deprecation policy.
Check out the Development guide to learn how to contribute to Newton, or how to use alternative installation methods.