# NVIDIA Warp

> Source: https://aiwiki.ai/wiki/nvidia_warp
> Updated: 2026-07-31
> Categories: Developer Tools, NVIDIA, Open Source AI, Robotics
> License: CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/) - attribute to "AI Wiki (aiwiki.ai)"
> Cite as: AI Wiki. "NVIDIA Warp." aiwiki.ai, 31 Jul 2026. https://aiwiki.ai/wiki/nvidia_warp
> From AI Wiki (https://aiwiki.ai), the free encyclopedia of artificial intelligence. Reuse freely with attribution.

**NVIDIA Warp** is an open-source [Python](https://aiwiki.ai/wiki/python) framework, first released by [NVIDIA](https://aiwiki.ai/wiki/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](https://aiwiki.ai/wiki/cuda)-capable [GPU](https://aiwiki.ai/wiki/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](https://aiwiki.ai/wiki/simulation).[5] Warp is the compute layer beneath [Newton](https://aiwiki.ai/wiki/nvidia_newton), [Isaac Lab](https://aiwiki.ai/wiki/isaac_lab), and parts of [NVIDIA Omniverse](https://aiwiki.ai/wiki/nvidia_omniverse), and it has been licensed under [Apache 2.0](https://aiwiki.ai/wiki/apache_license) since March 2025.[1][13][26]

| Field | Value |
|---|---|
| Developer | NVIDIA |
| First public release | v0.1.25-alpha, 22 March 2022[16] |
| Current release | 1.15.0, 7 July 2026[15][16] |
| License | Apache License 2.0 (since v1.6.2, 7 March 2025)[13][18] |
| Package name | `warp-lang` (PyPI)[15] |
| Language surface | Python 3.10 or newer; kernels compile to C++ and CUDA C++[1][10] |
| Targets | x86-64 and ARMv8 CPUs (Windows, Linux, macOS); NVIDIA GPUs from Maxwell (sm_52) upward[1][10] |
| Repository | `github.com/NVIDIA/warp`[1] |
| GitHub stars | 6,916 (accessed 31 July 2026)[16] |
| Canonical citation | Miles Macklin, "Warp: A High-performance Python Framework for GPU Simulation and Graphics", NVIDIA GTC, March 2022[14] |

## 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](https://aiwiki.ai/wiki/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.

```python
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](https://aiwiki.ai/wiki/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]

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

[Automatic differentiation](https://aiwiki.ai/wiki/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](https://aiwiki.ai/wiki/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]

| Framework | Bridge | Notes |
|---|---|---|
| [NumPy](https://aiwiki.ai/wiki/numpy) | `wp.from_numpy()`, `array.numpy()` | Zero-copy for CPU arrays; a CUDA array must be copied through a host buffer[6] |
| [PyTorch](https://aiwiki.ai/wiki/pytorch) | `wp.from_torch()`, `wp.to_torch()` | Zero-copy on GPU; gradient arrays are carried across; `wp.device_to_torch()` and `wp.dtype_to_torch()` map devices and types[7] |
| [JAX](https://aiwiki.ai/wiki/jax) | `wp.from_jax()`, `wp.to_jax()`, `wp.jax_kernel()`, `wp.jax_callable()` | Kernels are exposed as JAX primitives through the FFI; backward support is enabled with `enable_backward=True` and documented as experimental; `shard_map` allows multi-GPU sharding[8] |
| Paddle | `wp.from_paddle()`, `wp.to_paddle()` | Zero-copy, gradient-preserving, with stream conversion helpers[6] |
| CuPy, Numba | `__cuda_array_interface__` | Zero-copy buffer sharing without gradient propagation[6] |

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]

```python
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.

| Version | Date | License | Effect |
|---|---|---|---|
| Initial release | 15 March 2022 (LICENSE.md added) | NVIDIA Source Code License for Warp | Section 3.3 limited use to "non-commercially", defined as "for research or evaluation purposes only", with NVIDIA and its affiliates exempted[17] |
| v0.13.0 | 16 February 2024 | NVIDIA Software License Agreement | Commercial use permitted under a proprietary NVIDIA agreement[13] |
| v1.6.2 | 7 March 2025 | Apache License 2.0 | Standard permissive [open-source](https://aiwiki.ai/wiki/open_source) terms[13][18] |

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

| Project | Relationship |
|---|---|
| [Newton](https://aiwiki.ai/wiki/nvidia_newton) | Open GPU physics engine co-developed by NVIDIA, [Google DeepMind](https://aiwiki.ai/wiki/google_deepmind), and Disney Research, contributed to the [Linux Foundation](https://aiwiki.ai/wiki/linux_foundation) on 29 September 2025. The Linux Foundation announcement states it is built on NVIDIA Warp and OpenUSD.[26] |
| [Isaac Lab](https://aiwiki.ai/wiki/isaac_lab) | GPU-parallel [robot learning](https://aiwiki.ai/wiki/robot_learning) framework. The Isaac Lab 3.0 beta, published 17 March 2026, moved to "Warp-native data pipelines" in which every `.data.*` property returns a `wp.array` instead of a PyTorch tensor, alongside a Newton physics backend[27] |
| [Isaac Sim](https://aiwiki.ai/wiki/nvidia_isaac_sim) and [Omniverse](https://aiwiki.ai/wiki/nvidia_omniverse) | The `omni.warp.core` extension installs Warp into the Kit Python environment; `omni.warp` adds OmniGraph Warp Kernel Nodes and samples, so graph nodes can be authored in Python and JIT compiled at runtime[24] |
| [Isaac for Healthcare](https://aiwiki.ai/wiki/nvidia_isaac_for_healthcare) | Both classical solvers in NVIDIA's Medical Physics Simulation framework are written in Python using Warp and Newton[28] |
| MuJoCo Warp (MJX-Warp) | A Warp-based implementation of [MuJoCo](https://aiwiki.ai/wiki/mujoco) physics from Google DeepMind. MuJoCo's documentation calls it "the most fully-featured implementation of MuJoCo for hardware accelerated devices" but notes that, unlike the pure-JAX MJX, MJX-Warp is not differentiable and has "no immediate plans to support auto-diff"[25] |

## 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](https://aiwiki.ai/wiki/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](https://aiwiki.ai/wiki/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](https://aiwiki.ai/wiki/nvidia_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.

| Tool | Language surface | Differentiable | Target hardware | License |
|---|---|---|---|---|
| NVIDIA Warp | Python subset compiled to C++ and CUDA C++[1] | Yes, reverse-mode adjoint kernels[5] | NVIDIA GPUs, x86-64 and ARMv8 CPUs[1] | Apache 2.0[18] |
| Taichi | Python-embedded DSL, JIT compiled to native backends[29] | Yes, listed as differentiable programming[29] | CUDA, Vulkan, OpenGL 4.3+, Apple Metal, x64 and ARM CPUs, experimental WebAssembly[29] | Apache 2.0[29] |
| [JAX](https://aiwiki.ai/wiki/jax) | NumPy-style whole-array Python traced to XLA[35] | Yes, forward and reverse mode[35] | GPU, TPU, CPU via XLA[25][35] | Apache 2.0[35] |
| Numba | Python subset compiled by LLVM, including a CUDA target[31] | No | CPU and NVIDIA GPUs[31] | BSD 2-Clause[31] |
| CuPy | NumPy and SciPy-compatible array API[32] | No | NVIDIA GPUs (CUDA) and AMD GPUs (ROCm)[32] | MIT[32] |
| PyTorch custom CUDA extensions | Hand-written CUDA C++ bound into Python[36] | Only what the author writes | Whatever the CUDA code targets | BSD-style, see repository LICENSE[36] |
| MuJoCo MJX | JAX (MJX-JAX) or Warp (MJX-Warp)[25] | MJX-JAX yes, MJX-Warp no[25] | NVIDIA and AMD GPUs, Apple Silicon, TPU[25] | Apache 2.0[38] |
| Genesis | Python over the Quadrants compiler, forked from Taichi in June 2025[33] | Yes (autodiff carried through the compiler)[33] | CUDA, ROCm, Metal, Vulkan, x86, ARM64[33] | Apache 2.0[33] |

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](https://aiwiki.ai/wiki/nvidia_newton)
- [Isaac Lab](https://aiwiki.ai/wiki/isaac_lab)
- [NVIDIA Isaac Sim](https://aiwiki.ai/wiki/nvidia_isaac_sim)
- [NVIDIA Omniverse](https://aiwiki.ai/wiki/nvidia_omniverse)
- [NVIDIA Isaac for Healthcare](https://aiwiki.ai/wiki/nvidia_isaac_for_healthcare)
- [MuJoCo](https://aiwiki.ai/wiki/mujoco)
- [Genesis](https://aiwiki.ai/wiki/genesis_simulator)
- [Automatic differentiation](https://aiwiki.ai/wiki/automatic_differentiation)

## References

1. "NVIDIA/warp: A Python framework for GPU-accelerated simulation, robotics, and machine learning", repository README, GitHub, accessed 31 July 2026. https://github.com/NVIDIA/warp
2. Miles Macklin and Fred Oh, "Creating Differentiable Graphics and Physics Simulation in Python with NVIDIA Warp", NVIDIA Technical Blog, 23 March 2022. https://developer.nvidia.com/blog/creating-differentiable-graphics-and-physics-simulation-in-python-with-nvidia-warp/
3. "Basics", Warp 1.15.0 documentation, NVIDIA, accessed 31 July 2026. https://nvidia.github.io/warp/stable/user_guide/basics.html
4. "Runtime", Warp 1.15.0 documentation, NVIDIA, accessed 31 July 2026. https://nvidia.github.io/warp/stable/user_guide/runtime.html
5. "Differentiability", Warp 1.15.0 documentation, NVIDIA, accessed 31 July 2026. https://nvidia.github.io/warp/stable/user_guide/differentiability.html
6. "Interoperability", Warp 1.15.0 documentation, NVIDIA, accessed 31 July 2026. https://nvidia.github.io/warp/stable/user_guide/interoperability.html
7. "PyTorch Interoperability", Warp 1.15.0 documentation, NVIDIA, accessed 31 July 2026. https://nvidia.github.io/warp/stable/user_guide/interoperability_pytorch.html
8. "JAX Interoperability", Warp 1.15.0 documentation, NVIDIA, accessed 31 July 2026. https://nvidia.github.io/warp/stable/user_guide/interoperability_jax.html
9. "Limitations", Warp 1.15.0 documentation, NVIDIA, accessed 31 July 2026. https://nvidia.github.io/warp/stable/user_guide/limitations.html
10. "Compatibility and Support", Warp 1.15.0 documentation, NVIDIA, accessed 31 July 2026. https://nvidia.github.io/warp/stable/user_guide/compatibility.html
11. "Publications using Warp", Warp 1.15.0 documentation, NVIDIA, accessed 31 July 2026 (120 entries counted). https://nvidia.github.io/warp/stable/user_guide/publications.html
12. "FEM Toolkit", Warp 1.15.0 documentation, NVIDIA, accessed 31 July 2026. https://nvidia.github.io/warp/stable/domain_modules/fem.html
13. "Changelog", NVIDIA/warp, GitHub, accessed 31 July 2026. https://github.com/NVIDIA/warp/blob/main/CHANGELOG.md
14. "CITATION.cff", NVIDIA/warp, GitHub, accessed 31 July 2026. https://raw.githubusercontent.com/NVIDIA/warp/main/CITATION.cff
15. "warp-lang", PyPI, accessed 31 July 2026. https://pypi.org/project/warp-lang/
16. "NVIDIA/warp" repository record and release list, GitHub REST API, accessed 31 July 2026. https://api.github.com/repos/NVIDIA/warp
17. "NVIDIA Source Code License for Warp", LICENSE.md at commit f88594e2b, NVIDIA/warp, GitHub, 15 March 2022. https://raw.githubusercontent.com/NVIDIA/warp/f88594e2b/LICENSE.md
18. "LICENSE.md" (Apache License, Version 2.0), NVIDIA/warp, GitHub, accessed 31 July 2026. https://raw.githubusercontent.com/NVIDIA/warp/main/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. https://developer.nvidia.com/blog/introducing-tile-based-programming-in-warp-1-5-0/
20. "NVIDIA Warp Accelerates Scientific Computing in Python", NVIDIA Blog, 5 December 2024. https://blogs.nvidia.com/blog/warp-accelerates-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. https://developer.nvidia.com/blog/build-accelerated-differentiable-computational-physics-code-for-ai-with-nvidia-warp/
22. "Warp Python", NVIDIA Developer, accessed 31 July 2026. https://developer.nvidia.com/warp-python
23. Deniz Akyildiz and Hunter Liu, "Revolutionizing warehouse automation with scientific simulation", Amazon Science, 26 August 2025. https://www.amazon.science/blog/revolutionizing-warehouse-automation-with-scientific-simulation
24. "Warp", Omniverse Extensions documentation, NVIDIA, accessed 31 July 2026. https://docs.omniverse.nvidia.com/extensions/latest/ext_warp.html
25. "MuJoCo XLA (MJX)", MuJoCo documentation, Google DeepMind, accessed 31 July 2026. https://mujoco.readthedocs.io/en/stable/mjx.html
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. https://www.linuxfoundation.org/press/linux-foundation-announces-contribution-of-newton-by-disney-research-google-deepmind-and-nvidia-to-accelerate-open-robot-learning
27. "Isaac Lab 3.0 Beta", release v3.0.0-beta notes, isaac-sim/IsaacLab, GitHub, 17 March 2026. https://github.com/isaac-sim/IsaacLab/releases/tag/v3.0.0-beta
28. Cristiana Dinea et al., "Developing Healthcare Robotics with GPU-Native Medical Physics Simulation", NVIDIA Technical Blog, 28 July 2026. https://developer.nvidia.com/blog/developing-healthcare-robotics-with-gpu-native-medical-physics-simulation/
29. "taichi-dev/taichi: Productive, portable, and performant GPU programming in Python", repository README and record, GitHub, accessed 31 July 2026. https://github.com/taichi-dev/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). https://arxiv.org/abs/2412.12089
31. "numba/numba: NumPy aware dynamic Python compiler using LLVM", repository record, GitHub, accessed 31 July 2026. https://github.com/numba/numba
32. "cupy/cupy: NumPy and SciPy for GPU", repository record, GitHub, accessed 31 July 2026. https://github.com/cupy/cupy
33. "Genesis-Embodied-AI/Genesis", repository README, GitHub, accessed 31 July 2026. https://github.com/Genesis-Embodied-AI/Genesis
34. "Development on Taichi has halted :-( Any recommended alternatives from the community?", discussion #8506, taichi-dev/taichi, GitHub, June 2024. https://github.com/taichi-dev/taichi/discussions/8506
35. "jax-ml/jax: Composable transformations of Python+NumPy programs", repository record, GitHub, accessed 31 July 2026. https://github.com/jax-ml/jax
36. "pytorch/pytorch: Tensors and Dynamic neural networks in Python with strong GPU acceleration", repository record, GitHub, accessed 31 July 2026. https://github.com/pytorch/pytorch
37. "taichi", release history, PyPI, accessed 31 July 2026. https://pypi.org/project/taichi/#history
38. "google-deepmind/mujoco: Multi-Joint dynamics with Contact", repository record, GitHub, accessed 31 July 2026. https://github.com/google-deepmind/mujoco