NVIDIA Warp

NVIDIA Warp is an open-source Python framework, first released by NVIDIA in March 2022, that takes ordinary Python functions and just-in-time compiles them into native kernels that run on the CPU or on a CUDA-capable GPU.^[1][2] Its distinguishing feature is that those kernels are differentiable: Warp emits a backward (adjoint) version of every kernel alongside the forward one, so gradients can be propagated through an entire physical simulation.^[5] Warp is the compute layer beneath Newton, Isaac Lab, and parts of NVIDIA Omniverse, and it has been licensed under Apache 2.0 since March 2025.^[1][13][26]

Scroll sideways for more →

Why a Python-to-CUDA compiler exists at all

Scientists and engineers write simulation code in Python because the language is fast to iterate in and because NumPy makes array mathematics readable. NumPy, however, is a whole-array language: every operation touches an entire array and materialises a new one. Simulation code is usually not shaped that way. A particle solver wants each thread to look up its own neighbours, branch on what it finds, and accumulate into a shared buffer. Expressing that as a sequence of whole-array operations either fails outright or spends most of its runtime moving temporaries through memory.

The fast alternative is to write the inner loop by hand in CUDA C++, which requires a second language, a build system, and knowledge of thread blocks, shared memory, and memory coalescing. Warp is one of several attempts to remove that second step. The programmer writes a per-thread function in Python, annotates it, and Warp parses the function's abstract syntax tree, generates equivalent C++ or CUDA C++, compiles it, and caches the result on disk so that the next run skips compilation.^[2][4] The Python is a description of one thread's work; the framework supplies the parallelism.

Programming model

A Warp kernel is a Python function decorated with @wp.kernel whose parameters are all statically typed. Kernels return nothing; results are written through array arguments. Each thread recovers its index with wp.tid(), and wp.launch() starts a grid of up to four dimensions.^[3][4] The example below is the quick-start from the project README, which advances one million gravitating particles.

import warp as wp
import numpy as np

num_particles = 1_000_000
dt = 0.01

@wp.kernel
def gravity_step(pos: wp.array[wp.vec3], vel: wp.array[wp.vec3]):
    i = wp.tid()
    position = pos[i]
    dist_sq = wp.length_sq(position) + 0.01
    acc = -1000.0 / dist_sq * wp.normalize(position)
    vel[i] = vel[i] + acc * dt
    pos[i] = pos[i] + vel[i] * dt

rng = np.random.default_rng(42)
positions = wp.array(rng.normal(size=(num_particles, 3)), dtype=wp.vec3)
velocities = wp.array(rng.normal(size=(num_particles, 3)), dtype=wp.vec3)

for _ in range(100):
    wp.launch(gravity_step, dim=num_particles, inputs=[positions, velocities])

print(positions.numpy())

Helper functions carry @wp.func and can be called from kernels or from Python. wp.array is the memory abstraction, allocated with wp.zeros(), wp.empty(), wp.full(), or built directly from a NumPy array or any object exposing __cuda_array_interface__. Warp performs no implicit numeric conversion; casts must be written out.^[4]

The built-in type system is aimed squarely at geometry and mechanics: vec2 through vec4 and custom-length vectors, mat22/mat33/mat44 and custom shapes, quaternions in i, j, k, w order, transform (a 7-component position plus rotation), and spatial vector and matrix types for six-degree-of-freedom rigid-body dynamics. User aggregates are declared with @wp.struct.^[4]

Warp also ships the acceleration structures that simulation code otherwise has to reimplement: wp.Mesh for triangle geometry with ray-cast and closest-point queries and a runtime refit(); wp.HashGrid for particle neighbour lookups; wp.Bvh for ray and axis-aligned-bounding-box queries; wp.Volume for sparse NanoVDB grids with trilinear sampling; and, on CUDA, hardware texture sampling through wp.Texture1D/2D/3D.^[4] These primitives are the reason Warp reads as a simulation framework rather than a generic GPU compiler.

Tiles

