Repository files navigation

Warp is a Python framework for writing high-performance simulation and graphics code. Warp takesregular Python functions and JIT compiles them to efficient kernel code that can run on the CPU or GPU.

Warp is designed forspatial computingand comes with a rich set of primitives that make it easy to writeprograms for physics simulation, perception, robotics, and geometry processing. In addition, Warp kernelsare differentiable and can be used as part of machine-learning pipelines with frameworks such as PyTorch, JAX and Paddle.

Please refer to the projectDocumentation for API and language reference andCHANGELOG.md for release history.

A selection of physical simulations computed with Warp

Python version 3.9 or newer is recommended. Warp can run on x86-64 and ARMv8 CPUs on Windows, Linux, and macOS.GPU support requires a CUDA-capable NVIDIA GPU and driver (minimum GeForce GTX 9xx).

The easiest way to install Warp is fromPyPI:

pip install warp-lang

You can also usepip install warp-lang[extras] to install additional dependencies for running examples and USD-related features.

The binaries hosted on PyPI are currently built with the CUDA 12 runtime and thereforerequire a minimum version of the CUDA driver of 525.60.13 (Linux x86-64) or 528.33 (Windows x86-64).

If you require GPU support on a system with an older CUDA driver, you can build Warp from source orinstall wheels built with the CUDA 11.8 runtime from theGitHub Releases page.Copy the URL of the appropriate wheel file (warp-lang-{ver}+cu12-py3-none-{platform}.whl) and pass it tothepip install command, e.g.

The--force-reinstall option may need to be used to overwrite a previous installation.

• Warp packages built with CUDA Toolkit 11.x require NVIDIA driver 470 or newer.
• Warp packages built with CUDA Toolkit 12.x require NVIDIA driver 525 or newer.

This applies to pre-built packages distributed on PyPI and GitHub and also when building Warp from source.

Note that building Warp with the--quick flag changes the driver requirements. The quick build skips CUDA backward compatibility, so the minimum required driver is determined by the CUDA Toolkit version. Refer to thelatest CUDA Toolkit release notes to find the minimum required driver for different CUDA Toolkit versions (e.g.,this table from CUDA Toolkit 12.6).

Warp checks the installed driver during initialization and will report a warning if the driver is not suitable, e.g.:

Warp UserWarning:   Insufficient CUDA driver version.   The minimum required CUDA driver version is 12.0, but the installed CUDA driver version is 11.8.   Visit https://github.com/NVIDIA/warp/blob/main/README.md#installing for guidance.

This will make CUDA devices unavailable, but the CPU can still be used.

To remedy the situation there are a few options:

• Update the driver.
• Install a compatible pre-built Warp package.
• Build Warp from source using a CUDA Toolkit that's compatible with the installed driver.

An example first program that computes the lengths of random 3D vectors is given below:

importwarpaswpimportnumpyasnpnum_points=1024@wp.kerneldeflength(points:wp.array(dtype=wp.vec3),lengths:wp.array(dtype=float)):# thread indextid=wp.tid()# compute distance of each point from originlengths[tid]=wp.length(points[tid])# allocate an array of 3d pointspoints=wp.array(np.random.rand(num_points,3),dtype=wp.vec3)lengths=wp.zeros(num_points,dtype=float)# launch kernelwp.launch(kernel=length,dim=len(points),inputs=[points,lengths])print(lengths)

Thewarp/examples directory contains a number of scripts categorized under subdirectoriesthat show how to implement various simulation methods using the Warp API.Most examples will generate USD files containing time-sampled animations in the current working directory.Before running examples, users should ensure that theusd-core,matplotlib, andpyglet packages are installed using:

pip install warp-lang[extras]

These dependencies can also be manually installed using:

pip install usd-core matplotlib pyglet

Examples can be run from the command-line as follows:

python -m warp.examples.<example_subdir>.<example>

To browse the example source code, you can open the directory where the files are located like this:

python -m warp.examples.browse

