NewYour coding agent can read the release notes before it upgrades.Set up the MCP server →

PyPI · #3905 most downloaded on PyPI

warp-lang

1.17.01.1M downloads/moNVIDIA/warp ↗New releases in your daily digest, changelog included.

A Python framework for high-performance simulation and graphics programming

Last release 1 months ago
31 Aug 2026
Ships on a steady schedule
a new release about every 4 weeks
Nearly every release is documented
notes for 52 of 52 stable releases
Nothing withdrawn
no release was ever pulled
4 years old
52 releases · first in 2022

Release timeline

52 releases since 2022

20222023202420252026

20222026

One column per quarter.

Releases

1.11.02 Jan 2026Deprecated
Symbols and namespaces intended for internal use now emit deprecation warnings when accessed and will be removed in v1.13 (nominally May 2026). The co…
Warp v1.11.0

Warp v1.11 introduces group-aware spatial queries for multi-world workloads, provides new options for managing JIT compilation overhead, and expands differentiation capabilities with wp.grad(). This release also includes expanded tile operations, the unpack operator in kernels, C++ integration examples, and a major API cleanup clarifying public versus internal interfaces.

New features

Group-aware spatial queries

Warp v1.11 introduces group-aware construction and queries for wp.Bvh and wp.Mesh data structures, enabling efficient spatial queries across multiple independent environments. This feature allows you to build a single acceleration structure containing geometry from multiple worlds or scenes, then query each world independently without traversing primitives from other worlds.

When constructing a BVH or Mesh, assign each primitive to a group using the groups parameter. Warp builds isolated sub-trees for each group within a unified structure:

# Build a BVH in Python containing multiple worlds lowers = wp.array(...) # Shape bounds for all worlds uppers = wp.array(...) world_ids = wp.array([0, 0, 1, 1, 2, 2, ...], dtype=int) bvh = wp.Bvh(lowers, uppers, groups=world_ids) @wp.kernel def raycast_world( bvh_id: wp.uint64, world_id: int, ray_origin: wp.vec3, ray_dir: wp.vec3 ): # Get the root node for this world's sub-tree root = wp.bvh_get_group_root(bvh_id, world_id) # Query only intersects geometry from this world query = wp.bvh_query_ray(bvh_id, ray_origin, ray_dir, root) # Process hits shape_idx = int(0) while wp.bvh_query_next(query, shape_idx): # Handle intersection with shape_idx pass # Launch kernel to query world 2 wp.launch(raycast_world, dim=1, inputs=[bvh.id, 2, origin, direction])

This example shows a single-world query for clarity. For production use, launch multiple threads in parallel, each querying its assigned world from arrays of world IDs and ray parameters. See Newton's raytrace implementation for a real-world example of parallel multi-world raycasting.

Key features

Group construction: Pass a groups array during construction to organize primitives into isolated sub-trees

Group-restricted queries: All query functions accept an optional root parameter to limit traversal to a specific group

Helper functions: wp.bvh_get_group_root() and wp.mesh_get_group_root() retrieve sub-tree roots for each group

Thanks to @StafaH for implementing this feature.

Geometry query enhancements

Warp v1.11 adds several new query functions and improvements for spatial queries:

wp.mesh_query_ray_anyhit(): Fast any-hit query that returns immediately upon finding any intersection, useful for shadow ray calculations in rendering

wp.mesh_query_ray_count_intersections(): Counts all ray-triangle intersections along a ray path

wp.mesh_query_point_sign_parity(): Point-in-mesh query using perturbed ray casting with majority voting for improved robustness in challenging cases

max_dist parameter: wp.bvh_query_next() now accepts a maximum distance to filter intersections, useful for early ray termination

Tiled query functions: Cooperative thread-block queries for use in tiled kernels (wp.bvh_query_aabb_tiled(), wp.bvh_query_ray_tiled(), wp.mesh_query_aabb_tiled(), etc.)

Evaluate the gradients of functions