Warp 1.5.0, released in December 2024, added a second, block-level programming model on top of the per-thread one. A tile is a two-dimensional block of data that the threads of a CUDA block cooperate on, which lets a kernel reach hardware that per-thread code cannot address efficiently. wp.tile_matmul() dispatches to Tensor Core instructions according to element type and shape, using NVIDIA's device-side cuBLASDx and cuFFTDx libraries, so a single kernel can fuse a GEMM, an FFT, and elementwise work without round-tripping through global memory.^[19] NVIDIA reported that Warp tile GEMM reached 70 to 80 percent of cuBLAS throughput for larger matrices on an A100 80GB, and that a batched quadruped forward-dynamics solve written with tiles ran about 4 times faster than an equivalent PyTorch implementation.^[19] Both figures are NVIDIA's own.

Differentiability

Warp generates a backward (adjoint) kernel for every forward kernel from the same Python source, so reverse-mode differentiation happens at the level of the generated native code rather than by tracing array operations. Arrays that participate in gradients are created with requires_grad=True, and a wp.Tape records the launches so they can be replayed in reverse:^[2][5]

tape = wp.Tape()
with tape:
    wp.launch(forward_step, dim=n, inputs=[params, state])
tape.backward(loss)
grad = params.grad

Automatic differentiation through a simulator is what makes gradient-based methods available for problems that would otherwise be attacked by black-box search. If a policy, a material parameter, or a mechanical design sits upstream of a physics rollout, an adjoint pass tells the optimiser which direction to move rather than forcing it to sample. That is the basis of differentiable simulation work in robot learning, system identification (recovering stiffness, friction, or mass from observed motion), and inverse design.^[2][21]

The documented caveats matter as much as the capability. Warp's differentiability page warns that writing to an array after reading from it across kernel launches breaks gradient correctness, because the earlier value is no longer available for the backward pass; the verify_autograd_array_access configuration flag exists to detect exactly that. In-place += and -= are differentiated correctly, but in-place multiplication and division are not. Dynamic loops do not replay their intermediate values, so adjoints that depend on loop state come out wrong, whereas statically unrolled loops are fine. Vector, matrix, and quaternion components may be assigned only once. For verification, Warp provides jacobian(), jacobian_fd(), and gradcheck(), which compares autodiff results against finite differences, plus Tape.visualize() for dumping the recorded graph.^[5] Custom derivatives can be supplied with @wp.func_grad and @wp.func_replay.^[5]

Interoperability

Warp is designed to sit inside an existing Python numerical stack rather than replace it. It accepts external arrays through __array__, __array_interface__, and __cuda_array_interface__, and implements DLPack to the Python Array API standard v2022.12.^[6]

Scroll sideways for more →

The PyTorch bridge has a documented performance trap worth knowing: PyTorch allocates gradient buffers lazily, so passing a tensor with requires_grad=True into wp.from_torch() forces an allocation and a device-wide synchronisation. Detaching the tensor, passing requires_grad=False, or pre-allocating the gradient avoids it, and NVIDIA reports 3 to 4 times better conversion throughput as a result.^[7]

For launch-bound workloads, Warp exposes CUDA graph capture, which records a sequence of launches once and replays it as a single graph, removing per-launch Python dispatch overhead:^[4]

with wp.ScopedCapture(device="cuda") as capture:
    for i in range(100):
        wp.launch(kernel, dim=n, inputs=[a, b], device="cuda")
wp.capture_launch(capture.graph)

Conditional nodes are available through wp.capture_if() and wp.capture_while() on CUDA 12.4 and newer, graphs can be serialised with wp.capture_save() and replayed later or from C++, and the same API produces deferred CPU graphs. Multi-GPU work is expressed with explicit device arguments, wp.Stream, and wp.Event.^[4] Warp 1.15.0 added an opt-in deterministic execution mode for atomic operations, addressing the run-to-run variation that floating-point atomics normally cause, including in generated backward passes.^[13]

Domain modules

Beyond the core language, Warp ships several libraries written in Warp itself. warp.fem is a finite-element toolkit for partial differential equations, built around a Geometry (regular grids, NanoVDB volumes, or unstructured triangle, quad, tetrahedral, and hexahedral meshes), a FunctionSpace supplying shape functions (Lagrange and Serendipity bases up to order 3, Nedelec and Raviart-Thomas vector elements, B-splines), and integrands that are Warp kernels assembled by integrate() and interpolate(). Its examples cover diffusion, Stokes and Navier-Stokes flow, elasticity, magnetostatics, and PDE-constrained shape optimisation.^[12] warp.sparse provides block-sparse (BSR and CSR) matrices and preconditioned iterative solvers, warp.optim supplies Adam and SGD, warp.autograd holds the gradient-checking tools, and warp.render writes OpenUSD or OpenGL output.^[3][12]