Most examples can be run on either the CPU or a CUDA-capable device, but a handful require a CUDA-capable device. These are marked at the top of the example script.

USD files can be viewed or rendered insideNVIDIA Omniverse, Pixar's UsdView, and Blender. Note that Preview in macOS is not recommended as it has limited support for time-sampled animations.

Built-in unit tests can be run from the command-line as follows:

python -m warp.tests

dem	fluid	graph capture	marching cubes
mesh	nvdb	raycast	raymarch
sph	torch	wave

diffusion 3d	mixed elasticity	apic fluid	streamlines
convection diffusion	navier stokes	burgers	magnetostatics

bounce	cloth throw	diffray	drone
inverse kinematics	spring cage	trajectory	walker

cartpole	cloth	granular	granular collision sdf
jacobian ik	quadruped	rigid chain	rigid contact
rigid force	rigid gyroscopic	rigid soft contact	soft body

For developers who want to build the library themselves, the following tools are required:

• Microsoft Visual Studio 2019 upwards (Windows)
• GCC 9.4 upwards (Linux)
• CUDA Toolkit 11.5 or higher
• Git LFS installed

After cloning the repository, users should run:

python build_lib.py

Upon success, the script will output platform-specific binary files inwarp/bin/.The build script will look for the CUDA Toolkit in its default installation path.This path can be overridden by setting theCUDA_PATH environment variable. Alternatively,the path to the CUDA Toolkit can be passed to the build command as--cuda_path="...". After building, the Warp package should be installed using:

pip install -e .

This ensures that subsequent modifications to the library will be reflected in the Python package.

Please see the following resources for additional background on Warp:

• Product Page
• SIGGRAPH 2024 Course Slides
• GTC 2024 Presentation
• GTC 2022 Presentation
• GTC 2021 Presentation
• SIGGRAPH Asia 2021 Differentiable Simulation Course

The underlying technology in Warp has been used in a number of research projects at NVIDIA including the following publications:

• Accelerated Policy Learning with Parallel Differentiable Simulation - Xu, J., Makoviychuk, V., Narang, Y., Ramos, F., Matusik, W., Garg, A., & Macklin, M.(2022)
• DiSECt: Differentiable Simulator for Robotic Cutting - Heiden, E., Macklin, M., Narang, Y., Fox, D., Garg, A., & Ramos, F(2021)
• gradSim: Differentiable Simulation for System Identification and Visuomotor Control - Murthy, J. Krishna, Miles Macklin, Florian Golemo, Vikram Voleti, Linda Petrini, Martin Weiss, Breandan Considine et al.(2021)

See theFAQ in the Warp documentation.

Problems, questions, and feature requests can be opened onGitHub Issues.

The Warp team also monitors the#warp forum on the publicOmniverse Discord server, come chat with us!

Versions take the format X.Y.Z, similar toPython itself:

• Increments in X are reserved for major reworks of the project causing disruptive incompatibility (or reaching the 1.0 milestone).
• Increments in Y are for regular releases with a new set of features.
• Increments in Z are for bug fixes. In principle, there are no new features. Can be omitted if 0 or not relevant.

This is similar toSemantic Versioning but is less strict regarding backward compatibility.Like with Python, some breaking changes can be present between minor versions if well-documented and gradually introduced.

Note that prior to 0.11.0, this schema was not strictly adhered to.

Warp is provided under the NVIDIA Software License, please seeLICENSE.md for full license text.

Contributions and pull requests from the community are welcome and are taken under theterms described in theFeedback section ofLICENSE.md.Please see theContribution Guide for moreinformation on contributing to the development of Warp.

If you use Warp in your research, please use the following citation:

@misc{warp2022,title={Warp: A High-performance Python Framework for GPU Simulation and Graphics},author ={Miles Macklin},month ={March},year ={2022},note={NVIDIA GPU Technology Conference (GTC)},howpublished ={\url{https://github.com/nvidia/warp}}}