wp.grad() directly evaluates the gradient of a Warp function at specific input values, computing gradients inline during the forward pass. This is useful for computing forces from energy functions or when implementing custom adjoints that need to call auto-generated gradients of subfunctions, avoiding the need to manually code the entire adjoint chain. This contrasts with wp.Tape(), which records an entire computation graph for reverse-mode automatic differentiation across multiple kernel launches. This feature was implemented in response to community feedback (#125).

import warp as wp import numpy as np k = 1.0 @wp.func def compute_energy(x: float): return 0.5 * k * x * x @wp.kernel def compute_force(x: wp.array(dtype=float), U: wp.array(dtype=float), F: wp.array(dtype=float)): i = wp.tid() U[i] = compute_energy(x[i]) F[i] = -wp.grad(compute_energy)(x[i]) N = 5 x = wp.array(np.arange(N, dtype=np.float32), dtype=float) U = wp.zeros_like(x) F = wp.zeros_like(x) wp.launch(compute_force, N, inputs=[x], outputs=[U, F]) print(U.numpy()) # Energy: [0. 0.5 2. 4.5 8. ] print(F.numpy()) # Force: [ 0. -1. -2. -3. -4.]

wp.tile_map() supports n-ary maps (up to n=8)

User-defined functions that accept up to 8 arguments may now be used as tile mapping functions. An equivalent number of tiles must be passed to wp.tile_map(). For example:

@wp.func def weighted_sum(a: float, b: float, c: float): return 0.5 * a + 0.3 * b + 0.2 * c @wp.kernel def compute(): a = wp.tile_arange(0.0, 1.0, 0.1, dtype=float) b = wp.tile_ones(shape=10, dtype=float) c = wp.tile_arange(1.0, 2.0, 0.1, dtype=float) s = wp.tile_map(weighted_sum, a, b, c) print(s) wp.launch_tiled(compute, dim=[1], inputs=[], block_dim=16)

Generate tiles of random numbers

wp.tile_randf() and wp.tile_randi() have been introduced to generate tiles of random floats and ints, respectively. These functions accept optional lower and upper bound arguments to control the range of generated values. This snippet generates 4x4 tensors of random floats using 2x2 tiles:

TILE_M, TILE_N = 2, 2 M, N = 2, 2 seed = 42 @wp.kernel def rand_kernel(seed: int, x: wp.array2d(dtype=float)): i, j = wp.tid() rng = wp.rand_init(seed, i * TILE_M + j) t = wp.tile_randf(shape=(TILE_M, TILE_N), rng=rng) wp.tile_store(x, t, offset=(i * TILE_M, j * TILE_N)) x = wp.zeros(shape=(M * TILE_M, N * TILE_N), dtype=float) wp.launch_tiled(rand_kernel, dim=[M, N], inputs=[seed, x], block_dim=32) print(x.numpy())

Alpha and Beta scalings in wp.tile_matmul()

Optional alpha and beta scaling arguments have been added to wp.tile_matmul() builtins.

Previous Behavior Updated Behavior

out = A * B + out out = alpha * A * B + beta * out

out = A * B out = alpha * A * B

In-place variants of Cholesky decomposition and linear solvers

wp.tile_cholesky_inplace(), wp.tile_cholesky_solve_inplace(), wp.tile_lower_solve_inplace(), and wp.tile_upper_solve_inplace() give the same results as their non-inplace counterparts, but overwrite input memory rather than allocate additional output memory, thereby halving shared memory usage. This is particularly beneficial in memory-constrained kernels where shared memory is limited. A standard example using Cholesky decomposition and the Cholesky solver looks like:

@wp.kernel() def tile_math_cholesky_inplace( gA: wp.array2d(dtype=wp.float64), gy: wp.array1d(dtype=wp.float64), ): i, j = wp.tid() # Load A & y a = wp.tile_load(gA, shape=(TILE_M, TILE_M), storage="shared") y = wp.tile_load(gy, shape=TILE_M, storage="shared") # Compute L st LL^T = A inplace wp.tile_cholesky_inplace(a) # Solve for y in LL^T x = y inplace wp.tile_cholesky_solve_inplace(a, y) # Store L & y wp.tile_store(gA, a) wp.tile_store(gy, y)

Performance improvements

JIT-compile time improvements

Warp v1.11 brings three changes that aim to reduce the time to compile and load modules:

Precompiled headers

The CUDA C++ files that are generated from the Python modules all include the same set of header files. Warp now leverages NVRTC precompiled headers to cache the result of parsing these headers and reuse it for subsequent modules.

The first module that gets compiled incurs a 50 ms overhead to create the precompiled header, but every subsequent module in the same Python session gains 50-500 ms in compile time, with larger modules seeing the greatest benefit. The precompiled header is stored in a temporary directory and cached for the lifetime of the Python process. Each new Python process must recreate the precompiled header, as PCH files cannot be shared across processes due to internal memory layout requirements.

This feature is enabled by default, but can be disabled using wp.config.use_precompiled_headers=False.

Note for source builds: Precompiled headers require building Warp against CUDA Toolkit 12.8 or newer. Users installing from PyPI automatically have this feature because the Warp libraries on PyPI are now built against CUDA Toolkit 12.9.1.

For more details, see the NVRTC PCH documentation.

Optimization level control

By default, the CUDA Runtime Compiler performs a high level of optimizations on GPU kernels, favoring runtime performance at the cost of longer compilation times. Warp v1.11 introduces the wp.config.optimization_level setting to control this tradeoff. When set to None (the default), Warp uses level 3, which corresponds to maximum runtime optimization.

This setting controls GPU kernel compilation and accepts values from 0 to 3:

Level 3 (default): Maximum runtime performance, longest compile times

Level 2: Balanced tradeoff, can reduce initial compile times by up to 30%

Levels 0-1: Faster compilation, but may offer diminishing returns compared to level 2

The setting can be configured globally via wp.config.optimization_level or per-module using wp.set_module_options({"optimization_level": 2}).

This setting is available when Warp is built against CUDA Toolkit 12.9 or newer. PyPI wheels include this support.

Parallel compilation

Modules can now be compiled and loaded in parallel across multiple threads for both CPU and GPU. To benefit from parallel compilation, set wp.config.load_module_max_workers to a positive integer (default is 0, which disables parallelization) and explicitly load modules using wp.load_module() or wp.force_load(). You can also pass a max_workers argument directly to these functions to override the config setting. When modules are lazily compiled on-demand at wp.launch(), they are compiled one at a time and do not benefit from parallelization.

Parallel compilation can significantly reduce startup time when working with many modules. The most time-consuming step being parallelized is the two-stage compilation process: translating Python code to CUDA/C++ source code, then JIT-compiling to binary libraries using NVRTC for GPU or LLVM for CPU.

wp.load_module() requires recursive=True to enable parallel compilation. This loads the specified module along with all its submodules. The following example loads Newton's inverse kinematics module and its submodules:

import warp as wp import newton._src.sim.ik wp.config.load_module_max_workers = 4 wp.load_module(newton._src.sim.ik, device=wp.get_device("cuda:0"), recursive=True)

With parallel compilation (wp.config.load_module_max_workers=4), this takes about 3 seconds for CUDA (versus 4.5 seconds serially) and 3.7 seconds for CPU (versus 10.5 seconds serially).

wp.force_load() provides lower-level control by accepting an explicit list of modules to compile, unlike wp.load_module() which operates on a module hierarchy. Warning: Without explicit modules and device arguments, wp.force_load() compiles all imported modules for all available devices, which can take much longer than not using it at all. For example, import newton followed by wp.force_load(device="cuda:0") will compile over 100 modules.

The following example shows selective compilation using a manually-built module list. This requires more setup but provides fine-grained control:

import warp as wp wp.config.load_module_max_workers = 4 module_list = [ wp.get_module(m) for m in [ "newton._src.sim.articulation", "newton._src.sim.ik.ik_common", "newton._src.sim.ik.ik_lm_optimizer", "newton._src.sim.ik.ik_objectives", "newton._src.sim.ik.ik_solver", "newton._src.geometry.inertia", "newton._src.viewer.gl.opengl", "newton._src.viewer.kernels", "newton._src.solvers.mujoco.kernels", ] ] wp.force_load(device=wp.get_device("cpu"), modules=module_list)

The above snippet takes about 9-10 seconds with parallel compilation (wp.config.load_module_max_workers=4), compared to about 24 seconds with serial loading (wp.config.load_module_max_workers=0), yielding a roughly 2.5x speedup in this case.

Parallel compilation is most effective when compilation time is distributed evenly across modules. Gains will be limited if a single module dominates the total compilation time.

Advanced optimization: For applications with many kernels in a single large module file, consider splitting them into separate submodules across multiple files. This enables parallel compilation of the submodules, trading some code organization complexity for faster compilation times.

Language enhancements

Unpack operator support in kernels

Warp now supports Python's unpack operator (*) inside kernel function calls, enabling you to expand vectors, matrices, quaternions, and 1D array slices into individual arguments. This feature brings familiar Python idioms into Warp kernels and simplifies common patterns like constructing larger vectors from smaller ones, or copying array values into a vector.

The unpack operator works on composite types to expand their components:

@wp.kernel def compute( arr: wp.array(dtype=float), ): # Unpack a 1D array slice into a vector. v1 = wp.vec3(*arr[:3]) wp.expect_eq(v1, wp.vec3(1.0, 2.0, 3.0)) # Unpack a vector into function arguments. v2 = wp.vec2(1.0, 2.0) x2 = wp.max(*v2) wp.expect_eq(x2, 2.0) # Build larger vectors by unpacking smaller ones. v3 = wp.vec3(1.0, 2.0, 3.0) v4 = wp.vec4(*v3, 4.0) wp.expect_eq(v4, wp.vec4(1.0, 2.0, 3.0, 4.0)) arr = wp.array((1, 2, 3, 4, 5, 6, 7, 8, 9), dtype=float) wp.launch(compute, dim=1, inputs=(arr,))

Important: When unpacking arrays, slice bounds must be compile-time constants and non-negative. The upper bound is required since the array length is not known at compile time.

C++ integration examples

Warp v1.11 introduces C++ integration examples demonstrating how to deploy Warp-compiled kernels in standalone C++ applications without runtime Python dependencies. Two approaches are demonstrated:

Runtime CUBIN loading (00_cubin_launch): Load Warp-generated CUBIN files at runtime using CUDA Driver API

Source inclusion (01_source_include): Statically include Warp-generated CUDA source (including forward and adjoint kernels) in C++ projects

These examples are available at warp/examples/cpp/ with full build support for Make and CMake on Linux and Windows.

Community feedback: We're gathering input on Warp's AOT and C++ interoperability roadmap through a survey on GitHub Discussions. If you work with native workflows, deployment in minimal-Python environments, or interoperability with other CUDA/C++ libraries, your feedback will help shape future development in these areas.

Public API clarification

Warp v1.11 refines the boundary between public and internal APIs alongside a major documentation reorganization. Symbols and namespaces intended for internal use now emit deprecation warnings when accessed and will be removed in v1.13 (nominally May 2026). The complete public API is now clearly documented in the restructured API Reference and Language Reference sections.

What this means for your code:

Deprecation warnings will appear if you access internal APIs or deprecated symbols. The warnings will guide you to the correct migration path for each case. To get more details about where warnings originate (including filename and line number), set wp.config.verbose_warnings = True.

Internal module access via the top-level warp package (e.g., wp.context) is deprecated. If your code relies on internal APIs like wp.context.runtime, you can access them via wp._src.context.runtime, but be aware these are not part of the public API and may change or be removed without notice.

Type hint updates: Use wp.DeviceLike instead of the deprecated wp.Devicelike (note the capitalization).

If you depend on functionality that's no longer accessible and believe it should be part of the public API, please open a feature request on GitHub. Note: We're aware that some functionality (such as graph coloring and color balancing) currently lacks a public API and requires accessing internal modules. We're tracking these gaps in issues like #1145.

Platform support

Python version requirements

Warp 1.11.0 drops support for Python 3.8, which reached end-of-life in October 2024. Python 3.9 is now the minimum supported version.

CUDA Toolkit updates

PyPI wheels are now built with CUDA Toolkit 12.9.1 (up from 12.8.0 in previous releases). This enables new optimizations and features, including the wp.config.optimization_level setting for controlling kernel compilation.

For users building Warp from source, CUDA Toolkit 12.9.1 or newer is recommended for full GPU support.

Acknowledgments

We also thank the following contributors from outside the core Warp development team:

@StafaH for adding group-aware construction and queries for wp.Bvh and wp.Mesh, a new built-in function for
wp.mesh_query_ray_anyhit(), support for the max_dist argument to wp.bvh_query_next(), and improving the BVH SAH
constructor to use centroids for better build quality and traversal performance.

@RSchwan for adding in-place variants of tile linear algebra functions and alpha/beta scaling parameters to
wp.tile_matmul(), reducing shared memory usage and enabling operation fusion in tile kernels.

Full Changelog

For a curated list of all changes in this release, please see the v1.11.0 section in CHANGELOG.md.

Previous Behavior	Updated Behavior
`out = A * B + out`	`out = alpha * A * B + beta * out`
`out = A * B`	`out = alpha * A * B`

Additional notes2 sources agree

Added

Add wp.grad() to get a Warp function's gradient in functions, kernels, and custom gradients (GH-125).
Add group-aware construction and queries for wp.Bvh and wp.Mesh to support multi-environment workloads, including groups constructor argument, optional root query parameter for group-restricted traversal, and helper functions wp.bvh_get_group_root() and wp.mesh_get_group_root() to retrieve subtree roots (GH-1074, GH-1097).
Add tiled query functions for cooperative thread-block parallel queries in tiled kernels on CUDA devices. Functions include wp.bvh_query_aabb_tiled(), wp.bvh_query_ray_tiled(), wp.bvh_query_next_tiled(), wp.mesh_query_aabb_tiled(), and wp.mesh_query_aabb_next_tiled(). Aliases with tile_* prefix (e.g., wp.tile_bvh_query_ray()) are also available (GH-1005).
Add wp.mesh_query_ray_anyhit() for ray any-hit queries with group-aware support (GH-1097).
Add a max_dist argument to wp.bvh_query_next() to control the maximum distance to check for intersections in ray queries (GH-1052).
Add wp.mesh_query_ray_count_intersections() to count all intersections with triangles along a ray (GH-938).
Add wp.mesh_query_point_sign_parity() for mesh point queries with parity-based inside/outside determination using ray–triangle intersection counting (GH-938).
Add alpha and beta scaling parameters to wp.tile_matmul() to reduce shared memory usage and fuse operations, supporting C = alpha * A * B + beta * C and C = alpha * A * B (GH-1023).
Add in-place variants of tile linear algebra functions to reduce shared memory usage in kernels: wp.tile_cholesky_inplace(), wp.tile_cholesky_solve_inplace(), wp.tile_lower_solve_inplace(), and wp.tile_upper_solve_inplace() (GH-1025).
Add support for wp.int64 and wp.uint64 key types to wp.tile_sort() (GH-1089).
Add wp.tile_scan_max_inclusive() and wp.tile_scan_min_inclusive() for cumulative maximum and minimum operations across tiles (GH-1090).
Add wp.tile_randi() and wp.tile_randf() to support generating tiles of random numbers (GH-1010).
Add launch_bounds parameter to @wp.kernel decorator to specify CUDA __launch_bounds__ attribute for controlling thread block occupancy. Can be an integer for maxThreadsPerBlock or a tuple of 1-2 integers for (maxThreadsPerBlock, minBlocksPerMultiprocessor) (GH-1049).
Add type introspection functions to query Warp types (e.g., wp.types.is_vector(), wp.types.type_is_tile()). See the warp.types documentation for the complete list.
Add support for the unpack operator (*) in kernels to expand vectors, matrices, quaternions, and 1D array slices into individual arguments, enabling syntax like wp.vec4(*v3, 1.0), wp.max(*v), or wp.vec3i(*arr[:3]) (GH-1083).
Add wp.config.optimization_level to control kernel compilation optimization level, allowing trade-offs between kernel compile time and runtime performance. Can be configured globally or per-module. Currently only affects kernels compiled for GPU devices (GH-1084).
Add support for parallel module compilation and loading via max_workers parameter in wp.load_module() and wp.force_load(). Defaults to serial loading; set wp.config.load_module_max_workers to enable parallel loading (GH-1086).
Add support for precompiled headers in CUDA compilation, enabled by default to reduce compilation overhead in many cases. Can be disabled using wp.config.use_precompiled_headers=False if needed (GH-595).
Add staged graph capture modes (GraphMode.WARP_STAGED and GraphMode.WARP_STAGED_EX) for JAX FFI to avoid re-capturing graphs when input/output buffer addresses change between calls (GH-1039).

Removed

Drop support for Python 3.8. Python 3.9 is now the minimum supported version (GH-1019).
Remove graph_compatible argument from warp.jax_experimental.jax_callable() (deprecated since 1.8.1). Use graph_mode instead (GH-982).

Deprecated

Deprecate accepting integer inputs in wp.isfinite(), wp.isnan(), and wp.isinf(). These functions will only accept floating-point arguments in a future release (GH-847).
Deprecate internal namespaces and symbols not intended for public use (GH-908).
Deprecate warp.render.UsdRenderer.update_body_transforms() which references non-existent attributes and is non-functional.

Changed

Extend wp.tile_map() to support user-defined functions with up to 8 input tiles, beyond the previous unary and binary operations (GH-1077).
Improve wp.map() performance by caching kernels for repeated calls with the same function and similar input arguments (GH-1108).
Support converting between vector, matrix, and scalar types in array.view() (GH-1112).
Suppress CUDA compiler warnings about unused variables generated during kernel compilation to reduce noise when wp.config.verbose is enabled or when compilation errors occur (GH-1129).
Change BVH SAH constructor to use centroids instead of bounds to determine partition axis, improving build quality and traversal performance in some scenarios (GH-1102).
Extend warp.fem.interpolate() API to decouple interpolation location from storage definition, allowing more flexible usage patterns (GH-1091).
Change wp.config.enable_tiles_in_stack_memory to use architecture-aware defaults. When None (the default), automatically enables stack memory on aarch64 platforms and disables it on other architectures.

Fixed

Fix atomic floating-point min/max operations not returning the old value (GH-1058).
Fix direct initialization and slice assignment of vector, quaternion, and transform types from PyTorch tensors (GH-1121).
Fix a potential OverflowError when slicing arrays with np.int32 strides (GH-1120).
Fix RecursionError when calling repr() on vector instances (e.g., repr(wp.vec2i(42))) (GH-1124).
Fix array.list() returning NumPy scalar types instead of Python native types (e.g., numpy.int64 instead of int) (GH-1099).
Fix compilation error when calling wp.tile_zeros() with a struct type containing an array field (GH-1128).
Fix compilation error when constructing shared tiles of struct types (GH-1135).
Fix incorrect results in iterative linear solvers caused by including padding elements beyond the valid data length in tiled reductions.
Fix incorrect kernel parameter order in warp.optim.SGD causing wrong momentum and weight decay behavior (GH-1143).
Fix warp.render.OpenGLRenderer window incorrectly appearing when pyglet.options["headless"] is True but the headless constructor parameter is not provided.

Open source →

1.10.11 Dec 2025Deprecated

The following feature is deprecated and will be removed in v1.11 (planned for January 2026):

Warp v1.10.1

Warp v1.10.1 is a bugfix release following v1.10.0. For a complete list of changes, see the changelog.

Highlights

This is primarily a bugfix release with no major new features. Key fixes include:

Module reuse with module="unique": Fixed kernels using @wp.kernel(module="unique") to properly reuse existing module objects when the kernel is defined multiple times, avoiding unnecessary module creation overhead.
Kernel-local arrays: Fixed several issues with arrays created using wp.zeros() inside kernels, including .ptr access, indexing for subarrays, and accepting single integers for the shape parameter.
Custom gradients: Fixed a code-generation ordering bug that could prevent custom gradient functions (@wp.func_grad) from compiling when used with nested function calls.
FEM improvements: Fixed invalid reads when using wp.fem.TemporaryStore during tape capture and resolved reference cycles in wp.fem.Temporary and wp.fem.ShapeBasisSpace.

Announcements

Upcoming removals

The following feature is deprecated and will be removed in v1.11 (planned for January 2026):

graph_compatible parameter in jax_callable(): The boolean graph_compatible flag has been deprecated in favor of the new graph_mode parameter which accepts GraphMode enum values. Use GraphMode.JAX, GraphMode.WARP, or GraphMode.NONE instead.

# Deprecated (v1.10.1, will be removed in v1.11)
callable = wp.jax_experimental.jax_callable(func, graph_compatible=True)

# Use instead
from warp.jax_experimental import GraphMode
callable = wp.jax_experimental.jax_callable(func, graph_mode=GraphMode.JAX)

Platform support

Python 3.8: We plan to drop support for Python 3.8 (end-of-life since October 2024) starting with v1.11.
CUDA Toolkit: Starting with v1.11, the default pre-built wheels published on PyPI will be built with CUDA Toolkit 12.9 instead of 12.8. This does not change driver requirements but enables new compiler options to control the tradeoff between kernel compilation speed and runtime performance. We plan a second transition to CUDA Toolkit 13.x in mid-2026.

Acknowledgments

We thank the following contributors:

@mehdiataei for fixing loop unrolling with wp.static() expressions that prevented certain code patterns from compiling correctly.

Open source →

Additional notes2 sources agree

Fixed

Fix type inference errors when passing reference arguments (such as array elements) to built-in functions (GH-1071).
Fix module="unique" kernels to properly reuse existing module objects when defined multiple times, avoiding unnecessary module creation overhead (GH-995).
Fix for loops containing wp.static() expressions that use the loop variable. These loops are now always unrolled regardless of max_unroll settings to ensure loop variables are available as compile-time constants within static expressions (GH-560).
Add validation in wp.compile_aot_module() to detect generic kernels without overloads and generic kernels with multiple overloads when strip_hash=True (GH-919).
Fix compilation error in wp.tile_load_indexed() when indices tile has been reshaped or transformed (GH-1008).
Fix multiple issues with kernel-local arrays (arrays created with wp.zeros() in kernels):
- Fix .ptr access (GH-999).
- Fix indexing when requesting a subarray (GH-1081).
- Fix shape parameter to accept a single integer (e.g., wp.zeros(shape=123, dtype=float)) (GH-1081).
Fix code-generation ordering for custom gradient functions (@wp.func_grad) when used with nested function calls (GH-967).
Fix invalid reads when using wp.fem.TemporaryStore during tape capture for automatic differentiation (GH-1021).
Fix reference cycles introduced by wp.fem.Temporary and wp.fem.ShapeBasisSpace (GH-1076).
Improve documentation and error messages about requiring a BVH for wp.fem.lookup() and related functionality (GH-1072).

Documentation

Add more examples to the Tiles and SIMT code documentation, demonstrating caveats when switching between the CPU and GPU and using wp.tile() (GH-1042).

1.10.02 Nov 2025Breaking

Breaking change: As part of this optimization, support for passing lists, tuples, and other non-Warp array arguments to built-in functions has been re…

Warp v1.10.0

Warp v1.10 expands JAX integration with automatic differentiation support and multi-device jax.pmap() compatibility. The tile programming model has been enhanced with axis-specific reductions, component-level indexing, and convenience functions for creating tiles.

Performance has been significantly improved in several areas: BVH operations now support in-place rebuilding for CUDA graphs and configurable leaf sizes, built-in function calls from Python are up to 70× faster, and additional sparse matrix and FEM operations can now be captured in CUDA graphs.

Additional usability improvements include negative indexing and slicing for arrays, atomic bitwise operations, and new built-in functions including error functions and type casting.

Important: This release removes the warp.sim module (deprecated since v1.8), which has been superseded by the Newton physics engine. See the Announcements section below for migration guidance and other upcoming changes.

For a complete list of changes, see the full changelog.

New features

JAX automatic differentiation (experimental)

Warp now supports experimental automatic differentiation with JAX, allowing kernels to participate in JAX automatic differentiation workflows. This feature is contributed by @mehdiataei and builds on earlier work by @jaro-sevcik. It enables computing gradients through Warp kernels using jax.grad() by passing enable_backward=True to jax_kernel().

Key capabilities include:

Single and multiple output kernels: Compute gradients for kernels with one or more output arrays
Static input auto-detection: Scalar inputs are automatically treated as static (non-differentiable) arguments
Vector and matrix arrays: Arrays of composite types like wp.vec2 or wp.mat22 are fully supported
Multi-device execution: Compatible with jax.pmap() for distributed forward and backward passes across multiple GPUs

import jax
from warp.jax_experimental import jax_kernel

@wp.kernel
def my_kernel(a: wp.array(dtype=float), out: wp.array(dtype=float)):
    i = wp.tid()
    out[i] = a[i] ** 2.0

# Enable automatic differentiation
jax_func = jax_kernel(my_kernel, num_outputs=1, enable_backward=True)

# Compute gradients through the kernel
grad_fn = jax.grad(lambda a: jax.numpy.sum(jax_func(a)[0]))
gradient = grad_fn(input_array)  # gradient: [2*a[0], 2*a[1], ...]

This feature is experimental and has some current limitations. See the JAX Automatic Differentiation documentation for complete examples, usage details, and limitations.

Multi-device JAX support with `jax.pmap()`

Warp now properly supports jax.pmap() and jax.shard_map() for multi-device parallel execution, thanks to fixes contributed by @chaserileyroberts. Previously, device targeting issues prevented Warp callables from working correctly within these JAX primitives—JAX would invoke callbacks from multiple threads targeting different devices, but Warp would always execute on the default device. The fix ensures proper device coordination by extracting device ordinals from XLA FFI and adding thread synchronization for concurrent callbacks, enabling efficient data-parallel workflows across multiple GPUs.

In-place BVH rebuilding with CUDA graph support

A new wp.Bvh.rebuild() method enables rebuilding BVH hierarchies in-place without allocating new memory. This complements the existing refit() method and is particularly useful when primitive distributions change significantly.

CUDA graph capture: Unlike creating a new BVH, rebuild() reuses existing buffers, making it safe to capture in CUDA graphs. Previously captured graphs that include queries on the BVH remain valid after rebuilding, enabling high-performance repeated updates without graph re-capture overhead.

Construction algorithms: On CUDA devices, in-place rebuild supports "lbvh" only. On CPU, "sah" and "median" are supported. Defaults are chosen automatically based on the device.

Tile programming enhancements

The tile programming model has been enhanced with new capabilities to make tile-based computations more expressive and convenient:

Axis-specific reductions

The tile-reduction functions wp.tile_reduce() and wp.tile_sum() now support an optional axis parameter, enabling reductions along a specific dimension of a tile rather than reducing the entire tile to a single value. This enhancement brings NumPy-like axis semantics to tile operations.

@wp.kernel
def tile_reduce_axis(x: wp.array2d(dtype=float), y: wp.array(dtype=float)):
    a = wp.tile_load(x, shape=(4, 8), storage="shared")
    # Sum along axis 0, reducing shape from (4, 8) to (8,)
    b = wp.tile_sum(a, axis=0)
    wp.tile_store(y, b)


x = wp.array(np.arange(32).reshape(4, 8), dtype=float)
# x = [[ 0.  1.  2.  3.  4.  5.  6.  7.]
#      [ 8.  9. 10. 11. 12. 13. 14. 15.]
#      [16. 17. 18. 19. 20. 21. 22. 23.]
#      [24. 25. 26. 27. 28. 29. 30. 31.]]
y = wp.zeros(8, dtype=float)

wp.launch_tiled(tile_reduce_axis, dim=(1,), inputs=[x], outputs=[y], block_dim=32)
# y = [48. 52. 56. 60. 64. 68. 72. 76.]  (column sums)

Component-level indexing

Tiles of composite types (vectors, matrices, quaternions) now support component-level indexing and assignment. You can directly index into individual components using extended indexing syntax:

Vector components: tile[i][1] extracts the second component of a vector at position i
Matrix elements: tile[i][1, 1] accesses the element at row 1, column 1 of a matrix at position i

This provides more convenient and expressive syntax for working with structured data in tiles.

Creating tiles filled with a constant value

The new wp.tile_full() function provides a convenient way to create tiles initialized with a constant value, similar to NumPy's np.full():

# Create an 8x8 tile filled with 3.14
tile = wp.tile_full(shape=(8, 8), value=3.14, dtype=float)

New example

The new example_tile_mcgp.py example demonstrates tile-based Monte Carlo methods by implementing a walk-on-spheres algorithm for solving Laplace's equation on volumetric domains.

Performance improvements

Built-in function calls from Python

Calling Warp built-in functions from Python scope (e.g., wp.normalize(), wp.transform_identity(), matrix arithmetic like mat * mat) is now significantly faster thanks to optimizations in overload resolution. Previously, each function call would iterate through all overloads, attempt argument binding, and pack parameters into C types until finding a match. Now, Warp caches the resolved overload and parameter packing strategy based on argument types using @functools.lru_cache, eliminating redundant resolution overhead on subsequent calls.

In microbenchmarks, repeated wp.mat44 multiplication at Python scope is up to 70× faster (~570 μs → ~8 μs), while operations like wp.transform_identity() see 3-4× speedups (~100 μs → ~30 μs). The magnitude of improvement varies by operation complexity, with greater gains for operations requiring more expensive overload resolution.

Breaking change: As part of this optimization, support for passing lists, tuples, and other non-Warp array arguments to built-in functions has been removed. Calls like wp.normalize([1.0, 2.0, 3.0]) must now be written as wp.normalize(wp.vec3(1.0, 2.0, 3.0)). This simplifies the function call path and removes expensive sequence-flattening logic that was incompatible with efficient caching.

Configurable BVH leaf size

wp.Bvh and wp.Mesh now expose tunable leaf_size and bvh_leaf_size parameters, respectively, allowing users to control the number of primitives stored in each leaf node for performance optimization. The optimal leaf size depends on the query workload:

Intersection queries (ray casting, AABB overlap): Smaller leaf sizes (e.g., 1) are generally optimal, reducing unnecessary primitive checks
Closest point queries: Larger leaf sizes (e.g., 4-8) can improve performance by checking more primitives together and reducing traversal overhead
Mixed workloads: Moderate values (e.g., 4) provide a balanced trade-off

Behavior change: The default leaf_size for wp.Bvh has changed from 4 (hardcoded) to 1, optimizing for intersection queries which are more common. wp.Mesh retains a default bvh_leaf_size of 4 as a compromise between intersection and closest-point query performance. Users performing primarily closest-point queries may benefit from explicitly setting larger leaf sizes.

Sparse matrix operations with CUDA graphs

Sparse matrix operations in warp.sparse can now be captured in CUDA graphs for allocation-free execution. Operations like bsr_axpy(), bsr_assign(), and bsr_set_transpose() preserve matrix topology when using masked=True, while bsr_mm() adds a new max_new_nnz parameter that allows specifying an upper bound on new non-zero blocks for flexible graph capture when sparsity patterns vary within known bounds.

FEM operations with CUDA graphs

Building warp.fem geometry and function space partitions can now be captured in CUDA graphs by specifying upper bounds on partition sizes: max_cell_count and max_side_count for ExplicitGeometryPartition, and max_node_count for make_space_partition(). Additionally, building fields and restrictions is now synchronization-free by default.

Language enhancements

Array indexing and slicing improvements

Warp arrays now support negative indexing and improved slicing behavior, making array manipulation more intuitive and consistent with NumPy conventions.

Negative indexing: Access elements from the end of an array using negative indices:

@wp.kernel
def use_negative_indexing(arr: wp.array(dtype=float)):
    last = arr[-1]  # Last element
    second_last = arr[-2]  # Second-to-last element

Enhanced array slicing: Arrays now support more flexible slicing operations within kernels, including stride-based access patterns. This works with both regular arrays and tile operations:

@wp.kernel
def tile_load_strided(input: wp.array2d(dtype=float), output: wp.array2d(dtype=float)):
    # Load every other element from a 16x16 region into an 8x8 tile
    tile = wp.tile_load(input[::2, ::2], shape=(8, 8))
    wp.tile_store(output, tile)

input = wp.array(np.arange(256).reshape(16, 16), dtype=float)
output = wp.zeros((8, 8), dtype=float)
wp.launch_tiled(tile_load_strided, dim=(1,), inputs=[input, output], block_dim=32)

# output contains every other element from input:
# [[  0.   2.   4.   6.   8.  10.  12.  14.]
#  [ 32.  34.  36.  38.  40.  42.  44.  46.]
#  [ 64.  66.  68.  70.  72.  74.  76.  78.]
#  ...
#  [224. 226. 228. 230. 232. 234. 236. 238.]]

New built-in functions

Error functions: Added wp.erf(), wp.erfc(), wp.erfinv(), and wp.erfcinv() for error function computations
Type casting: Added wp.cast() to reinterpret values as different types while preserving bit patterns (e.g., reinterpreting float bits as int)
Atomic bitwise operations: Added wp.atomic_and(), wp.atomic_or(), and wp.atomic_xor() for thread-safe bitwise operations on integers, contributed by @j3soon
Sparse matrix utilities: Added wp.sparse.bsr_row_index() and wp.sparse.bsr_block_index() as kernel-level functions to efficiently determine which row a given block belongs to without manually searching through the compressed offset array

Bug fixes

AArch64 CPU execution with tiles

Fixed segmentation faults when running tile-based kernels on AArch64 CPUs, affecting platforms including NVIDIA Jetson (Thor, Orin), DGX Spark, Grace Hopper, and Grace Blackwell systems. The fix uses stack memory allocation instead of static memory to work around limitations in LLVM's JIT compiler.

This change is enabled by default on all CPU architectures and can be disabled if needed via wp.config.enable_tiles_in_stack_memory = False. If you encounter issues that are resolved by disabling this setting, please report them on our GitHub Issues page.

Note: This primarily affects CPU execution of tile operations, which is less common in Warp workflows but useful for debugging or scenarios in which GPU memory transfer overhead outweighs compute benefits.

Native library version verification

Warp now performs runtime version checking to detect mismatches between the Python package and native libraries (e.g., warp.dll, warp.so). This helps diagnose issues in which multiple Warp installations on the same system may cause the wrong native libraries to be loaded. When a mismatch is detected, a warning is issued but execution continues. If you see such warnings, ensure you're loading Warp from the expected installation location and that your environment doesn't have conflicting Warp versions.

Announcements

Removal of `warp.sim` module

The warp.sim module has been removed in this release. This module was formally deprecated in Warp v1.8 (July 2025) and has been superseded by the Newton physics engine, an independent package managed as a Linux Foundation project with a redesigned API focused on robotics and robot learning.

Migration: Users relying on warp.sim should migrate to Newton. For guidance on transitioning from warp.sim to Newton, please consult the Newton migration guide. The original deprecation announcement and community discussion can be found in GitHub Discussion #735.

Questions and discussions about Newton should be directed to the Newton Discussions section. Existing issues in the Warp repository concerning warp.sim will be closed.

JAX FFI is now the default

The default implementation of jax_kernel() is now based on JAX's Foreign Function Interface (FFI), which is required for JAX version 0.8 and newer. Most users should not need to change their code, as the FFI-based version has been available since Warp 1.7 and provides better performance through CUDA graph capture. The previous custom call implementation is still available as wp.jax_experimental.custom_call.jax_kernel() for users on older JAX versions, but it is deprecated and will not work with JAX version 0.8 or later.

Internal code reorganization: `_src` folder

As part of ongoing efforts to clarify Warp's public API surface, internal implementation code has been reorganized into a warp._src subpackage. This change helps distinguish between public APIs that users should rely on versus internal implementation details that may change without notice.

What this means for users:

No immediate breaking changes: All existing imports continue to work. Modules like warp.context, warp.types, and warp.fem remain accessible at their current paths through compatibility shims.
Visible in stack traces: You may see warp._src paths in error messages and stack traces (e.g., warp._src.context instead of warp.context).
Future direction: In upcoming releases, we plan to define and formalize the public API surface. Once established, public modules will be updated to re-export all designated public symbols, and then compatibility shims will be removed. Code that imports from internal modules will need to be updated to use public APIs or explicitly import from warp._src.* (acknowledging the use of private APIs).

This reorganization is the first step in a multi-phase effort to establish a stable public API. If you encounter any issues introduced by this reorganization, please report them on our GitHub Issues page.

Upcoming removals

The following features will be removed in v1.11 (planned for January 2026):

Constructing matrices from row vectors: The ability to construct matrices by passing row vectors to the matrix constructor (e.g., wp.mat22(wp.vec2(1, 2), wp.vec2(3, 4))). Use wp.matrix_from_rows() or wp.matrix_from_cols() instead. This deprecation was originally announced in v1.9 with a planned removal in v1.10, but has been extended one release cycle. While kernel-scope usage had been emitting deprecation warnings since v1.9, it was discovered that Python-scope usage lacked proper warnings. Starting in v1.10, both contexts now emit deprecation warnings.
graph_compatible parameter in jax_callable(): The boolean graph_compatible parameter has been deprecated in favor of the new graph_mode parameter which accepts GraphMode enum values (GraphMode.JAX, GraphMode.WARP, or GraphMode.NONE).

Platform support

Python 3.14: Warp now supports Python 3.14, expanding compatibility beyond the previous maximum of Python 3.13.
Intel-based macOS (x86_64): Support for Intel Macs has been removed in this release. Apple Silicon Macs (ARM64) continue to be fully supported with CPU execution. Users on Intel-based Macs can continue using Warp 1.9.x or earlier versions.
Python 3.8: We plan to drop support for Python 3.8 (end-of-life since 2024-10-07) starting with the next minor release (#1019).

Acknowledgments

We also thank the following contributors from outside the core Warp development team:

@j3soon for adding support for atomic bitwise operations
@chaserileyroberts for fixing issues with JAX interop on multiple devices
@mehdiataei and @jaro-sevcik for adding support for JAX automatic differentiation
@liblaf for improving type annotations for struct() and overload() decorators
@manuelkNVDA for adding support for multi-process compilation of the core library
@boomanaiden154 for contributing fixes to handle upcoming removals in LLVM

Open source →

Additional notes2 sources agree

Added

Add an in-place wp.Bvh.rebuild() method that rebuilds the hierarchy without allocating new memory and can be captured in CUDA graphs (GH-826).
Add atomic bitwise operations wp.atomic_and() (&=), wp.atomic_or() (|=), and wp.atomic_xor() (^=) for scalar types, along with bitwise operations for vector, matrix, and tile types (GH-886).
Add support for negative indexing and improve slicing for the wp.array() type (GH-504).
Add wp.cast() to reinterpret a value as a different type while preserving its bit pattern (GH-789).
Add support for error functions: wp.erf(), wp.erfc(), wp.erfinv(), and wp.erfcinv() (GH-910).
Add wp.tile_full(), which fills a tile with a constant value (GH-973).
Add axis-reduction overloads for wp.tile_reduce() and wp.tile_sum() (GH-835).
Add support for component-level indexing and assignment on tiles of composite types (e.g. tile[i][1] for extracting vector components, tile[i][1, 1] for matrix elements) (GH-941).
Add warp/examples/tile/example_tile_mcgp.py, demonstrating how to implement a Monte Carlo Laplace solver.
Add support for recording and waiting for external events in CUDA graphs (GH-983).
Add support for querying CPU memory information (requires psutil package) (GH-985).
Add wp.get_cuda_supported_archs() to query supported CUDA compute architectures for compilation targets (GH-964).
Add runtime version verification to detect native library mismatches. Version mismatches trigger warnings but allow execution to continue (GH-1018).
Add kernel-level functions bsr_row_index() and bsr_block_index() to warp.sparse (GH-895).
Add adjoint for wp.transform() when constructing with individual scalars (GH-1011).
Add a double-precision overload for wp.intersect_tri_tri() (GH-1015).
Add support for jax.pmap() (GH-976).
Add automatic differentiation support with jax_kernel(enable_backward=True) (GH-912, GH-515).
Add support for limiting the graph cache size of JAX callables (GH-989).
Add PyTorch-Warp interop deferred gradient allocation case study to documentation (GH-1046).

Removed

Remove warp.sim module and related examples. This module has been superseded by the Newton library, a separate package with a new API. For migration guidance, see the Newton migration guide and the original GitHub announcement (GH-735).
Remove support for passing lists, tuples, and other non-Warp array arguments when calling built-ins at the Python scope (deprecated since v0.11.0). Use explicit type constructors instead (e.g., wp.normalize([1.0, 2.0, 3.0]) should be wp.normalize(wp.vec3(1.0, 2.0, 3.0))).
Remove support for Intel-based macOS (x86_64). Apple Silicon-based Macs (ARM64) continue to be supported with the CPU backend. Users on Intel Macs will receive a RuntimeError directing them to use Warp 1.9.x or earlier (GH-1016).
Remove wp.select() (deprecated since 1.7). Use wp.where(cond, value_if_true, value_if_false) instead.
Remove the wp.matrix(pos, quat, scale) built-in function. Use wp.transform_compose() instead (GH-980).

Deprecated

Deprecate constructing a matrix from vectors at the Python scope (e.g. wp.mat22(wp.vec2(1, 2), wp.vec2(3, 4)) should become wp.matrix_from_rows(wp.vec2(1, 2), wp.vec2(3, 4))) (GH-981).

Changed

Breaking: Change the default implementation of jax_kernel() to be wp.jax_experimental.ffi.jax_kernel(). The previous version is still available as wp.jax_experimental.custom_call.jax_kernel(), but it is not supported with JAX v0.8 and newer (GH-974).
Breaking: Raise RuntimeError from wp.load_module() when attempting to load a module that does not contain any Warp kernels, functions, or structs (GH-920).
Improve performance when calling built-in functions from the Python scope (GH-801).
Improve efficiency of struct instance creation and attribute access (GH-968).
Add leaf_size parameter to wp.Bvh and bvh_leaf_size to wp.Mesh to control the number of primitives per leaf for performance tuning. The default is now 1 for wp.Bvh and 4 for wp.Mesh, changed from a hardcoded value of 4 (GH-994).
Make warp.sparse operations with masked=True consistent with bsr_mm() by preserving result matrix topology, enabling CUDA subgraph capture for bsr_axpy(), bsr_assign() and bsr_set_transpose() (GH-987).
Add max_new_nnz argument to wp.sparse.bsr_mm() providing a synchronization-free path without further assumptions about non-zero topology.
Building warp.fem geometry and function space partitions is now possible in CUDA graphs by passing an explicit upper-bound for the number of cells and nodes to ExplicitGeometryPartition and make_space_partition. Building fields and field restrictions is now synchronization-free by default (GH-1021).
Default the q argument in wp.transform() to the identity quaternion at the kernel scope (GH-923).
Improve efficiency for wp.bvh_query_aabb(), wp.mesh_query_aabb() and wp.bvh_query_ray(). This fixes a performance regression introduced in Warp 1.6.0 (GH-758).

Fixed

Fix segmentation faults on AArch64 CPUs when using tiles. The fix uses stack memory for tile storage and is controlled by wp.config.enable_tiles_in_stack_memory (enabled by default) (GH-957).
Fix copying and filling arrays with large strides (GH-929).
Fix incorrect results when filling arrays in CUDA graphs (GH-1040).
Defer CUDA graph deletion when graph captures are in progress (GH-992).
Fix race conditions in CUDA graph destruction callbacks (GH-1063).
Fix arithmetic operators with scalars and arrays at the Python scope. Operations like scalar * array now work correctly (previously only array * scalar worked) (GH-892).
Fix wp.atomic_add() failing to accumulate wp.int64 values (GH-977).
Fix handling of multi-line lambda expressions and lambda expressions involving parentheses in wp.map() (GH-984).
Fix invalid keyword arguments not being detected in the wp.transform() constructor at the Python scope (GH-975).
Fix return type annotations for struct() and overload() decorators (GH-971).
Suppress TypeError and AttributeError exceptions during Python interpreter shutdown when Warp objects are being cleaned up, as these can be safely ignored during process termination (GH-1048).

1.9.11 Oct 2025Deprecated

The following features have been deprecated in prior releases and will be removed in v1.10 (early November):

Warp v1.9.1

Warp 1.9.1 is a bugfix release that follows our recent feature update. For a full list of changes, see the changelog.

Highlights

GPU Compatibility: Support for older NVIDIA GPU architectures (Maxwell, Pascal, Volta) was unintentionally dropped in the pre-built wheels distributed for Warp 1.9.0 on PyPI. These architectures have been added back.
Documentation Improvements: We have corrected the documentation for wp.mesh_query_aabb() and wp.mesh_query_aabb_next(), added a caveat concerning the use of __cuda_array_interface__ on a system with multiple GPUs, and fixed the labeling of built-in functions that were incorrectly labeled as differentiable.
Corrected Slice Behavior: Empty slices (e.g. arr[i:i]) are now handled correctly at the Python scope, returning an empty array instead of raising an error.
Tile Stability and Correctness: A critical memory management issue with shared tiles has been fixed to prevent unpredictable crashes and memory leaks. Additionally, functions like wp.copy() and wp.where() now work with tiles and compute correct gradients (adjoints).
Tuple Type Hints: Resolved a TypeError that occurred when using modern tuple type hints (e.g., tuple[int, int]) with @wp.func-decorated functions on Python 3.9 and 3.10.

Announcements

Known limitations

CPU Kernels on ARM: Launching CPU kernels on Linux ARM systems, such as NVIDIA Jetson Thor and Grace Hopper, may result in segmentation faults. A fix for this issue is planned for the v1.10 release. GPU kernels are not affected.

Upcoming removals

The following features have been deprecated in prior releases and will be removed in v1.10 (early November):

warp.sim - Use the Newton engine.
Constructing a wp.matrix() from column vectors - Use wp.matrix_from_rows() or wp.matrix_from_cols() instead.
wp.select() - Use wp.where() instead (node: different argument order).
wp.matrix(pos, quat, scale) - Use wp.transform_compose() instead.

Platform support

We plan to drop support for Intel macOS (x86-64) in a future release (tentatively planned for v1.10).

Acknowledgments

We thank the following contributors for their valuable contributions to this release:

@RSchwan for a major contribution that fixed memory management issues with tiles and enabled functions like wp.copy() and wp.where() to work correctly with tile arguments (#777).
@liblaf for reporting issues related to GPU architecture compatibility (#960, #966) and code generation for wp.map() (#953).

Open source →

Additional notes2 sources agree

Added

Add documentation describing Python IntFlag limitations in Warp kernels (GH-917).

Fixed

Fix crash when radix sort is used on multiple streams (e.g., when using hash grids on multiple streams) (GH-950).
Fix empty slice operations arr[i:i] that previously failed with indexing errors (GH-958).
Fix TypeError: Unrecognized type 'tuple[...]' with tuple type annotations on Python 3.10 (GH-959).
Fix memory management issues with shared tiles, including double frees and memory leaks (GH-777).
Fix use of wp.copy(), wp.select(), and wp.where() with tiles (GH-777).
Fix invalid #line directives being emitted for wp.map() calls during code generation (GH-953).
Restore support for older GPU architectures (Maxwell, Pascal, Volta) when building with CUDA 12 (GH-966).
Fix conditional graph compilation on newer GPU architectures by using PTX fallback when CUBIN is not supported (GH-963).
Fix scaling not being correctly applied to rendered meshes in some cases (GH-880).
Fix handling of generic kernels with wp.jax_experimental.ffi.jax_kernel().
Update built-in documentation to accurately reflect their differentiability status (GH-970).

Open source →

1.9.05 Sept 2025Deprecated

The following features have been deprecated in prior releases and will be removed in v1.10 (early November):

Warp 1.9 ships with a rewritten marching cubes implementation, compatibility with the CUDA 13 toolkit, and new functions for ahead-of-time module compilation. The programming model has also been enhanced with more flexible indexing for composite types, direct IntEnum support, and the ability to initialize local arrays in kernels.

New Features

Differentiable marching cubes

A fully differentiable wp.MarchingCubes implementation, contributed by @mikacuy and @nmwsharp, has been added. This version is written entirely in Warp, replacing the previous native CUDA C++ implementation and enabling it to run on both CPU and GPU devices. The implementation also addresses a long-standing off-by-one bug (#324). For more details, see the updated documentation.

Functions for module compilation and loading

We have added wp.compile_aot_module() and wp.load_aot_module() for more flexible ahead-of-time (AOT) compilation.

These functions include a strip_hash=True argument, which removes the unique hashes from compiled module and function names. This change makes it possible to distribute pre-compiled modules without shipping the original Python source code.

See the documentation on ahead-of-time compilation workflows for more details. In future releases, we plan to continue to expand Warp's support for ahead-of-time workflows.

CUDA 13 Support

CUDA Toolkit 13.0 was released in early August.

PyPI Distribution: Warp wheels on PyPI and NVIDIA PyPI will continue to be built with CUDA 12.8 to provide a transition period for users upgrading their CUDA drivers.

CUDA 13.0 Compatibility: Users requiring Warp compiled against CUDA 13.x have two options:

Build Warp from source
Install pre-built wheels from GitHub releases

Driver Compatibility: CUDA 12.8 Warp wheels can run on systems with CUDA 13.x drivers thanks to CUDA's backward compatibility.

Performance Improvements

Graph-capturable linear solvers

The iterative linear solvers in warp.optim.linear (CG, BiCGSTAB, GMRES) are now fully compatible with CUDA graph capture. This adds support for device-side convergence checking via wp.capture_while(), enabling full CUDA graph capture when check_every=0. Users can now choose between traditional host-side convergence checks or fully graph-capturable device-side termination.

Automatic tiling for sparse linear algebra

warp.sparse now supports arbitrary-sized blocks and can leverage tile-based computations for certain matrix types. The system automatically chooses between tiled and non-tiled execution using heuristics based on matrix characteristics (block sizes, sparsity patterns, and workload dimensions). Note that the heuristic for choosing between tiled and non-tiled variants is still being refined, and that it can be manually overridden by providing the tile_size parameter to bsr_mm or bsr_mv.

Automatic tiling for finite element quadrature

warp.fem.integrate now leverages tile-based computations for quadrature point accumulation, with automatic tile size selection based on workload characteristics. The system automatically chooses between tiled and non-tiled execution to optimize performance based on the integration problem size and complexity.

Programming Model Updates

Slice and negative indexing improvements for composite types

We have enhanced the support for slice operations and negative indexing across all composite types (vectors, matrices, quaternions, and transforms).

m = wp.matrix_from_rows(
    wp.vec3(1.0, 2.0, 3.0),
    wp.vec3(4.0, 5.0, 6.0),
    wp.vec3(7.0, 8.0, 9.0),
)
subm = m[:-1, 1:]
print(subm)
# [[2.0, 3.0],
#  [5.0, 6.0]]

Support for `IntEnum` and `IntFlag` inside kernels

It is now possible to directly reference IntEnum and IntFlag values inside Warp functions and kernels. Previously, workarounds involving wp.static() were required.

from enum import IntEnum

class JointType(IntEnum):
    PRISMATIC = 0
    REVOLUTE = 1
    BALL = 2

@wp.kernel
def count_revolute_joints(
    joint_types: wp.array(dtype=JointType),
    counter: wp.array(dtype=int)
):
    tid = wp.tid()
    joint = joint_types[tid]

    # No longer requires wp.static(JointType.REVOLUTE.value)
    if joint == JointType.REVOLUTE:
        wp.atomic_add(counter, 0, 1)

Improved support for `wp.array()` views inside kernels

This enhancement allows kernels to create array views by accessing the ptr attribute of an array.

@wp.kernel
def kernel_array_from_ptr(arr_orig: wp.array2d(dtype=wp.float32)):
    arr = wp.array(ptr=arr_orig.ptr, shape=(2, 3), dtype=wp.float32)
    arr[0, 0] = 1.0
    arr[0, 1] = 2.0
    arr[0, 2] = 3.0

Additionally, these in-kernel views now support dynamic shapes and struct types.

Support for initializing fixed-size arrays inside kernels

It is now possible to allocate local arrays of a fixed size in kernels using wp.zeros(). The resulting arrays are allocated in registers, providing fast access and avoiding global memory overhead.

Previously, developers needed to create vectors to achieve a similar capability, e.g. v = wp.vector(length=8, dtype=float), but this came with various limitations.

@wp.kernel
def kernel_with_local_array():
    local_arr = wp.zeros(8, dtype=wp.float32)  # Allocated in registers
    # ... use local_arr

Indexed tile operations

Warp now provides three new indexed tile operations that enable more flexible memory access patterns beyond simple contiguous tile operations. These functions allow you to load, store, and perform atomic operations on tiles using custom index mappings along specified axes.

wp.tile_load_indexed() - Load tiles with custom index mapping along a specified axis
wp.tile_store_indexed() - Store tiles with custom index mapping along a specified axis
wp.tile_atomic_add_indexed() - Perform atomic additions with custom index mapping along a specified axis

x = wp.array(
    [
        [0.77395605, 0.43887844, 0.85859792, 0.69736803],
        [0.09417735, 0.97562235, 0.7611397, 0.78606431],
        [0.12811363, 0.45038594, 0.37079802, 0.92676499],
    ],
    dtype=float,
)

indices = wp.array([0, 2], dtype=int)


@wp.kernel
def indexed_data_lookup(data: wp.array2d(dtype=float), indices: wp.array(dtype=int)):
    # [0 2] = tile(shape=(2), storage=shared)
    indices_tile = wp.tile_load(indices, shape=(2,))

    # [[0.773956 0.438878 0.858598 0.697368]
    #  [0.128114 0.450386 0.370798 0.926765]] = tile(shape=(2,4), storage=register)
    data_rows_tile = wp.tile_load_indexed(data, indices_tile, axis=0, shape=(2, 4))
    print(data_rows_tile)

    # [[0.773956 0.858598]
    #  [0.0941774 0.76114]
    #  [0.128114 0.370798]] = tile(shape=(3,2), storage=register)
    data_columns_tile = wp.tile_load_indexed(data, indices_tile, axis=1, shape=(3, 2))


wp.launch_tiled(indexed_data_lookup, dim=1, inputs=[x, indices], block_dim=2)

Fixed nested matrix component support

Warp now properly supports writing to individual matrix elements stored within struct fields. Previously, operations like struct.matrix[1, 2] = value would result in a compile-time error.

@wp.struct
class MatStruct:
    m: wp.mat44

@wp.kernel
def kernel_nested_mat(out: wp.array(dtype=MatStruct)):
    s = MatStruct()
    s.m[1, 2] = 3.0  # This now works correctly (no longer raises a WarpCodegenError)
    s.m[2][2] = 5.0  # This has also been fixed (used to silently fail)
    out[0] = s

Announcements

Known limitations

Early testing on NVIDIA Jetson Thor indicates that launching CPU kernels may sometimes result in segmentation faults. GPU kernel launches are unaffected. We believe this can be resolved by building Warp from source against LLVM/Clang version 18 or newer.

Upcoming removals

The following features have been deprecated in prior releases and will be removed in v1.10 (early November):

warp.sim - Use the Newton engine.
Constructing a wp.matrix() from column vectors - Use wp.matrix_from_rows() or wp.matrix_from_cols() instead.
wp.select() - Use wp.where() instead (note: different argument order).
wp.matrix(pos, quat, scale) - Use wp.transform_compose() instead.

Platform support

We plan to drop support for Intel macOS (x86-64) in a future release (tentatively planned for v1.10).

Acknowledgments

We thank the following contributors for their valuable contributions to this release:

@liblaf for fixing an issue with using warp.jax_experimental.ffi.jax_callable() with a function annotated with the -> None return type (#893).
@matthewdcong for providing an updated version of NanoVDB compatible with CUDA 13 (#888).
@YuyangLee for contributing an early prototype that helped shape the strip_hash=True option for the new ahead-of-time compilation functions (#661).

Full Changelog

For a curated list of all changes in this release, please see the v1.9.0 section in CHANGELOG.md.

Open source →

Additional notes2 sources agree

Added

Add support for building Warp with CUDA 13.
Add wp.MarchingCubes.extract_surface_marching_cubes() to extract a triangular mesh from a 3D scalar field (GH-788).
Add wp.compile_aot_module() and wp.load_aot_module() to support basic ahead-of-time compilation workflows (docs, GH-766).
Add support for negative indexing and improve slicing for the wp.matrix()/wp.vector()/wp.quaternion() types (GH-899).
Add support for retrieving the memory address of a Warp array in kernels as array.ptr (GH-819).
Add support for using struct types in the wp.array() constructor inside kernels (GH-853).
Add support for initializing fixed-size arrays inside kernels using wp.zeros() (GH-794).
Add support for IntEnum and IntFlag inside Warp kernels (GH-529).
Add bounds_check option to wp.tile_load(), wp.tile_store(), and wp.tile_atomic_add() for performance optimization. When set to False, boundary checks are disabled for memory-aligned tiles, improving performance (defaults to True for safety) (GH-797).
Add indexed tile operations: wp.tile_index_load(), wp.tile_index_store(), and wp.tile_index_atomic_add() (GH-684, GH-796).
Add optional block_dim argument to wp.load_module() and wp.force_load().
Add support for displaying and editing Warp vector and array types in ImGui (GH-844).
Extend examples/core/example_render_opengl.py example with comprehensive ImGui usage examples (GH-833).

Removed

Remove support for building Warp with CUDA 11.

Deprecated

Deprecate support for Intel-based macOS (x86_64) with removal targeted in late 2025. We will continue to support Apple Silicon-based Macs with the CPU backend. Users on Intel-based hardware will now receive a DeprecationWarning with this information.

Changed

Enforce strict argument matching for user-function calls from the Python scope, mirroring built-in function behavior.
Enforce a consistent wp_ prefix for all exported, C-style symbols to prevent name conflicts (GH-792).
Rewrite wp.MarchingCubes in pure Warp for cross-platform support and differentiability (GH-788).
Allow dynamic shapes when constructing a wp.array from a pointer inside a kernel.
Allow functions passed to wp.tile_map() to return a different type than their input arguments (GH-732).
Use codegen instead of function evaluation to infer return types for wp.map() (GH-732).
Enable warp.sparse to efficiently process sparse matrices with arbitrarily sized blocks and leverage tiled computations when beneficial (GH-838).
Enable opportunistic use of tile-based computations in warp.fem.integrate for quadrature-point accumulation (GH-854).
Use an extended-length default cache path on Windows to prevent build errors (GH-870).
Add support for wp.breakpoint() in CUDA kernels on Linux systems. This feature is not supported on Windows due to CUDA-GDB Linux-target-only support (GH-795).
Skip generating code for unreferenced adjoint functions, reducing JIT compilation time (GH-841).
Define and re-export Warp's public Python-scope API in __init__.py using typing re-export conventions to improve static type checker support (GH-864).
Improve error messages for MathDx-based tile operations that fail to compile (e.g., Failed to compile LTO) (GH-608, GH-911).
Improve error detection and reporting in conditional graphs (GH-866).

Fixed

Fix ARM64 CPU kernel argument passing issues by packaging arguments into a structure to work around a libffi library bug (GH-356).
Fix matrix assignment and indexing operations when matrices are stored as struct members (GH-793).
Fix str() and repr() implementations missing for scalar types at the Python scope (GH-863).
Fix issue with calling user functions from the Python scope with wp.array parameters.
Fix 2D shared tile allocation/de-allocation bug inside Warp functions (GH-877).
Fix wp.load_module() when loading modules created with @wp.kernel(module="unique").
Fix an off-by-one error in marching cubes output coordinates to align with the scikit-image convention (GH-324).
Fix UnboundLocalError when applying warp.jax_experimental.ffi.jax_callable to a function annotated with the None return type (GH-893).
Fix compatibility of the OpenGL renderer with macOS (GH-834).
Fix evaluation of Discontinuous Galerkin gradients for warp.fem discrete fields.
Work around caching issue (GH-637) with operator evaluation in warp.fem integrands.
Fix adding superfluous inactive nodes to tetrahedron polynomial function spaces in warp.fem.
Fix #line directives for Python↔CUDA source correlation not being emitted by default when a module is compiled in debug mode (GH-901).

1.8.11 Aug 2025Deprecated3 sources agree

However, to support the adoption of Warp by the MuJoCo MJX physics engine, it also includes new features and deprecations limited to the jax_experimen…

This patch release primarily contains bug fixes as expected.

However, to support the adoption of Warp by the MuJoCo MJX physics engine, it also includes new features and deprecations limited to the jax_experimental module. We are flagging this deviation from our standard versioning practices to ensure clarity. Normal versioning practices will resume with the next release.

Full Changelog

Deprecated

This is the final release that will provide builds for or support the CUDA 11.x Toolkit and driver. Starting with v1.9.0, Warp will require CUDA 12.x or newer.
Deprecate the graph_compatible boolean flag in jax_callable() in favor of the new graph_mode argument with GraphMode enum (#848).

Added

Add documentation for creating and manipulating Warp structured arrays using NumPy (#852)
Add documentation for wp.indexedarray() (#468).
Support input-output aliasing in JAX FFI (#815).
Support capturing jax_callable() using Warp via the new graph_mode parameter (GraphMode.WARP), enabling capture of graphs with conditional nodes that cannot be used as subgraphs in a JAX capture (#848).

Fixed

Fix tape.zero() to correctly reset gradient arrays in nested structs (#807).
Fix incorrect adjoints for div(scalar, vec), div(scalar, mat), and div(scalar, quat), and other miscellaneous issues with adjoints (#831).
Fix a module-hashing issue for functions or kernels using static expressions that cannot be resolved at the time of declaration (#830).
Fix a bug in which changes to wp.config.mode were not being picked up after module initialization (#856).
Fix a bug where CUDA modules could get prematurely unloaded when conditional graph nodes are used.
Fix compile time regression for kernels using matmul, Cholesky, and FFT solvers by upgrading to libmathdx 0.2.2 (#809).
Fix potential uninitialized memory issues in wp.tile_sort() (#836).
Fix wp.tile_min() and wp.tile_argmin() to return correct values for large tiles with low occupancy (#725).
Fix codegen errors associated with adjoint of wp.tile_sum() when using shared tiles (#822).
Fix driver entry point error for cuDeviceGetUuid caused by using an incorrect version (#851).
Fix an issue that caused Warp to request PTX generation from NVRTC for architectures unsupported by the compiler (#858).
Fix a regression where wp.sparse.bsr_from_triplets() ignored the prune_numerical_zeros=False setting (#832).
Fix missing cloth-body contact in wp.sim.VBDIntegrator with handle_self_contact=False (#862).
Fix a bug causing potential infinite loops in the color balancing calculation (#816).
Fix box-box collision by computing the contact normal at the closest point of approach instead of at the center of the source box (#839).
Fix the OpenGL renderer not correctly displaying colors for box shapes (#810).
Fix a bug in OpenGLRenderer where meshes with different scale attributes were incorrectly instanced, causing them all to be rendered with the same scale OpenGLRenderer (#828).

Open source →

1.8.01 Jul 2025Deprecated3 sources agree

Remove wp.mlp() (deprecated in v1.6.0). Use tile primitives instead.

Changelog

[1.8.0] - 2025-07-01

Added

Add wp.map() to map a function over arrays and add math operators for Warp arrays (docs, #694).
Add support for dynamic control flow in CUDA graphs, see wp.capture_if() and wp.capture_while() (docs, #597).
Add wp.capture_debug_dot_print() to write a DOT file describing the structure of a captured CUDA graph (#746).
Add the Device.sm_count property to get the number of streaming multiprocessors on a CUDA device (#584).
Add wp.block_dim() to query the number of threads in the current block inside a kernel (#695).
Add wp.atomic_cas() and wp.atomic_exch() built-ins for atomic compare-and-swap and exchange operations (#767).
Add support for profiling GPU runtime module compilation using the global wp.config.compile_time_trace setting or the module-level "compile_time_trace" option. When used, JSON files in the Trace Event format will be written in the kernel cache, which can be opened in a viewer like chrome://tracing/ (docs, #609).
Add support for returning multiple values from native functions like wp.svd3() and wp.quat_to_axis_angle() (#503).
Add support for passing tiles to user wp.func functions (#682).
Add wp.tile_squeeze() to remove axes of length one (#662).
Add wp.tile_reshape() to reshape a tile (#663).
Add wp.tile_astype() to return a new tile with the same data but different data type. (#683).
Add support for in-place tile add and subtract operations (#518).
Add support for in-place tile-component addition and subtraction (#659).
Add support for 2D solves using wp.tile_cholesky_solve() (#773).
Add wp.tile_scan_inclusive() and wp.tile_scan_exclusive() for performing inclusive and exclusive scans over tiles (#731).
Support attribute indexing for quaternions on the right-hand side of expressions (#625).
Add wp.transform_compose() and wp.transform_decompose() for converting between transforms and 4x4 matrices with 3D scale information (#576).
Add various wp.transform syntax operations for loading and storing (#710).
Add the as_spheres parameter to UsdRenderer.render_points() in order to choose whether to render the points as USD spheres using a point instancer or as simple USD points (#634).
Add support for animating visibility of objects in the USD renderer (#598).
Add wp.sim.VBDIntegrator.rebuild_bvh() to rebuild the BVH used for detecting self-contacts.
Add damping terms wp.sim.VBDIntegrator collisions, with strength is controlled by Model.soft_contact_kd.
Improve consistency of the wp.fem.lookup() operator across geometries and add filtering parameters (#618).
Add two examples demonstrating shape optimization using warp.fem: fem/example_elastic_shape_optimization.py and fem/example_darcy_ls_optimization.py (#698).
Add a py.typed marker file (per PEP 561) to the package to formally support static type checking by downstream users (#780).

Removed

Remove wp.mlp() (deprecated in v1.6.0). Use tile primitives instead.
Remove wp.autograd.plot_kernel_jacobians() (deprecated in v1.4.0). Use wp.autograd.jacobian_plot() instead.
Remove the length and owner keyword arguments from wp.array() constructor (deprecated in v1.6.0). Use the shape and deleter keywords instead.
Remove the kernel keyword argument from wp.autograd.jacobian() and wp.autograd.jacobian_fd() (deprecated in v1.6.0). Use the function keyword argument instead.
Remove the outputs keyword argument from wp.autograd.jacobian_plot() (deprecated in v1.6.0).

Changed

Deprecate the warp.sim module (planned for removal in v1.10). It will be superseded by the upcoming Newton library, a separate package with a new API. Migrating will require code changes; a future guide will be provided (current draft). See the GitHub announcement for details (#735).
Deprecate the wp.matrix(pos, quat, scale) built-in function. Use wp.transform_compose() instead (#576).
Improve support for tuples in kernels (#506).
Return a constant value from len() where possible.
Rename the internal function wp.types.type_length() to wp.types.type_size().
Rename wp.tile_cholesky_solve() input parameters to align with its docstring (#726).
Change wp.tile_upper_solve() and wp.tile_lower_solve() to use libmathdx 0.2.1 TRSM solver (#773).
Skip adjoint compilation for wp.tile_matmul() if enable_backward is disabled (#644).
Allow tile reductions to work with non-scalar tile types (#771).
Permit data-type preservation with preserve_type=True when tiling a value across the block with wp.Tile() (#772).
Make wp.sparse.bsr_[set_]from_triplets differentiable with respect to the input triplet values (#760).
Expose new warp.fem operators: node_count, node_index, element_coordinates, element_closest_point.
Change wp.sim.VBDIntegrator rigid-body-contact handling to use only the shape's friction coefficient, rather than averaging the shape's and the cloth's coefficients.
Limit usage of the wp.assign_copy() hidden built-in to the kernel scope.
Describe the distinction between inputs and outputs arguments in the Kernel documentation.
Reduce the overhead of wp.launch() by avoiding costly native API calls (#774).
Improve error reporting when calling @wp.func-decorated functions from the Python scope (#521).

Fixed

Fix missing documentation for geometric structs (#674).
Fix the type annotations in various tile functions (#714).
Fix incorrect stride initialization in tiles returned from functions taking transposed tiles as input (#722).
Fix adjoint generation for user functions that return a tile (#749).
Fix tile-based solvers failing to accept and return transposed tiles (#768).
Fix the Formal parameter space overflowed error during wp.sim.VBDIntegrator kernel compilation for the backward pass in CUDA 11 Warp builds. This was resolved by decoupling collision and elasticity evaluations into separate kernels, increasing parallelism and speeding up the solver (#442).
Fix an issue with graph coloring on an empty graph (#509).
Fix an integer overflow bug in the native graph coloring module (#718).
Fix UsdRenderer.render_points() not supporting multiple colors (#634).
Fix an inconsistency in the wp.fem module regarding the orientation of 2D geometry side normals (#629).
Fix premature unloading of CUDA modules used in JAX FFI graph captures (#782).

Open source →

1.7.11 May 2025Deprecated3 sources agree

Improve handling of deprecated JAX features (#613).

Changelog

[1.7.1] - 2025-04-30

Added

Add example of a distributed Jacobi solver using mpi4py in warp/examples/distributed/example_jacobi_mpi.py (#475).

Changed

Improve repr() for Warp types, including adding repr() for wp.array.
Change the USD renderer to use framesPerSecond for time sampling instead of timeCodesPerSecond to avoid playback speed issues in some viewers (#617).
Model.rigid_contact_tids are now -1 at non-active contact indices which allows to retrieve the vertex index of a mesh collision, see test_collision.py (#623).
Improve handling of deprecated JAX features (#613).

Fixed

Fix a code generation bug involving return statements in Warp kernels, which could result in some threads in Warp being skipped when processed on the GPU (#594).
Fix constructing DeformedGeometry from wp.fem.Trimesh3D geometries (#614).
Fix lookup operator for wp.fem.Trimesh3D (#618).
Include the block dimension in the LTO file hash for the Cholesky solver (#639).
Fix tile loads for small tiles with aligned source memory (#622).
Fix length/shape matching for vectors and matrices from the Python scope.
Fix the dtype parameter missing for wp.quaternion().
Fix invalid dtype comparison when using the wp.matrix()/wp.vector()/wp.quaternion() constructors with literal values and an explicit dtype argument (#651).
Fix incorrect thread index lookup for the backward pass of wp.sim.collide() (#459).
Fix a bug where wp.sim.ModelBuilder adds springs with -1 as vertex indices (#621).
Fix center of mass, inertia computation for mesh shapes (#251).
Fix computation of body center of mass to account for shape orientation (#648).
Fix show_joints not working with wp.sim.render.SimRenderer set to render to USD (#510).
Fix the jitter for the OgnParticlesFromMesh node not being computed correctly.
Fix documentation of atol and rtol arguments to wp.autograd.gradcheck() and wp.autograd.gradcheck_tape() (#508).

Open source →

1.7.030 Mar 2025Deprecated3 sources agree

Deprecate constructing a matrix from vectors using wp.matrix().

Changelog

[1.7.0] - 2025-03-30

Added

Support JAX foreign function interface (FFI) (docs, #511).
Support Python/SASS correlation in Nsight Compute reports by emitting #line directives in CUDA-C code. This setting is controlled by wp.config.line_directives and is True by default. (docs, #437)
Support vec4f grid construction in wp.Volume.allocate_by_tiles().
Add 2D SVD wp.svd2() (#436).
Add wp.randu() for random uint32 generation.
Add matrix construction functions wp.matrix_from_cols() and wp.matrix_from_rows() (#278).
Add wp.transform_from_matrix() to obtain a transform from a 4x4 matrix (#211).
Add wp.where() to select between two arguments conditionally using a more intuitive argument order (cond, value_if_true, value_if_false) (#469).
Add wp.get_mempool_used_mem_current() and wp.get_mempool_used_mem_high() to query the respective current and high-water mark memory pool allocator usage (#446 ).
Add Stream.is_complete and Event.is_complete properties to query completion status (#435).
Support timing events inside of CUDA graphs (#556).
Add LTO cache to speed up compilation times for kernels using MathDx-based tile functions. Use wp.clear_lto_cache() to clear the LTO cache (#507).
Add example demonstrating gradient checkpointing for fluid optimization in warp/examples/optim/example_fluid_checkpoint.py.
Add a hinge-angle-based bending force to wp.sim.VBDIntegrator.
Add an example to show mesh sampling using a CDF (#476).

Changed

Breaking: Remove CUTLASS dependency and wp.matmul() functionality (including batched version). Users should use tile primitives for matrix multiplication operations instead.
Deprecate constructing a matrix from vectors using wp.matrix().
Deprecate wp.select() in favor of wp.where(). Users should update their code to use wp.where(cond, value_if_true, value_if_false) instead of wp.select(cond, value_if_false, value_if_true).
wp.sim.Control no longer has a model attribute (#487).
wp.sim.Control.reset() is deprecated and now only zeros-out the controls (previously restored controls to initial model state). Use wp.sim.Control.clear() instead.
Vector/matrix/quaternion component assignment operations (e.g., v[0] = x) now compile and run faster in the backward pass. Note: For correct gradient computation, each component should only be assigned once.
@wp.kernel has now an optional module argument that allows passing a wp.context.Module to the kernel, or, if set to "unique" let Warp create a new unique module just for this kernel. The default behavior to use the current module is unchanged.
Default PTX architecture is now automatically determined by the devices present in the system, ensuring optimal compatibility and performance (#537).
Structs now have a trivial default constructor, allowing for wp.tile_reduce() on tiles with struct data types.
Extend wp.tile_broadcast() to support broadcasting to 1D, 3D, and 4D shapes (in addition to existing 2D support).
wp.fem.integrate() and wp.fem.interpolate() may now perform parallel evaluation of quadrature points within elements.
wp.fem.interpolate() can now build Jacobian sparse matrices of interpolated functions with respect to a trial field.
Multiple wp.sparse routines (bsr_set_from_triplets, bsr_assign, bsr_axpy, bsr_mm) now accept a masked flag to discard any non-zero not already present in the destination matrix.
wp.sparse.bsr_assign() no longer requires source and destination block shapes to evenly divide each other.
Extend wp.expect_near() to support all vectors and quaternions.
Extend wp.quat_from_matrix() to support 4x4 matrices.
Update the OgnClothSimulate node to use the VBD integrator (#512).
Remove the globalScale parameter from the OgnClothSimulate node.

Fixed

Fix an out-of-bounds access bug caused by an unbalanced BVH tree (#536).
Fix an error of incorrectly adding the offset to -1 elements in edge_indices when adding a ModelBuilder to another (#557).

Open source →

1.6.03 Feb 2025Deprecated3 sources agree

Emit deprecation warnings for the use of the owner and length keywords in the wp.array initializer.

Changelog

[1.6.0] - 2025-02-03

Added

Add preview of Tile Cholesky factorization and solve APIs through wp.tile_cholesky(), tile_cholesky_solve() and tile_diag_add() (preview APIs are subject to change).
Support for loading tiles from arrays whose shapes are not multiples of the tile dimensions. Out-of-bounds reads will be zero-filled and out-of-bounds writes will be skipped.
Support for higher-dimensional (up to 4D) tile shapes and memory operations.
Add intersection-free self-contact support in wp.sim.VDBIntegrator by passing handle_self_contact=True. See warp/examples/sim/example_cloth_self_contact.py for a usage example.
Add functions wp.norm_l1(), wp.norm_l2(), wp.norm_huber(), wp.norm_pseudo_huber(), and wp.smooth_normalize() for vector types to a new wp.math module.
wp.sim.SemiImplicitIntegrator and wp.sim.FeatherstoneIntegrator now have an optional friction_smoothing constructor argument (defaults to 1.0) that controls softness of the friction norm computation.
Support assert statements in kernels (docs). Assertions can only be triggered in "debug" mode (GH-366).
Support CUDA IPC on Linux. Call the ipc_handle() method to get an IPC handle for a wp.Event or a wp.array, and call wp.from_ipc_handle() or wp.event_from_ipc_handle() in another process to open the handle (docs).
Add per-module option to disable fused floating point operations, use wp.set_module_options({"fuse_fp": False}) (GH-379).
Add per-module option to add CUDA-C line information for profiling, use wp.set_module_options({"lineinfo": True}).
Support operator overloading for wp.struct objects by defining wp.func functions (GH-392).
Add built-in function wp.len() to retrieve the number of elements for vectors, quaternions, matrices, and arrays (GH-389).
Add warp/examples/optim/example_softbody_properties.py as an optimization example for soft-body properties (GH-419).
Add warp/examples/tile/example_tile_walker.py, which reworks the existing example_walker.py to use Warp's tile API for matrix multiplication.
Add warp/examples/tile/example_tile_nbody.py as an example of an N-body simulation using Warp tile primitives.

Changed

Breaking: Change wp.tile_load() and wp.tile_store() indexing behavior so that indices are now specified in terms of array elements instead of tile multiples.
Breaking: Tile operations now take shape and offset parameters as tuples, e.g.: wp.tile_load(array, shape=(m,n), offset=(i,j)).
Breaking: Change exception types and error messages thrown by tile functions for improved consistency.
Add an implicit tile synchronization whenever a shared memory tile's data is reinitialized (e.g. in dynamic loops). This could result in lower performance.
wp.Bvh constructor now supports various construction algorithms via the constructor argument, including "sah" (Surface Area Heuristics), "median", and "lbvh" (docs)
Improve the query efficiency of wp.Bvh and wp.Mesh.
Improve memory consumption, compilation and runtime performance when using in-place vector/matrix assignments in kernels that have enable_backward set to False (GH-332).
Vector/matrix/quaternion component += and -= operations compile and run faster in the backward pass (GH-332).
Name files in the kernel cache according to their directory. Previously, all files began with module_codegen (GH-431).
Avoid recompilation of modules when changing block_dim.
wp.autograd.gradcheck_tape() now has additional optional arguments reverse_launches and skip_to_launch_index.
wp.autograd.gradcheck(), wp.autograd.jacobian(), and wp.autograd.jacobian_fd() now also accept arbitrary Python functions that have Warp arrays as inputs and outputs.
update_vbo_transforms kernel launches in the OpenGL renderer are no longer recorded onto the tape.
Skip emitting backward functions/kernels in the generated C++/CUDA code when enable_backward is set to False.
Emit deprecation warnings for the use of the owner and length keywords in the wp.array initializer.
Emit deprecation warnings for the use of wp.mlp(), wp.matmul(), and wp.batched_matmul(). Use tile primitives instead.

Fixed

Fix unintended modification of non-Warp arrays during the backward pass (GH-394).
Fix so that wp.Tape.zero() zeroes gradients passed via the grads parameter in wp.Tape.backward() (GH-407).
Fix errors during graph capture caused by module unloading (GH-401).
Fix potential memory corruption errors when allocating arrays with strides (GH-404).
Fix wp.array() not respecting the target dtype and shape when the given data is an another array with a CUDA interface (GH-363).
Negative constants evaluate to compile-time constants (GH-403)
Fix ImportError exception being thrown during interpreter shutdown on Windows when using the OpenGL renderer (GH-412).
Fix the OpenGL renderer not working when multiple instances exist at the same time (GH-385).
Fix AttributeError crash in the OpenGL renderer when moving the camera (GH-426).
Fix the OpenGL renderer not correctly displaying duplicate capsule, cone, and cylinder shapes (GH-388).
Fix the overriding of wp.sim.ModelBuilder default parameters (GH-429).
Fix indexing of wp.tile_extract() when the block dimension is smaller than the tile size.
Fix scale and rotation issues with the rock geometry used in the granular collision SDF example (GH-409).
Fix autodiff Jacobian computation in wp.autograd.jacobian() where in some cases gradients were not zeroed-out properly.
Fix plotting issues in wp.autograd.jacobian_plot().
Fix the len() operator returning the total size of a matrix instead of its first dimension.
Fix gradient instability in rigid-body contact handling for wp.sim.SemiImplicitIntegrator and wp.sim.FeatherstoneIntegrator (GH-349).
Fix overload resolution of generic Warp functions with default arguments.
Fix rendering of arrows with different up_axis, color in OpenGLRenderer (GH-448).

Open source →

1.5.03 Dec 20243 sources agree

Support for cooperative tile-based primitives using cuBLASDx and cuFFTDx, please see the tile documentation for details.

Changelog

[1.5.0] - 2024-12-02

Added

Support for cooperative tile-based primitives using cuBLASDx and cuFFTDx, please see the tile documentation for details.
Expose a reversed() built-in for iterators (GH-311).
Support for saving Volumes into .nvdb files with the save_to_nvdb method.
warp.fem: Add wp.fem.Trimesh3D and wp.fem.Quadmesh3D geometry types for 3D surfaces with new example_distortion_energy example.
warp.fem: Add "add" option to wp.fem.integrate() for accumulating integration result to existing output.
warp.fem: Add "assembly" option to wp.fem.integrate() for selecting between more memory-efficient or more computationally efficient integration algorithms.
warp.fem: Add Nédélec (first kind) and Raviart-Thomas vector-valued function spaces providing conforming discretization of curl and div operators, respectively.
warp.sim: Add a graph coloring module that supports converting trimesh into a vertex graph and applying coloring. The wp.sim.ModelBuilder now includes methods to color particles for use with wp.sim.VBDIntegrator(), users should call builder.color() before finalizing assets.
warp.sim: Add support for a per-particle radius for soft-body triangle contact using the wp.sim.Model.particle_radius array (docs), replacing the previous hard-coded value of 0.01 (GH-329).
Add a particle_radius parameter to wp.sim.ModelBuilder.add_cloth_mesh() and wp.sim.ModelBuilder.add_cloth_grid() to set a uniform radius for the added particles.
Document wp.array attributes (GH-364).
Document time-to-compile tradeoffs when using vector component assignment statements in kernels.
Add introductory Jupyter notebooks to the notebooks directory.

Changed

Drop support for Python 3.7; Python 3.8 is now the minimum-supported version.
Promote the wp.Int, wp.Float, and wp.Scalar generic annotation types to the public API.
warp.fem: Simplify querying neighboring cell quantities when integrating on sides using new wp.fem.cells(), wp.fem.to_inner_cell(), wp.fem.to_outer_cell() operators.
Show an error message when the type returned by a function differs from its annotation, which would have led to the compilation stage failing.
Clarify that wp.randn() samples a normal distribution of mean 0 and variance 1.
Raise error when passing more than 32 variadic argument to the wp.printf() built-in.

Fixed

Fix place setting of paddle backend.
warp.fem: Fix tri-cubic shape functions on quadrilateral meshes.
warp.fem: Fix caching of integrand kernels when changing code-generation options.
Fix wp.expect_neq() overloads missing for scalar types.
Fix an error when a wp.kernel or a wp.func object is annotated to return a None value.
Fix error when reading multi-volume, BLOSC-compressed .nvdb files.
Fix wp.printf() erroring out when no variadic arguments are passed (GH-333).
Fix memory access issues in soft-rigid contact collisions (GH-362).
Fix gradient propagation for in-place addition/subtraction operations on custom vector-type arrays.
Fix the OpenGL renderer's window not closing when clicking the X button.
Fix the OpenGL renderer's camera snapping to a different direction from the initial camera's orientation when first looking around.
Fix custom colors being ignored when rendering meshes in OpenGL (GH-343).
Fix topology updates not being supported by the the OpenGL renderer.

Open source →

1.4.01 Oct 20243 sources agree

Support for a new wp.static(expr) function that allows arbitrary Python expressions to be evaluated at the time of function/kernel definition (docs).

CHANGELOG

[1.4.0] - 2024-10-01

Added

Support for a new wp.static(expr) function that allows arbitrary Python expressions to be evaluated at the time of function/kernel definition (docs).
Support for stream priorities to hint to the device that it should process pending work in high-priority streams over pending work in low-priority streams when possible (docs).
Adaptive sparse grid geometry to warp.fem (docs).
Support for defining wp.kernel and wp.func objects from within closures.
Support for defining multiple versions of kernels, functions, and structs without manually assigning unique keys.
Support for default argument values for user functions decorated with wp.func.
Allow passing custom launch dimensions to jax_kernel() (GH-310).
JAX interoperability examples for sharding and matrix multiplication (docs).
Interoperability support for the PaddlePaddle ML framework (GH-318).
Support wp.mod() for vector types (GH-282).
Expose the modulo operator % to Python's runtime scalar and vector types.
Support for fp64 atomic_add, atomic_max, and atomic_min (GH-284).
Support for quaternion indexing (e.g. q.w).
Support shadowing builtin functions (GH-308).
Support for redefining function overloads.
Add an ocean sample to the omni.warp extension.
warp.sim.VBDIntegrator now supports body-particle collision.
Add a contributing guide to the Sphinx docs .
Add documentation for dynamic code generation (docs).

Changed

wp.sim.Model.edge_indices now includes boundary edges.
Unexposed wp.rand*(), wp.sample*(), and wp.poisson() from the Python scope.
Skip unused functions in module code generation, improving performance.
Avoid reloading modules if their content does not change, improving performance.
wp.Mesh.points is now a property instead of a raw data member, its reference can be changed after the mesh is initialized.
Improve error message when invalid objects are referenced in a Warp kernel.
if/else/elif statements with constant conditions are resolved at compile time with no branches being inserted in the generated code.
Include all non-hidden builtins in the stub file.
Improve accuracy of symmetric eigenvalues routine in warp.fem.

Fixed

Fix for wp.func erroring out when defining a Tuple as a return type hint (GH-302).
Fix array in-place op (+=, -=) adjoints to compute gradients correctly in the backwards pass
Fix vector, matrix in-place assignment adjoints to compute gradients correctly in the backwards pass, e.g.: v[1] = x
Fix a bug in which Python docstrings would be created as local function variables in generated code.
Fix a bug with autograd array access validation in functions from different modules.
Fix a rare crash during error reporting on some systems due to glibc mismatches.
Handle --num_tiles 1 in example_render_opengl.py (GH-306).
Fix the computation of body contact forces in FeatherstoneIntegrator when bodies and particles collide.
Fix bug in FeatherstoneIntegrator where eval_rigid_jacobian could give incorrect results or reach an infinite loop when the body and joint indices were not in the same order. Added Model.joint_ancestor to fix the indexing from a joint to its parent joint in the articulation.
Fix wrong vertex index passed to add_edges() called from ModelBuilder.add_cloth_mesh() (GH-319).
Add a workaround for uninitialized memory read warning in the compute-sanitizer initcheck tool when using wp.Mesh.
Fix name clashes when Warp functions and structs are returned from Python functions multiple times.
Fix name clashes between Warp functions and structs defined in different modules.
Fix code generation errors when overloading generic kernels defined in a Python function.
Fix issues with unrelated functions being treated as overloads (e.g., closures).
Fix handling of stream argument in array.__dlpack__().
Fix a bug related to reloading CPU modules.
Fix a crash when kernel functions are not found in CPU modules.
Fix conditions not being evaluated as expected in while statements.
Fix printing Boolean and 8-bit integer values.
Fix array interface type strings used for Boolean and 8-bit integer values.
Fix initialization error when setting struct members.
Fix Warp not being initialized upon entering a wp.Tape context.
Use kDLBool instead of kDLUInt for DLPack interop of Booleans.

Open source →

1.3.34 Sept 20243 sources agree

Fix an aliasing issue with zero-copy array initialization from NumPy introduced in Warp 1.3.0.

[1.3.3] - 2024-09-04

Bug fixes
- Fix an aliasing issue with zero-copy array initialization from NumPy introduced in Warp 1.3.0.
- Fix wp.Volume.load_from_numpy() behavior when bg_value is a sequence of values.

[1.3.2] - 2024-08-30

Bug fixes
- Fix accuracy of 3x3 SVD wp.svd3 with fp64 numbers (GH-281).
- Fix module hashing when a kernel argument contained a struct array (GH-287).
- Fix a bug in wp.bvh_query_ray() where the direction instead of the reciprocal direction was used (GH-288).
- Fix errors when launching a CUDA graph after a module is reloaded. Modules that were used during graph capture will no longer be unloaded before the graph is released.
- Fix a bug in wp.sim.collide.triangle_closest_point_barycentric() where the returned barycentric coordinates may be incorrect when the closest point lies on an edge.
- Fix 32-bit overflow when array shape is specified using np.int32.
- Fix handling of integer indices in the input_output_mask argument to autograd.jacobian and autograd.jacobian_fd (GH-289).
- Fix ModelBuilder.collapse_fixed_joints() to correctly update the body centers of mass and the ModelBuilder.articulation_start array.
- Fix precedence of closure constants over global constants.
- Fix quadrature point indexing in wp.fem.ExplicitQuadrature (regression from 1.3.0).
Documentation improvements
- Add missing return types for built-in functions.
- Clarify that atomic operations also return the previous value.
- Clarify that wp.bvh_query_aabb() returns parts that overlap the bounding volume.

[1.3.1] - 2024-07-27

Remove wp.synchronize() from PyTorch autograd function example
Tape.check_kernel_array_access() and Tape.reset_array_read_flags() are now private methods.
Fix reporting unmatched argument types

[1.3.0] - 2024-07-25

Warp Core improvements
- Update to CUDA 12.x by default (requires NVIDIA driver 525 or newer), please see README.md for commands to install CUDA 11.x binaries for older drivers
- Add information to the module load print outs to indicate whether a module was compiled (compiled), loaded from the cache (cached), or was unable to be loaded (error).
- wp.config.verbose = True now also prints out a message upon the entry to a wp.ScopedTimer.
- Add wp.clear_kernel_cache() to the public API. This is equivalent to wp.build.clear_kernel_cache().
- Add code-completion support for wp.config variables.
- Remove usage of a static task (thread) index for CPU kernels to address multithreading concerns (GH-224)
- Improve error messages for unsupported Python operations such as sequence construction in kernels
- Update wp.matmul() CPU fallback to use dtype explicitly in np.matmul() call
- Add support for PEP 563's from __future__ import annotations (GH-256).
- Allow passing external arrays/tensors to wp.launch() directly via __cuda_array_interface__ and __array_interface__, up to 2.5x faster conversion from PyTorch
- Add faster Torch interop path using return_ctype argument to wp.from_torch()
- Handle incompatible CUDA driver versions gracefully
- Add wp.abs() and wp.sign() for vector types
- Expose scalar arithmetic operators to Python's runtime (e.g.: wp.float16(1.23) * wp.float16(2.34))
- Add support for creating volumes with anisotropic transforms
- Allow users to pass function arguments by keyword in a kernel using standard Python calling semantics
- Add additional documentation and examples demonstrating wp.copy(), wp.clone(), and array.assign() differentiability
- Add __new__() methods for all class __del__() methods to handle when a class instance is created but not instantiated before garbage collection
- Implement the assignment operator for wp.quat
- Make the geometry-related built-ins available only from within kernels
- Rename the API-facing query types to remove their _t suffix: wp.BVHQuery, wp.HashGridQuery, wp.MeshQueryAABB, wp.MeshQueryPoint, and wp.MeshQueryRay
- Add wp.array(ptr=...) to allow initializing arrays from pointer addresses inside of kernels (GH-206)
warp.autograd improvements:
- New warp.autograd module with utility functions gradcheck(), jacobian(), and jacobian_fd() for debugging kernel Jacobians (docs)
- Add array overwrite detection, if wp.config.verify_autograd_array_access is true in-place operations on arrays on the Tape that could break gradient computation will be detected (docs)
- Fix bug where modification of @wp.func_replay functions and native snippets would not trigger module recompilation
- Add documentation for dynamic loop autograd limitations
warp.sim improvements:
- Improve memory usage and performance for rigid body contact handling when self.rigid_mesh_contact_max is zero (default behavior).
- The mask argument to wp.sim.eval_fk() now accepts both integer and boolean arrays to mask articulations.
- Fix handling of ModelBuilder.joint_act in ModelBuilder.collapse_fixed_joints() (affected floating-base systems)
- Fix and improve implementation of ModelBuilder.plot_articulation() to visualize the articulation tree of a rigid-body mechanism
- Fix ShapeInstancer __new__() method (missing instance return and *args parameter)
- Fix handling of upaxis variable in ModelBuilder and the rendering thereof in OpenGLRenderer
warp.sparse improvements:
- Sparse matrix allocations (from bsr_from_triplets(), bsr_axpy(), etc.) can now be captured in CUDA graphs; exact number of non-zeros can be optionally requested asynchronously.
- bsr_assign() now supports changing block shape (including CSR/BSR conversions)
- Add Python operator overloads for common sparse matrix operations, e.g A += 0.5 * B, y = x @ C
warp.fem new features and fixes:
- Support for variable number of nodes per element
- Global wp.fem.lookup() operator now supports wp.fem.Tetmesh and wp.fem.Trimesh2D geometries
- Simplified defining custom subdomains (wp.fem.Subdomain), free-slip boundary conditions
- New field types: wp.fem.UniformField, wp.fem.ImplicitField and wp.fem.NonconformingField
- New streamlines, magnetostatics and nonconforming_contact examples, updated mixed_elasticity to use a nonlinear model
- Function spaces can now export VTK-compatible cells for visualization
- Fixed edge cases with NanoVDB function spaces
- Fixed differentiability of wp.fem.PicQuadrature w.r.t. positions and measures

Open source →

1.3.230 Aug 20243 sources agree

Fix accuracy of 3x3 SVD wp.svd3 with fp64 numbers (GH-281).

[1.3.2] - 2024-08-30

Bug fixes
- Fix accuracy of 3x3 SVD wp.svd3 with fp64 numbers (GH-281).
- Fix module hashing when a kernel argument contained a struct array (GH-287).
- Fix a bug in wp.bvh_query_ray() where the direction instead of the reciprocal direction was used (GH-288).
- Fix errors when launching a CUDA graph after a module is reloaded. Modules that were used during graph capture will no longer be unloaded before the graph is released.
- Fix a bug in wp.sim.collide.triangle_closest_point_barycentric() where the returned barycentric coordinates may be incorrect when the closest point lies on an edge.
- Fix 32-bit overflow when array shape is specified using np.int32.
- Fix handling of integer indices in the input_output_mask argument to autograd.jacobian and autograd.jacobian_fd (GH-289).
- Fix ModelBuilder.collapse_fixed_joints() to correctly update the body centers of mass and the ModelBuilder.articulation_start array.
- Fix precedence of closure constants over global constants.
- Fix quadrature point indexing in wp.fem.ExplicitQuadrature (regression from 1.3.0).
Documentation improvements
- Add missing return types for built-in functions.
- Clarify that atomic operations also return the previous value.
- Clarify that wp.bvh_query_aabb() returns parts that overlap the bounding volume.

[1.3.1] - 2024-07-27

Remove wp.synchronize() from PyTorch autograd function example
Tape.check_kernel_array_access() and Tape.reset_array_read_flags() are now private methods.
Fix reporting unmatched argument types

[1.3.0] - 2024-07-25

Warp Core improvements
- Update to CUDA 12.x by default (requires NVIDIA driver 525 or newer), please see README.md for commands to install CUDA 11.x binaries for older drivers
- Add information to the module load print outs to indicate whether a module was compiled (compiled), loaded from the cache (cached), or was unable to be loaded (error).
- wp.config.verbose = True now also prints out a message upon the entry to a wp.ScopedTimer.
- Add wp.clear_kernel_cache() to the public API. This is equivalent to wp.build.clear_kernel_cache().
- Add code-completion support for wp.config variables.
- Remove usage of a static task (thread) index for CPU kernels to address multithreading concerns (GH-224)
- Improve error messages for unsupported Python operations such as sequence construction in kernels
- Update wp.matmul() CPU fallback to use dtype explicitly in np.matmul() call
- Add support for PEP 563's from __future__ import annotations (GH-256).
- Allow passing external arrays/tensors to wp.launch() directly via __cuda_array_interface__ and __array_interface__, up to 2.5x faster conversion from PyTorch
- Add faster Torch interop path using return_ctype argument to wp.from_torch()
- Handle incompatible CUDA driver versions gracefully
- Add wp.abs() and wp.sign() for vector types
- Expose scalar arithmetic operators to Python's runtime (e.g.: wp.float16(1.23) * wp.float16(2.34))
- Add support for creating volumes with anisotropic transforms
- Allow users to pass function arguments by keyword in a kernel using standard Python calling semantics
- Add additional documentation and examples demonstrating wp.copy(), wp.clone(), and array.assign() differentiability
- Add __new__() methods for all class __del__() methods to handle when a class instance is created but not instantiated before garbage collection
- Implement the assignment operator for wp.quat
- Make the geometry-related built-ins available only from within kernels
- Rename the API-facing query types to remove their _t suffix: wp.BVHQuery, wp.HashGridQuery, wp.MeshQueryAABB, wp.MeshQueryPoint, and wp.MeshQueryRay
- Add wp.array(ptr=...) to allow initializing arrays from pointer addresses inside of kernels (GH-206)

Open source →

1.3.128 Jul 20243 sources agree

Remove wp.synchronize() from PyTorch autograd function example

[1.3.1] - 2024-07-27

Remove wp.synchronize() from PyTorch autograd function example
Tape.check_kernel_array_access() and Tape.reset_array_read_flags() are now private methods.
Fix reporting unmatched argument types

[1.3.0] - 2024-07-25

Warp Core improvements
- Update to CUDA 12.x by default (requires NVIDIA driver 525 or newer), please see README.md for commands to install CUDA 11.x binaries for older drivers
- Add information to the module load print outs to indicate whether a module was compiled (compiled), loaded from the cache (cached), or was unable to be loaded (error).
- wp.config.verbose = True now also prints out a message upon the entry to a wp.ScopedTimer.
- Add wp.clear_kernel_cache() to the public API. This is equivalent to wp.build.clear_kernel_cache().
- Add code-completion support for wp.config variables.
- Remove usage of a static task (thread) index for CPU kernels to address multithreading concerns (GH-224)
- Improve error messages for unsupported Python operations such as sequence construction in kernels
- Update wp.matmul() CPU fallback to use dtype explicitly in np.matmul() call
- Add support for PEP 563's from __future__ import annotations (GH-256).
- Allow passing external arrays/tensors to wp.launch() directly via __cuda_array_interface__ and __array_interface__, up to 2.5x faster conversion from PyTorch
- Add faster Torch interop path using return_ctype argument to wp.from_torch()
- Handle incompatible CUDA driver versions gracefully
- Add wp.abs() and wp.sign() for vector types
- Expose scalar arithmetic operators to Python's runtime (e.g.: wp.float16(1.23) * wp.float16(2.34))
- Add support for creating volumes with anisotropic transforms
- Allow users to pass function arguments by keyword in a kernel using standard Python calling semantics
- Add additional documentation and examples demonstrating wp.copy(), wp.clone(), and array.assign() differentiability
- Add __new__() methods for all class __del__() methods to handle when a class instance is created but not instantiated before garbage collection
- Implement the assignment operator for wp.quat
- Make the geometry-related built-ins available only from within kernels
- Rename the API-facing query types to remove their _t suffix: wp.BVHQuery, wp.HashGridQuery, wp.MeshQueryAABB, wp.MeshQueryPoint, and wp.MeshQueryRay
- Add wp.array(ptr=...) to allow initializing arrays from pointer addresses inside of kernels (GH-206)
warp.autograd improvements:
- New warp.autograd module with utility functions gradcheck(), jacobian(), and jacobian_fd() for debugging kernel Jacobians (docs)
- Add array overwrite detection, if wp.config.verify_autograd_array_access is true in-place operations on arrays on the Tape that could break gradient computation will be detected (docs)
- Fix bug where modification of @wp.func_replay functions and native snippets would not trigger module recompilation
- Add documentation for dynamic loop autograd limitations
warp.sim improvements:
- Improve memory usage and performance for rigid body contact handling when self.rigid_mesh_contact_max is zero (default behavior).
- The mask argument to wp.sim.eval_fk() now accepts both integer and boolean arrays to mask articulations.
- Fix handling of ModelBuilder.joint_act in ModelBuilder.collapse_fixed_joints() (affected floating-base systems)
- Fix and improve implementation of ModelBuilder.plot_articulation() to visualize the articulation tree of a rigid-body mechanism
- Fix ShapeInstancer __new__() method (missing instance return and *args parameter)
- Fix handling of upaxis variable in ModelBuilder and the rendering thereof in OpenGLRenderer
warp.sparse improvements:
- Sparse matrix allocations (from bsr_from_triplets(), bsr_axpy(), etc.) can now be captured in CUDA graphs; exact number of non-zeros can be optionally requested asynchronously.
- bsr_assign() now supports changing block shape (including CSR/BSR conversions)
- Add Python operator overloads for common sparse matrix operations, e.g A += 0.5 * B, y = x @ C
warp.fem new features and fixes:
- Support for variable number of nodes per element
- Global wp.fem.lookup() operator now supports wp.fem.Tetmesh and wp.fem.Trimesh2D geometries
- Simplified defining custom subdomains (wp.fem.Subdomain), free-slip boundary conditions
- New field types: wp.fem.UniformField, wp.fem.ImplicitField and wp.fem.NonconformingField
- New streamlines, magnetostatics and nonconforming_contact examples, updated mixed_elasticity to use a nonlinear model
- Function spaces can now export VTK-compatible cells for visualization
- Fixed edge cases with NanoVDB function spaces
- Fixed differentiability of wp.fem.PicQuadrature w.r.t. positions and measures

Open source →

1.3.026 Jul 20243 sources agree

Update to CUDA 12.x by default (requires NVIDIA driver 525 or newer), please see README.md for commands to install CUDA 11.x binaries for older driver

[1.3.0] - 2024-07-25

Warp Core improvements
- Update to CUDA 12.x by default (requires NVIDIA driver 525 or newer), please see README.md for commands to install CUDA 11.x binaries for older drivers
- Add information to the module load print outs to indicate whether a module was compiled (compiled), loaded from the cache (cached), or was unable to be loaded (error).
- wp.config.verbose = True now also prints out a message upon the entry to a wp.ScopedTimer.
- Add wp.clear_kernel_cache() to the public API. This is equivalent to wp.build.clear_kernel_cache().
- Add code-completion support for wp.config variables.
- Remove usage of a static task (thread) index for CPU kernels to address multithreading concerns (GH-224)
- Improve error messages for unsupported Python operations such as sequence construction in kernels
- Update wp.matmul() CPU fallback to use dtype explicitly in np.matmul() call
- Add support for PEP 563's from __future__ import annotations (GH-256).
- Allow passing external arrays/tensors to wp.launch() directly via __cuda_array_interface__ and __array_interface__, up to 2.5x faster conversion from PyTorch
- Add faster Torch interop path using return_ctype argument to wp.from_torch()
- Handle incompatible CUDA driver versions gracefully
- Add wp.abs() and wp.sign() for vector types
- Expose scalar arithmetic operators to Python's runtime (e.g.: wp.float16(1.23) * wp.float16(2.34))
- Add support for creating volumes with anisotropic transforms
- Allow users to pass function arguments by keyword in a kernel using standard Python calling semantics
- Add additional documentation and examples demonstrating wp.copy(), wp.clone(), and array.assign() differentiability
- Add __new__() methods for all class __del__() methods to handle when a class instance is created but not instantiated before garbage collection
- Implement the assignment operator for wp.quat
- Make the geometry-related built-ins available only from within kernels
- Rename the API-facing query types to remove their _t suffix: wp.BVHQuery, wp.HashGridQuery, wp.MeshQueryAABB, wp.MeshQueryPoint, and wp.MeshQueryRay
- Add wp.array(ptr=...) to allow initializing arrays from pointer addresses inside of kernels (GH-206)
warp.autograd improvements:
- New warp.autograd module with utility functions gradcheck(), jacobian(), and jacobian_fd() for debugging kernel Jacobians (docs)
- Add array overwrite detection, if wp.config.verify_autograd_array_access is true in-place operations on arrays on the Tape that could break gradient computation will be detected (docs)
- Fix bug where modification of @wp.func_replay functions and native snippets would not trigger module recompilation
- Add documentation for dynamic loop autograd limitations
warp.sim improvements:
- Improve memory usage and performance for rigid body contact handling when self.rigid_mesh_contact_max is zero (default behavior).
- The mask argument to wp.sim.eval_fk() now accepts both integer and boolean arrays to mask articulations.
- Fix handling of ModelBuilder.joint_act in ModelBuilder.collapse_fixed_joints() (affected floating-base systems)
- Fix and improve implementation of ModelBuilder.plot_articulation() to visualize the articulation tree of a rigid-body mechanism
- Fix ShapeInstancer __new__() method (missing instance return and *args parameter)
- Fix handling of upaxis variable in ModelBuilder and the rendering thereof in OpenGLRenderer
warp.sparse improvements:
- Sparse matrix allocations (from bsr_from_triplets(), bsr_axpy(), etc.) can now be captured in CUDA graphs; exact number of non-zeros can be optionally requested asynchronously.
- bsr_assign() now supports changing block shape (including CSR/BSR conversions)
- Add Python operator overloads for common sparse matrix operations, e.g A += 0.5 * B, y = x @ C
warp.fem new features and fixes:
- Support for variable number of nodes per element
- Global wp.fem.lookup() operator now supports wp.fem.Tetmesh and wp.fem.Trimesh2D geometries
- Simplified defining custom subdomains (wp.fem.Subdomain), free-slip boundary conditions
- New field types: wp.fem.UniformField, wp.fem.ImplicitField and wp.fem.NonconformingField
- New streamlines, magnetostatics and nonconforming_contact examples, updated mixed_elasticity to use a nonlinear model
- Function spaces can now export VTK-compatible cells for visualization
- Fixed edge cases with NanoVDB function spaces
- Fixed differentiability of wp.fem.PicQuadrature w.r.t. positions and measures

Open source →

1.2.24 Jul 2024

Fix Warp not being initialized when constructing arrays with wp.array()

[1.2.2] - 2024-07-04

Support for NumPy >= 2.0

[1.2.1] - 2024-06-14

Fix generic function caching
Fix Warp not being initialized when constructing arrays with wp.array()
Fix wp.is_mempool_access_supported() not resolving the provided device arguments to wp.context.Device

[1.2.0] - 2024-06-06

Add a not-a-number floating-point constant that can be used as wp.NAN or wp.nan.
Add wp.isnan(), wp.isinf(), and wp.isfinite() for scalars, vectors, matrices, etc.
Improve kernel cache reuse by hashing just the local module constants. Previously, a module's hash was affected by all wp.constant() variables declared in a Warp program.
Revised module compilation process to allow multiple processes to use the same kernel cache directory. Cached kernels will now be stored in hash-specific subdirectory.
Add runtime checks for wp.MarchingCubes on field dimensions and size
Fix memory leak in wp.Mesh BVH (GH-225)
Use C++17 when building the Warp library and user kernels
Increase PTX target architecture up to sm_75 (from sm_70), enabling Turing ISA features
Extended NanoVDB support (see warp.Volume):
- Add support for data-agnostic index grids, allocation at voxel granularity
- New wp.volume_lookup_index(), wp.volume_sample_index() and generic wp.volume_sample()/wp.volume_lookup()/wp.volume_store() kernel-level functions
- Zero-copy aliasing of in-memory grids, support for multi-grid buffers
- Grid introspection and blind data access capabilities
- warp.fem can now work directly on NanoVDB grids using warp.fem.Nanogrid
- Fixed wp.volume_sample_v() and wp.volume_store_*() adjoints
- Prevent wp.volume_store() from overwriting grid background values
Improve validation of user-provided fields and values in warp.fem
Support headless rendering of wp.render.OpenGLRenderer via pyglet.options["headless"] = True
wp.render.RegisteredGLBuffer can fall back to CPU-bound copying if CUDA/OpenGL interop is not available
Clarify terms for external contributions, please see CONTRIBUTING.md for details
Improve performance of wp.sparse.bsr_mm() by ~5x on benchmark problems
Fix for XPBD incorrectly indexing into of joint actuations joint_act arrays
Fix for mass matrix gradients computation in wp.sim.FeatherstoneIntegrator()
Fix for handling of --msvc_path in build scripts
Fix for wp.copy() params to record dest and src offset parameters on wp.Tape()
Fix for wp.randn() to ensure return values are finite
Fix for slicing of arrays with gradients in kernels
Fix for function overload caching, ensure module is rebuilt if any function overloads are modified
Fix for handling of bool types in generic kernels
Publish CUDA 12.5 binaries for Hopper support, see https://github.com/nvidia/warp?tab=readme-ov-file#installing for details

Open source →

Additional notes2 sources agree

Fix hashing of replay functions and snippets
Add additional documentation and examples demonstrating wp.copy(), wp.clone(), and array.assign() differentiability
Add __new__() methods for all class __del__() methods to handle when a class instance is created but not instantiated before garbage collection.
Add documentation for dynamic loop autograd limitations
Allow users to pass function arguments by keyword in a kernel using standard Python calling semantics
Implement the assignment operator for wp.quat
Support for NumPy >= 2.0

Open source →

1.2.114 Jun 20243 sources agree

Fix Warp not being initialized when constructing arrays with wp.array()

[1.2.1] - 2024-06-14

Fix generic function caching
Fix Warp not being initialized when constructing arrays with wp.array()
Fix wp.is_mempool_access_supported() not resolving the provided device arguments to wp.context.Device

[1.2.0] - 2024-06-06

Add a not-a-number floating-point constant that can be used as wp.NAN or wp.nan.
Add wp.isnan(), wp.isinf(), and wp.isfinite() for scalars, vectors, matrices, etc.
Improve kernel cache reuse by hashing just the local module constants. Previously, a module's hash was affected by all wp.constant() variables declared in a Warp program.
Revised module compilation process to allow multiple processes to use the same kernel cache directory. Cached kernels will now be stored in hash-specific subdirectory.
Add runtime checks for wp.MarchingCubes on field dimensions and size
Fix memory leak in wp.Mesh BVH (GH-225)
Use C++17 when building the Warp library and user kernels
Increase PTX target architecture up to sm_75 (from sm_70), enabling Turing ISA features
Extended NanoVDB support (see warp.Volume):
- Add support for data-agnostic index grids, allocation at voxel granularity
- New wp.volume_lookup_index(), wp.volume_sample_index() and generic wp.volume_sample()/wp.volume_lookup()/wp.volume_store() kernel-level functions
- Zero-copy aliasing of in-memory grids, support for multi-grid buffers
- Grid introspection and blind data access capabilities
- warp.fem can now work directly on NanoVDB grids using warp.fem.Nanogrid
- Fixed wp.volume_sample_v() and wp.volume_store_*() adjoints
- Prevent wp.volume_store() from overwriting grid background values
Improve validation of user-provided fields and values in warp.fem
Support headless rendering of wp.render.OpenGLRenderer via pyglet.options["headless"] = True
wp.render.RegisteredGLBuffer can fall back to CPU-bound copying if CUDA/OpenGL interop is not available
Clarify terms for external contributions, please see CONTRIBUTING.md for details
Improve performance of wp.sparse.bsr_mm() by ~5x on benchmark problems
Fix for XPBD incorrectly indexing into of joint actuations joint_act arrays
Fix for mass matrix gradients computation in wp.sim.FeatherstoneIntegrator()
Fix for handling of --msvc_path in build scripts
Fix for wp.copy() params to record dest and src offset parameters on wp.Tape()
Fix for wp.randn() to ensure return values are finite
Fix for slicing of arrays with gradients in kernels
Fix for function overload caching, ensure module is rebuilt if any function overloads are modified
Fix for handling of bool types in generic kernels
Publish CUDA 12.5 binaries for Hopper support, see https://github.com/nvidia/warp?tab=readme-ov-file#installing for details

Open source →

1.2.07 Jun 20243 sources agree

Add a not-a-number floating-point constant that can be used as wp.NAN or wp.nan.

[1.2.0] - 2024-06-06

Add a not-a-number floating-point constant that can be used as wp.NAN or wp.nan.
Add wp.isnan(), wp.isinf(), and wp.isfinite() for scalars, vectors, matrices, etc.
Improve kernel cache reuse by hashing just the local module constants. Previously, a module's hash was affected by all wp.constant() variables declared in a Warp program.
Revised module compilation process to allow multiple processes to use the same kernel cache directory. Cached kernels will now be stored in hash-specific subdirectory.
Add runtime checks for wp.MarchingCubes on field dimensions and size
Fix memory leak in wp.Mesh BVH (GH-225)
Use C++17 when building the Warp library and user kernels
Increase PTX target architecture up to sm_75 (from sm_70), enabling Turing ISA features
Extended NanoVDB support (see warp.Volume):
- Add support for data-agnostic index grids, allocation at voxel granularity
- New wp.volume_lookup_index(), wp.volume_sample_index() and generic wp.volume_sample()/wp.volume_lookup()/wp.volume_store() kernel-level functions
- Zero-copy aliasing of in-memory grids, support for multi-grid buffers
- Grid introspection and blind data access capabilities
- warp.fem can now work directly on NanoVDB grids using warp.fem.Nanogrid
- Fixed wp.volume_sample_v() and wp.volume_store_*() adjoints
- Prevent wp.volume_store() from overwriting grid background values
Improve validation of user-provided fields and values in warp.fem
Support headless rendering of wp.render.OpenGLRenderer via pyglet.options["headless"] = True
wp.render.RegisteredGLBuffer can fall back to CPU-bound copying if CUDA/OpenGL interop is not available
Clarify terms for external contributions, please see CONTRIBUTING.md for details
Improve performance of wp.sparse.bsr_mm() by ~5x on benchmark problems
Fix for XPBD incorrectly indexing into of joint actuations joint_act arrays
Fix for mass matrix gradients computation in wp.sim.FeatherstoneIntegrator()
Fix for handling of --msvc_path in build scripts
Fix for wp.copy() params to record dest and src offset parameters on wp.Tape()
Fix for wp.randn() to ensure return values are finite
Fix for slicing of arrays with gradients in kernels
Fix for function overload caching, ensure module is rebuilt if any function overloads are modified
Fix for handling of bool types in generic kernels
Publish CUDA 12.5 binaries for Hopper support, see https://github.com/nvidia/warp?tab=readme-ov-file#installing for details

[1.1.1] - 2024-05-24

wp.init() is no longer required to be called explicitly and will be performed on first call to the API
Speed up omni.warp.core's startup time

Open source →

1.1.08 May 20243 sources agree

Support returning a value from @wp.func_native CUDA functions using type hints

[1.1.0] - 2024-05-09

Support returning a value from @wp.func_native CUDA functions using type hints
Improved differentiability of the wp.sim.FeatherstoneIntegrator
Fix gradient propagation for rigid body contacts in wp.sim.collide()
Added support for event-based timing, see wp.ScopedTimer()
Added Tape visualization and debugging functions, see wp.Tape.visualize()
Support constructing Warp arrays from objects that define the __cuda_array_interface__ attribute
Support copying a struct to another device, use struct.to(device) to migrate struct arrays
Allow rigid shapes to not have any collisions with other shapes in wp.sim.Model
Change default test behavior to test redundant GPUs (up to 2x)
Test each example in an individual subprocess
Polish and optimize various examples and tests
Allow non-contiguous point arrays to be passed to wp.HashGrid.build()
Upgrade LLVM to 18.1.3 for from-source builds and Linux x86-64 builds
Build DLL source code as C++17 and require GCC 9.4 as a minimum
Array clone, assign, and copy are now differentiable
Use Ruff for formatting and linting
Various documentation improvements (infinity, math constants, etc.)
Improve URDF importer, handle joint armature
Allow builtins.bool to be used in Warp data structures
Use external gradient arrays in backward passes when passed to wp.launch()
Add Conjugate Residual linear solver, see wp.optim.linear.cr()
Fix propagation of gradients on aliased copy of variables in kernels
Facilitate debugging and speed up import warp by eliminating raising any exceptions
Improve support for nested vec/mat assignments in structs
Recommend Python 3.9 or higher, which is required for JAX and soon PyTorch.
Support gradient propagation for indexing sliced multi-dimensional arrays, i.e. a[i][j] vs. a[i, j]
Provide an informative message if setting DLL C-types failed, instructing to try rebuilding the library

[1.0.3] - 2024-04-17

Add a support_level entry to the configuration file of the extensions

Open source →

0.15.05 Mar 2024Deprecated3 sources agree

Deprecation of owner argument - use deleter to transfer ownership

[0.15.0] - 2024-03-04

Add thumbnails to examples gallery
Apply colored lighting to examples
Moved examples directory under warp/
Add example usage to python -m warp.tests --help
Adding torch.autograd.function example + docs
Add error-checking to array shapes during creation
Adding example_graph_capture
Add a Diffsim Example of a Drone
Fix verify_fp causing compiler errors and support CPU kernels
Fix to enable matmul to be called in CUDA graph capture
Enable mempools by default
Update wp.launch to support tuple args
Fix BiCGSTAB and GMRES producing NaNs when converging early
Fix warning about backward codegen being disabled in test_fem
Fix assert_np_equal when NaN's and tolerance are involved
Improve error message to discern between CUDA being disabled or not supported
Support cross-module functions with user-defined gradients
Suppress superfluous CUDA error when ending capture after errors
Make output during initialization atomic
Add warp.config.max_unroll, fix custom gradient unrolling
Support native replay snippets using @wp.func_native(snippet, replay_snippet=replay_snippet)
Look for the CUDA Toolkit in default locations if the CUDA_PATH environment variable or --cuda_path build option are not used
Added wp.ones() to efficiently create one-initialized arrays
Rename wp.config.graph_capture_module_load_default to wp.config.enable_graph_capture_module_load_by_default

[0.14.0] - 2024-02-19

Add support for CUDA pooled (stream-ordered) allocators
- Support memory allocation during graph capture
- Support copying non-contiguous CUDA arrays during graph capture
- Improved memory allocation/deallocation performance with pooled allocators
- Use wp.config.enable_mempools_at_init to enable pooled allocators during Warp initialization (if supported)
- wp.is_mempool_supported() - check if a device supports pooled allocators
- wp.is_mempool_enabled(), wp.set_mempool_enabled() - enable or disable pooled allocators per device
- wp.set_mempool_release_threshold(), wp.get_mempool_release_threshold() - configure memory pool release threshold
Add support for direct memory access between devices
- Improved peer-to-peer memory transfer performance if access is enabled
- Caveat: enabling peer access may impact memory allocation/deallocation performance and increase memory consumption
- wp.is_peer_access_supported() - check if the memory of a device can be accessed by a peer device
- wp.is_peer_access_enabled(), wp.set_peer_access_enabled() - manage peer access for memory allocated using default CUDA allocators
- wp.is_mempool_access_supported() - check if the memory pool of a device can be accessed by a peer device
- wp.is_mempool_access_enabled(), wp.set_mempool_access_enabled() - manage access for memory allocated using pooled CUDA allocators
Refined stream synchronization semantics
- wp.ScopedStream can synchronize with the previous stream on entry and/or exit (only sync on entry by default)
- Functions taking an optional stream argument do no implicit synchronization for max performance (e.g., wp.copy(), wp.launch(), wp.capture_launch())
Support for passing a custom deleter argument when constructing arrays
- Deprecation of owner argument - use deleter to transfer ownership
Optimizations for various core API functions (e.g., wp.zeros(), wp.full(), and more)
Fix wp.matmul() to always use the correct CUDA context
Fix memory leak in BSR transpose
Fix stream synchronization issues when copying non-contiguous arrays

[0.13.1] - 2024-02-22

Ensure that the results from the Noise Deform are deterministic across different Kit sessions

Open source →

0.11.023 Jan 2024Deprecated3 sources agree

Show deprecation warnings only once

[0.11.0] - 2024-01-23

Re-release 1.0.0-beta.7 as a non-pre-release 0.11.0 version so it gets selected by pip install warp-lang.
Introducing a new versioning and release process, detailed in PACKAGING.md and resembling that of Python itself:
- The 0.11 release(s) can be found on the release-0.11 branch.
- Point releases (if any) go on the same minor release branch and only contain bug fixes, not new features.
- The public branch, previously used to merge releases into and corresponding with the GitHub main branch, is retired.

[1.0.0-beta.7] - 2024-01-23

Ensure captures are always enclosed in try/finally
Only include .py files from the warp subdirectory into wheel packages
Fix an extension's sample node failing at parsing some version numbers
Allow examples to run without USD when possible
Add a setting to disable the main Warp menu in Kit
Add iterative linear solvers, see wp.optim.linear.cg, wp.optim.linear.bicgstab, wp.optim.linear.gmres, and wp.optim.linear.LinearOperator
Improve error messages around global variables
Improve error messages around mat/vec assignments
Support conversion of scalars to native/ctypes, e.g.: float(wp.float32(1.23)) or ctypes.c_float(wp.float32(1.23))
Add a constant for infinity, see wp.inf
Add a FAQ entry about array assignments
Add a mass spring cage diff simulation example, see examples/example_diffsim_mass_spring_cage.py
Add -s, --suite option for only running tests belonging to the given suites
Fix common spelling mistakes
Fix indentation of generated code
Show deprecation warnings only once
Improve wp.render.OpenGLRenderer
Create the extension's symlink to the core library at runtime
Fix some built-ins failing to compile the backward pass when nested inside if/else blocks
Update examples with the new variants of the mesh query built-ins
Fix type members that weren't zero-initialized
Fix missing adjoint function for wp.mesh_query_ray()

Open source →

0.10.126 Jul 2023Deprecated

Remove deprecated wp.ScopedCudaGuard(), please use wp.ScopedDevice() instead

[0.10.1] - 2023-07-25

Fix for large multidimensional kernel launches (> 2^32 threads)
Fix for module hashing with generics
Fix for unrolling loops with break or continue statements (will skip unrolling)
Fix for passing boolean arguments to build_lib.py (previously ignored)
Fix build warnings on Linux
Fix for creating array of structs from NumPy structured array
Fix for regression on kernel load times in Kit when using warp.sim
Update warp.array.reshape() to handle -1 dimensions
Update margin used by for mesh queries when using wp.sim.create_soft_body_contacts()
Improvements to gradient handling with warp.from_torch(), warp.to_torch() plus documentation

[0.10.0] - 2023-07-05

Add support for macOS universal binaries (x86 + aarch64) for M1+ support
Add additional methods for SDF generation please see the following new methods:
- wp.mesh_query_point_nosign() - closest point query with no sign determination
- wp.mesh_query_point_sign_normal() - closest point query with sign from angle-weighted normal
- wp.mesh_query_point_sign_winding_number() - closest point query with fast winding number sign determination
Add CSR/BSR sparse matrix support, see warp.sparse module:
- wp.sparse.BsrMatrix
- wp.sparse.bsr_zeros(), wp.sparse.bsr_set_from_triplets() for construction
- wp.sparse.bsr_mm(), wp.sparse_bsr_mv() for matrix-matrix and matrix-vector products respectively
Add array-wide utilities:
- wp.utils.array_scan() - prefix sum (inclusive or exlusive)
- wp.utils.array_sum() - sum across array
- wp.utils.radix_sort_pairs() - in-place radix sort (key,value) pairs
Add support for calling @wp.func functions from Python (outside of kernel scope)
Add support for recording kernel launches using a wp.Launch object that can be replayed with low overhead, use wp.launch(..., record_cmd=True) to generate a command object
Optimizations for wp.struct kernel arguments, up to 20x faster launches for kernels with large structs or number of params
Refresh USD samples to use bundle based workflow + change tracking
Add Python API for manipulating mesh and point bundle data in OmniGraph, see omni.warp.nodes module
- See omni.warp.nodes.mesh_create_bundle(), omni.warp.nodes.mesh_get_points(), etc.
Improvements to wp.array:
- Fix a number of array methods misbehaving with empty arrays
- Fix a number of bugs and memory leaks related to gradient arrays
- Fix array construction when creating arrays in pinned memory from a data source in pageable memory
- wp.empty() no longer zeroes-out memory and returns an uninitialized array, as intended
- array.zero_() and array.fill_() work with non-contiguous arrays
- Support wrapping non-contiguous NumPy arrays without a copy
- Support preserving the outer dimensions of NumPy arrays when wrapping them as Warp arrays of vector or matrix types
- Improve PyTorch and DLPack interop with Warp arrays of arbitrary vectors and matrices
- array.fill_() can now take lists or other sequences when filling arrays of vectors or matrices, e.g. arr.fill_([[1, 2], [3, 4]])
- array.fill_() now works with arrays of structs (pass a struct instance)
- wp.copy() gracefully handles copying between non-contiguous arrays on different devices
- Add wp.full() and wp.full_like(), e.g., a = wp.full(shape, value)
- Add optional device argument to wp.empty_like(), wp.zeros_like(), wp.full_like(), and wp.clone()
- Add indexedarray methods .zero_(), .fill_(), and .assign()
- Fix indexedarray methods .numpy() and .list()
- Fix array.list() to work with arrays of any Warp data type
- Fix array.list() synchronization issue with CUDA arrays
- array.numpy() called on an array of structs returns a structured NumPy array with named fields
- Improve the performance of creating arrays
Fix for Error: No module named 'omni.warp.core' when running some Kit configurations (e.g.: stubgen)
Fix for wp.struct instance address being included in module content hash
Fix codegen with overridden function names
Fix for kernel hashing so it occurs after code generation and before loading to fix a bug with stale kernel cache
Fix for wp.BVH.refit() when executed on the CPU
Fix adjoint of wp.struct constructor
Fix element accessors for wp.float16 vectors and matrices in Python
Fix wp.float16 members in structs
Remove deprecated wp.ScopedCudaGuard(), please use wp.ScopedDevice() instead

Open source →

Additional notes2 sources agree

Fix for large multidimensional kernel launches (> 2^32 threads)
Fix for module hashing with generics
Fix for unrolling loops with break or continue statements (will skip unrolling)
Fix for passing boolean arguments to build_lib.py (previously ignored)
Fix build warnings on Linux
Fix for creating array of structs from NumPy structured array
Fix for regression on kernel load times in Kit when using wp.sim
Update wp.array.reshape() to handle -1 dimensions
Update margin used by for mesh queries when using wp.sim.create_soft_body_contacts()
Improvements to gradient handling with wp.from_torch(), wp.to_torch() plus documentation

Open source →

0.9.02 Jun 2023Deprecated3 sources agree

Deprecate wp.Model.soft_contact_distance which is now replaced by wp.Model.particle_radius

[0.9.0] - 2023-06-01

Add support for in-place modifications to vector, matrix, and struct types inside kernels (will warn during backward pass with wp.verbose if using gradients)
Add support for step-through VSCode debugging of kernel code with standalone LLVM compiler, see wp.breakpoint(), and test_debug.py
Add support for default values on built-in functions
Add support for multi-valued @wp.func functions
Add support for pass, continue, and break statements
Add missing __sincos_stret symbol for macOS
Add support for gradient propagation through wp.Mesh.points, and other cases where arrays are passed to native functions
Add support for Python @ operator as an alias for wp.matmul()
Add XPBD support for particle-particle collision
Add support for individual particle radii: ModelBuilder.add_particle has a new radius argument, Model.particle_radius is now a Warp array
Add per-particle flags as a Model.particle_flags Warp array, introduce PARTICLE_FLAG_ACTIVE to define whether a particle is being simulated and participates in contact dynamics
Add support for Python bitwise operators &, |, ~, <<, >>
Switch to using standalone LLVM compiler by default for cpu devices
Split omni.warp into omni.warp.core for Omniverse applications that want to use the Warp Python module with minimal additional dependencies
Disable kernel gradient generation by default inside Omniverse for improved compile times
Fix for bounds checking on element access of vector/matrix types
Fix for stream initialization when a custom (non-primary) external CUDA context has been set on the calling thread
Fix for duplicate @wp.struct registration during hot reload
Fix for array unot() operator so kernel writers can use if not array: syntax
Fix for case where dynamic loops are nested within unrolled loops
Change wp.hash_grid_point_id() now returns -1 if the wp.HashGrid has not been reserved before
Deprecate wp.Model.soft_contact_distance which is now replaced by wp.Model.particle_radius
Deprecate single scalar particle radius (should be a per-particle array)

Open source →

0.8.011 Apr 20232 sources agree

Add Texture Write node for updating dynamic RTX textures from Warp kernels / nodes

Add Texture Write node for updating dynamic RTX textures from Warp kernels / nodes
Add multi-dimensional kernel support to Warp Kernel Node
Add wp.load_module() to pre-load specific modules (pass recursive=True to load recursively)
Add wp.poisson() for sampling Poisson distributions
Add support for UsdPhysics schema see wp.sim.parse_usd()
Add XPBD rigid body implementation plus diff. simulation examples
Add support for standalone CPU compilation (no host-compiler) with LLVM backed, enable with --standalone build option
Add support for per-timer color in wp.ScopedTimer()
Add support for row-based construction of matrix types outside of kernels
Add support for setting and getting row vectors for Python matrices, see matrix.get_row(), matrix.set_row()
Add support for instantiating wp.struct types within kernels
Add support for indexed arrays, slice = array[indices] will now generate a sparse slice of array data
Add support for generic kernel params, use def compute(param: Any):
Add support for with wp.ScopedDevice("cuda") as device: syntax (same for wp.ScopedStream(), wp.Tape())
Add support for creating custom length vector/matrices inside kernels, see wp.vector(), and wp.matrix()
Add support for creating identity matrices in kernels with, e.g.: I = wp.identity(n=3, dtype=float)
Add support for unary plus operator (wp.pos())
Add support for wp.constant variables to be used directly in Python without having to use .val member
Add support for nested wp.struct types
Add support for returning wp.struct from functions
Add --quick build for faster local dev. iteration (uses a reduced set of SASS arches)
Add optional requires_grad parameter to wp.from_torch() to override gradient allocation
Add type hints for generic vector / matrix types in Python stubs
Add support for custom user function recording in wp.Tape()
Add support for registering CUTLASS wp.matmul() with tape backward pass
Add support for grids with > 2^31 threads (each dimension may be up to INT_MAX in length)
Add CPU fallback for wp.matmul()
Optimizations for wp.launch(), up to 3x faster launches in common cases
Fix wp.randf() conversion to float to reduce bias for uniform sampling
Fix capture of wp.func and wp.constant types from inside Python closures
Fix for CUDA on WSL
Fix for matrices in structs
Fix for transpose indexing for some non-square matrices
Enable Python faulthandler by default
Update to VS2019

Breaking Changes

wp.constant variables can now be treated as their true type, accessing the underlying value through constant.val is no longer supported
wp.sim.model.ground_plane is now a wp.array to support gradient, users should call builder.set_ground_plane() to create the ground
wp.sim capsule, cones, and cylinders are now aligned with the default USD up-axis

Open source →

0.4.321 Sept 2022

Update all samples to use GPU interop path by default

[0.4.3] - 2022-09-20

Update all samples to use GPU interop path by default
Fix for arrays > 2GB in length
Add support for per-vertex USD mesh colors with warp.render class

[0.4.2] - 2022-09-07

Register Warp samples to the sample browser in Kit
Add NDEBUG flag to release mode kernel builds
Fix for particle solver node when using a large number of particles
Fix for broken cameras in Warp sample scenes

[0.4.1] - 2022-08-30

Add geometry sampling methods, see wp.sample_unit_cube(), wp.sample_unit_disk(), etc
Add wp.lower_bound() for searching sorted arrays
Add an option for disabling code-gen of backward pass to improve compilation times, see wp.set_module_options({"enable_backward": False}), True by default
Fix for using Warp from Script Editor or when module does not have a __file__ attribute
Fix for hot reload of modules containing wp.func() definitions
Fix for debug flags not being set correctly on CUDA when wp.config.mode == "debug", this enables bounds checking on CUDA kernels in debug mode
Fix for code gen of functions that do not return a value

[0.4.0] - 2022-08-09

Fix for FP16 conversions on GPUs without hardware support
Fix for runtime = None errors when reloading the Warp module
Fix for PTX architecture version when running with older drivers, see wp.config.ptx_target_arch
Fix for USD imports from __init__.py, defer them to individual functions that need them
Fix for robustness issues with sign determination for wp.mesh_query_point()
Fix for wp.HashGrid memory leak when creating/destroying grids
Add CUDA version checks for toolkit and driver
Add support for cross-module @wp.struct references
Support running even if CUDA initialization failed, use wp.is_cuda_available() to check availability
Statically linking with the CUDA runtime library to avoid deployment issues

Open source →

Additional notes2 sources agree

Update all samples to use GPU interop path by default
Fix for arrays > 2GB in length
Add support for per-vertex USD mesh colors with wp.render class

Open source →

0.3.112 Jul 2022

Fix for marching cubes reallocation after initialization

[0.3.1] - 2022-07-12

Fix for marching cubes reallocation after initialization
Add support for closest point between line segment tests, see wp.closest_point_edge_edge() builtin
Add support for per-triangle elasticity coefficients in simulation, see wp.sim.ModelBuilder.add_cloth_mesh()

[0.3.0] - 2022-07-08

Add support for FP16 storage type, see wp.float16
Add support for per-dimension byte strides, see wp.array.strides
Add support for passing Python classes as kernel arguments, see @wp.struct decorator
Add additional bounds checks for builtin matrix types
Add additional floating point checks, see wp.config.verify_fp
Add interleaved user source with generated code to aid debugging
Add generalized GPU marching cubes implementation, see wp.MarchingCubes class
Add additional scalar*matrix vector operators
Add support for retrieving a single row from builtin types, e.g.: r = m33[i]
Add wp.log2() and wp.log10() builtins
Add support for quickly instancing wp.sim.ModelBuilder objects to improve env. creation performance for RL
Remove custom CUB version and improve compatability with CUDA 11.7
Fix to preserve external user-gradients when calling wp.Tape.zero()
Fix to only allocate gradient of a Torch tensor if requires_grad=True
Fix for missing wp.mat22 constructor adjoint
Fix for ray-cast precision in edge case on GPU (watertightness issue)
Fix for kernel hot-reload when definition changes
Fix for NVCC warnings on Linux
Fix for generated function names when kernels are defined as class functions
Fix for reload of generated CPU kernel code on Linux
Fix for example scripts to output USD at 60 timecodes per-second (better Kit compatibility)

Open source →

Additional notes2 sources agree

Fix for marching cubes reallocation after initialization
Add support for closest point between line segment tests, see wp.closest_point_edge_edge() builtin
Add support for per-triangle elasticity coefficients in simulation, see wp.sim.ModelBuilder.add_cloth_mesh()
Add support for specifying default device, see wp.set_device(), wp.get_device(), wp.ScopedDevice
Add support for multiple GPUs (e.g., "cuda:0", "cuda:1"), see wp.get_cuda_devices(), wp.get_cuda_device_count(), wp.get_cuda_device()
Add support for explicitly targeting the current CUDA context using device alias "cuda"
Add support for using arbitrary external CUDA contexts, see wp.map_cuda_device(), wp.unmap_cuda_device()
Add PyTorch device aliasing functions, see wp.device_from_torch(), wp.device_to_torch()

Breaking Changes

A CUDA device is used by default, if available (aligned with wp.get_preferred_device())
wp.ScopedCudaGuard is deprecated, use wp.ScopedDevice instead
wp.synchronize() now synchronizes all devices; for finer-grained control, use wp.synchronize_device()
Device alias "cuda" now refers to the current CUDA context, rather than a specific device like "cuda:0" or "cuda:1"

Open source →

0.2.316 Jun 2022Deprecated3 sources agree

NumPy implementations of many builtin methods have been moved to warp.utils and will be deprecated

[0.2.3] - 2022-06-13

Fix for incorrect 4d array bounds checking
Fix for wp.constant changes not updating module hash
Fix for stale CUDA kernel cache when CPU kernels launched first
Array gradients are now allocated along with the arrays and accessible as wp.array.grad, users should take care to always call wp.Tape.zero() to clear gradients between different invocations of wp.Tape.backward()
Added wp.array.fill_() to set all entries to a scalar value (4-byte values only currently)

Breaking Changes

Tape capture option has been removed, users can now capture tapes inside existing CUDA graphs (e.g.: inside Torch)
Scalar loss arrays should now explicitly set requires_grad=True at creation time

[0.2.2] - 2022-05-30

Fix for from import * inside Warp initialization
Fix for body space velocity when using deforming Mesh objects with scale
Fix for noise gradient discontinuities affecting wp.curlnoise()
Fix for wp.from_torch() to correctly preserve shape
Fix for URDF parser incorrectly passing density to scale parameter
Optimizations for startup time from 3s -> 0.3s
Add support for custom kernel cache location, Warp will now store generated binaries in the user's application directory
Add support for cross-module function references, e.g.: call another modules @wp.func functions
Add support for overloading @wp.func functions based on argument type
Add support for calling built-in functions directly from Python interpreter outside kernels (experimental)
Add support for auto-complete and docstring lookup for builtins in IDEs like VSCode, PyCharm, etc
Add support for doing partial array copys, see wp.copy() for details
Add support for accessing mesh data directly in kernels, see wp.mesh_get_point(), wp.mesh_get_index(), wp.mesh_eval_face_normal()
Change to only compile for targets where kernel is launched (e.g.: will not compile CPU unless explicitly requested)

Breaking Changes

Builtin methods such as wp.quat_identity() now call the Warp native implementation directly and will return a wp.quat object instead of NumPy array
NumPy implementations of many builtin methods have been moved to warp.utils and will be deprecated
Local @wp.func functions should not be namespaced when called, e.g.: previously wp.myfunc() would work even if myfunc() was not a builtin
Removed wp.rpy2quat(), please use wp.quat_rpy() instead

[0.2.1] - 2022-05-11

Fix for unit tests in Kit

Open source →

0.2.06 May 20223 sources agree

Fix for unrolling loops with negative bounds

Warp Core

Fix for unrolling loops with negative bounds
Fix for unresolved symbol hash_grid_build_device() not found when lib is compiled without CUDA support
Fix for failure to load nvrtc-builtins64_113.dll when user has a newer CUDA toolkit installed on their machine
Fix for conversion of Torch tensors to wp.arrays() with a vector dtype (incorrect row count)
Fix for warp.dll not found on some Windows installations
Fix for macOS builds on Clang 13.x
Fix for step-through debugging of kernels on Linux
Add argument type checking for user defined @wp.func functions
Add support for custom iterable types, supports ranges, hash grid, and mesh query objects
Add support for multi-dimensional arrays, for example use x = array[i,j,k] syntax to address a 3-dimensional array
Add support for multi-dimensional kernel launches, use launch(kernel, dim=(i,j,k), ... and i,j,k = wp.tid() to obtain thread indices
Add support for bounds-checking array memory accesses in debug mode, use wp.config.mode = "debug" to enable
Add support for differentiating through dynamic and nested for-loops
Add support for evaluating MLP neural network layers inside kernels with custom activation functions, see wp.mlp()
Add additional NVDB sampling methods and adjoints, see wp.volume_sample_i(), wp.volume_sample_f(), and wp.volume_sample_vec()
Add support for loading zlib compressed NVDB volumes, see wp.Volume.load_from_nvdb()
Add support for triangle intersection testing, see wp.intersect_tri_tri()
Add support for NVTX profile zones in wp.ScopedTimer()
Add support for additional transform and quaternion math operations, see wp.inverse(), wp.quat_to_matrix(), wp.quat_from_matrix()
Add fast math (--fast-math) to kernel compilation by default
Add warp.torch import by default (if PyTorch is installed)

Warp Kit

Add Kit menu for browsing Warp documentation and example scenes under 'Window->Warp'
Fix for OgnParticleSolver.py example when collider is coming from Read Prim into Bundle node

Warp Sim

Fix for joint attachment forces
Fix for URDF importer and floating base support
Add examples showing how to use differentiable forward kinematics to solve inverse kinematics
Add examples for URDF cartpole and quadruped simulation

Breaking Changes

wp.volume_sample_world() is now replaced by wp.volume_sample_f/i/vec() which operate in index (local) space. Users should use wp.volume_world_to_index() to transform points from world space to index space before sampling.
wp.mlp() expects multi-dimensional arrays instead of one-dimensional arrays for inference, all other semantics remain the same as earlier versions of this API.
wp.array.length member has been removed, please use wp.array.shape to access array dimensions, or use wp.array.size to get total element count
Marking dense_gemm(), dense_chol(), etc methods as experimental until we revisit them

Open source →

warp-lang

Release timeline

Releases

Warp v1.11.0

New features

Group-aware spatial queries

Key features

Geometry query enhancements

Evaluate the gradients of functions

wp.tile_map() supports n-ary maps (up to n=8)

Generate tiles of random numbers

Alpha and Beta scalings in wp.tile_matmul()

In-place variants of Cholesky decomposition and linear solvers

Performance improvements

JIT-compile time improvements

Precompiled headers

Optimization level control

Parallel compilation

Language enhancements

Unpack operator support in kernels

C++ integration examples

Public API clarification

Platform support

Python version requirements

CUDA Toolkit updates

Acknowledgments

Full Changelog

Added

Removed

Deprecated

Changed

Fixed

Warp v1.10.1

Highlights

Announcements

Upcoming removals

Platform support

Acknowledgments

Fixed

Documentation

Warp v1.10.0

New features

JAX automatic differentiation (experimental)

Multi-device JAX support with jax.pmap()

In-place BVH rebuilding with CUDA graph support

Tile programming enhancements

Axis-specific reductions

Component-level indexing

Creating tiles filled with a constant value

New example

Performance improvements

Built-in function calls from Python

Configurable BVH leaf size

Sparse matrix operations with CUDA graphs

FEM operations with CUDA graphs

Language enhancements

Array indexing and slicing improvements

New built-in functions

Bug fixes

AArch64 CPU execution with tiles

Native library version verification

Announcements

Removal of warp.sim module

JAX FFI is now the default

Internal code reorganization: _src folder

Upcoming removals

Platform support

Acknowledgments

Added

Removed

Deprecated

Changed

Fixed

Warp v1.9.1

Highlights

Announcements

Known limitations

Upcoming removals

Platform support

Acknowledgments

`wp.tile_map()` supports n-ary maps (up to n=8)

Alpha and Beta scalings in `wp.tile_matmul()`

Multi-device JAX support with `jax.pmap()`

Removal of `warp.sim` module

Internal code reorganization: `_src` folder

Support for `IntEnum` and `IntFlag` inside kernels

Improved support for `wp.array()` views inside kernels