warp.sim, an early rigid-body and cloth simulation module, was deprecated in Warp 1.8.0 (July 2025) and removed in 1.10.0 (November 2025). NVIDIA's stated reason is that it was superseded by Newton, which lives in a separate package with a different API.^[13]

Licensing history

Warp's license changed twice, and the change is easy to get wrong because the intermediate step is often skipped.

Scroll sideways for more →

The Apache 2.0 relicensing shipped as the sole change in v1.6.2, three weeks before Warp 1.7.0 and in the same month as GTC 2025, where NVIDIA announced Newton.^[13][16] One dependency remains outside Apache 2.0: NVIDIA libmathdx, downloaded automatically in source builds, is governed by a separate NVIDIA Software License Agreement.^[1]

Releases now arrive roughly monthly. NVIDIA's support policy says feature releases may include breaking changes and that deprecated features get at least four months of notice, about four release cycles.^[10] PyPI wheels are currently built against CUDA 12.9; CUDA 12.x builds need driver 525 or newer and Maxwell-class hardware, CUDA 13.x builds need driver 580 or newer and Turing-class hardware.^[10]

What is built on Warp

Scroll sideways for more →

Adoption

As of 31 July 2026 the GitHub repository had 6,916 stars, 575 forks, and 86 contributors, with 253 open issues.^[16] The warp-lang package recorded 924,845 downloads in the preceding 30 days.^[15] Warp's own documentation maintains a bibliography of work that uses it: 120 entries as of the same date, spanning 2021 to 2026 and weighted toward robotics, differentiable physics, and physics-based graphics.^[11] Early entries include gradSim (2021) and DiSECt (2021), both co-authored by Warp's own author Miles Macklin; later ones include Kamino, Disney Research's multi-body solver that became one of Newton's rigid-body backends, and cuRoboV2 from NVIDIA's motion planning group.^[11] Rewarped, the differentiable multiphysics platform introduced alongside the SAPO reinforcement-learning algorithm at ICLR 2025, is a representative external example from that list.^[11][30]

NVIDIA's own product page for Warp lists computer-aided engineering at Autodesk Research and warehouse-automation sensor simulation at Amazon among its named use cases.^[22] Industrial users named by NVIDIA and by the users themselves include:

• Amazon Robotics, whose Sensor Workbench simulator for warehouse barcode sensing states that "our parallel-processing pipeline leverages NVIDIA's Warp library with custom computation kernels to maximize GPU utilization", keeping 3D objects resident in GPU memory to avoid redundant transfers.^[23]
• Autodesk Research, whose XLB lattice-Boltzmann fluid solver NVIDIA reports ran about 8 times faster on Warp than on JAX on a single A100, using 2.5 to 3 times less memory.^[20][21]
• C-Infinity, whose AutoAssembler NVIDIA reports achieved a 669 times speedup over optimised CPU baselines on an L4 GPU.^[21]

The speedup figures in that list are vendor benchmarks tied to specific hardware and workloads, not independent measurements.

Comparison with adjacent tools

Warp overlaps with several projects that solve neighbouring problems. None of them is a strict superset of another.

Scroll sideways for more →

The practical distinctions run along two axes. On portability, Taichi, Genesis, and JAX target multiple vendors' accelerators while Warp's GPU path is CUDA-only. On abstraction level, JAX and CuPy work at whole-array granularity, which suits dense linear algebra and neural networks, while Warp, Taichi, and Numba's CUDA target expose per-thread control, which suits irregular simulation. Numba and CuPy do not differentiate kernels at all, so a differentiable simulator written on them needs its adjoints written by hand, which is the labour that Warp, Taichi, and JAX remove. Taichi remains the closest match in design; its maintainers stated in June 2024 that "our active development pace has moderated" while the project stays maintained, and its most recent release, 1.7.4, was uploaded to PyPI on 31 July 2025.^[34][37]

Limitations

Warp's own documentation is candid about what does not work. Inside a kernel, the supported Python is a subset: no lambdas, no list comprehensions, no exceptions, no recursion, no eval(), and no lists, sets, or dictionaries. Strings cannot be passed into kernels and no complex-number types exist. Arrays are capped at four dimensions with each dimension under 2^31-1, and launch grids are bound by the same 32-bit limit. Structs cannot inherit or hold typing.Any members, and wp.tid() cannot be called from a @wp.func.^[9] Scalar mathematics deliberately diverges from Python in the sign convention of the modulus operator, in rounding away from zero rather than banker's rounding, and in clamping the inverse trigonometric functions.^[9]

Compilation is the other friction point. The first launch of a module pays JIT compilation cost, and while results are cached to disk, concurrent processes can collide on the cache directory, and Warp's cache is separate from the CUDA driver's own compute cache, so clearing one does not clear the other.^[4][9] CUDA contexts cannot be inherited across a fork().^[9] Debugging kernels is harder than debugging Python, since the code that actually executes is generated C++ or CUDA; Warp's answer is a dedicated debugging guide, optional AddressSanitizer builds for CPU kernels that surface out-of-bounds wp.array access, and the gradient-verification helpers already described.^[9][13]

The deeper constraint is that GPU acceleration only holds while data stays on the GPU. A pipeline that converts to NumPy in a Python loop, or that trips the PyTorch lazy-gradient synchronisation described above, will not see the speedups NVIDIA advertises.^[7]

See also

• NVIDIA Newton
• Isaac Lab
• NVIDIA Isaac Sim
• NVIDIA Omniverse
• NVIDIA Isaac for Healthcare
• MuJoCo
• Genesis
• Automatic differentiation

References

1. ^"NVIDIA/warp: A Python framework for GPU-accelerated simulation, robotics, and machine learning", repository README, GitHub, accessed 31 July 2026. github.com/...warp
2. ^Miles Macklin and Fred Oh, "Creating Differentiable Graphics and Physics Simulation in Python with NVIDIA Warp", NVIDIA Technical Blog, 23 March 2022. developer.nvidia.com/...in-python-with-nvidia-warp
3. ^"Basics", Warp 1.15.0 documentation, NVIDIA, accessed 31 July 2026. nvidia.github.io/...basics
4. ^"Runtime", Warp 1.15.0 documentation, NVIDIA, accessed 31 July 2026. nvidia.github.io/...runtime
5. ^"Differentiability", Warp 1.15.0 documentation, NVIDIA, accessed 31 July 2026. nvidia.github.io/...differentiability
6. ^"Interoperability", Warp 1.15.0 documentation, NVIDIA, accessed 31 July 2026. nvidia.github.io/...interoperability
7. ^"PyTorch Interoperability", Warp 1.15.0 documentation, NVIDIA, accessed 31 July 2026. nvidia.github.io/...interoperability_pytorch
8. ^"JAX Interoperability", Warp 1.15.0 documentation, NVIDIA, accessed 31 July 2026. nvidia.github.io/...interoperability_jax
9. ^"Limitations", Warp 1.15.0 documentation, NVIDIA, accessed 31 July 2026. nvidia.github.io/...limitations
10. ^"Compatibility and Support", Warp 1.15.0 documentation, NVIDIA, accessed 31 July 2026. nvidia.github.io/...compatibility
11. ^"Publications using Warp", Warp 1.15.0 documentation, NVIDIA, accessed 31 July 2026 (120 entries counted). nvidia.github.io/...publications
12. ^"FEM Toolkit", Warp 1.15.0 documentation, NVIDIA, accessed 31 July 2026. nvidia.github.io/...fem
13. ^"Changelog", NVIDIA/warp, GitHub, accessed 31 July 2026. github.com/...CHANGELOG.md
14. ^"CITATION.cff", NVIDIA/warp, GitHub, accessed 31 July 2026. raw.githubusercontent.com/...CITATION.cff
15. ^"warp-lang", PyPI, accessed 31 July 2026. pypi.org/...warp-lang
16. ^"NVIDIA/warp" repository record and release list, GitHub REST API, accessed 31 July 2026. api.github.com/...warp
17. ^"NVIDIA Source Code License for Warp", LICENSE.md at commit f88594e2b, NVIDIA/warp, GitHub, 15 March 2022. raw.githubusercontent.com/...LICENSE.md
18. ^"LICENSE.md" (Apache License, Version 2.0), NVIDIA/warp, GitHub, accessed 31 July 2026. raw.githubusercontent.com/...LICENSE.md
19. ^Miles Macklin, Leopold Cambier and Eric Shi, "Introducing Tile-Based Programming in Warp 1.5.0", NVIDIA Technical Blog, 14 December 2024. developer.nvidia.com/...-programming-in-warp-1-5-0
20. ^"NVIDIA Warp Accelerates Scientific Computing in Python", NVIDIA Blog, 5 December 2024. blogs.nvidia.com/...es-scientific-computing-python
21. ^Sheel Nidhan, Eric Shi, Neil Ashton, Zach Corse and Mohammad Mohajerani, "Build Accelerated, Differentiable Computational Physics Code for AI with NVIDIA Warp", NVIDIA Technical Blog, 12 March 2026. developer.nvidia.com/...de-for-ai-with-nvidia-warp
22. ^"Warp Python", NVIDIA Developer, accessed 31 July 2026. developer.nvidia.com/warp-python
23. ^Deniz Akyildiz and Hunter Liu, "Revolutionizing warehouse automation with scientific simulation", Amazon Science, 26 August 2025. amazon.science/...ation-with-scientific-simulation
24. ^"Warp", Omniverse Extensions documentation, NVIDIA, accessed 31 July 2026. docs.omniverse.nvidia.com/...ext_warp
25. ^"MuJoCo XLA (MJX)", MuJoCo documentation, Google DeepMind, accessed 31 July 2026. mujoco.readthedocs.io/...mjx
26. ^"Linux Foundation Announces Contribution of Newton by Disney Research, Google DeepMind and NVIDIA to Accelerate Open Robot Learning", The Linux Foundation, 29 September 2025. linuxfoundation.org/...elerate-open-robot-learning
27. ^"Isaac Lab 3.0 Beta", release v3.0.0-beta notes, isaac-sim/IsaacLab, GitHub, 17 March 2026. github.com/...v3.0.0-beta
28. ^Cristiana Dinea et al., "Developing Healthcare Robotics with GPU-Native Medical Physics Simulation", NVIDIA Technical Blog, 28 July 2026. developer.nvidia.com/...medical-physics-simulation
29. ^"taichi-dev/taichi: Productive, portable, and performant GPU programming in Python", repository README and record, GitHub, accessed 31 July 2026. github.com/...taichi
30. ^Eliot Xing, Vernon Luk and Jean Oh, "Stabilizing Reinforcement Learning in Differentiable Multiphysics Simulation", arXiv:2412.12089, 16 December 2024 (ICLR 2025 Spotlight). arxiv.org/...2412.12089
31. ^"numba/numba: NumPy aware dynamic Python compiler using LLVM", repository record, GitHub, accessed 31 July 2026. github.com/...numba
32. ^"cupy/cupy: NumPy and SciPy for GPU", repository record, GitHub, accessed 31 July 2026. github.com/...cupy
33. ^"Genesis-Embodied-AI/Genesis", repository README, GitHub, accessed 31 July 2026. github.com/...Genesis
34. ^"Development on Taichi has halted :-( Any recommended alternatives from the community?", discussion #8506, taichi-dev/taichi, GitHub, June 2024. github.com/...8506
35. ^"jax-ml/jax: Composable transformations of Python+NumPy programs", repository record, GitHub, accessed 31 July 2026. github.com/...jax
36. ^"pytorch/pytorch: Tensors and Dynamic neural networks in Python with strong GPU acceleration", repository record, GitHub, accessed 31 July 2026. github.com/...pytorch
37. ^"taichi", release history, PyPI, accessed 31 July 2026. pypi.org/...taichi
38. ^"google-deepmind/mujoco: Multi-Joint dynamics with Contact", repository record, GitHub, accessed 31 July 2026. github.com/...mujoco