CHANGELOG.md

Changelog

Unreleased - 2024-??

Added

• Expose a reversed() built-in for iterators to test (GH-311).
• Expose a reversed() built-in for iterators.
• warp.fem: Added Trimesh3D and Quadmesh3D geometry types for 3D surfaces, with new example_distortion_energy example

Changed

• Promote the wp.Int, wp.Float, and wp.Scalar generic annotation types to the public API.
• Make the output of wp.print() in backward kernels consistent for all supported data types.

Fixed

• Fix place setting of paddle backend and add 2 missing benchmark files.
• Fix to relax the integer types expected when indexing arrays (regression in 1.3.0).
• Fix printing vector and matrix adjoints in backward kernels.
• Fix kernel compile error when printing structs.
• Fix an incorrect user function being sometimes resolved when multiple overloads are available with array parameters with different dtype values.
• Fix error being raised when static and dynamic for-loops are written in sequence with the same iteration variable names (GH-331).
• Fix an issue with the Texture Write node, used in the Mandelbrot Omniverse sample, sometimes erroring out in multi-GPU environments.

1.4.1 - 2024-10-15

Fixed

• Fix iter_reverse() not working as expected for ranges with steps other than 1 (GH-311).
• Fix potential out-of-bounds memory access when a wp.sparse.BsrMatrix object is reused for storing matrices of different shapes.
• Fix robustness to very low desired tolerance in wp.fem.utils.symmetric_eigenvalues_qr.
• Fix invalid code generation error messages when nesting dynamic and static for-loops.
• Fix caching of kernels with static expressions.
• Fix ModelBuilder.add_builder(builder) to correctly update articulation_start and thereby articulation_count when builder contains more than one articulation.
• Re-introduced the wp.rand*(), wp.sample*(), and wp.poisson() onto the Python scope to revert a breaking change.
• Fix printing vector and matrix adjoints in backward kernels.
• Fix kernel compile error when printing structs.
• warp.fem: Simplified querying neighboring cell quantities when integrating on sides using new warp.fem.cells(), warp.fem.to_inner_cell(), warp.fem.to_outer_cell() operators

Fixed

• Fix potential out-of-bounds memory access when a wp.sparse.BsrMatrix object is reused for storing matrices of different shapes
• Fix robustness to very low desired tolerance in wp.fem.utils.symmetric_eigenvalues_qr
• Fix invalid code generation error messages when nesting dynamic and static for-loops
• warp.fem: Fixed tri-cubic shape functions on quadrilateral meshes
• warp.fem: Fixed caching of integrand kernels when changing code-generation options

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.

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 (GH-312).

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

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

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

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

1.0.2 - 2024-03-22

• Make examples runnable from any location
• Fix the examples not running directly from their Python file
• Add the example gallery to the documentation
• Update README.md examples USD location
• Update example_graph_capture.py description

1.0.1 - 2024-03-15

• Document Device total_memory and free_memory
• Documentation for allocators, streams, peer access, and generics
• Changed example output directory to current working directory
• Added python -m warp.examples.browse for browsing the examples folder
• Print where the USD stage file is being saved
• Added examples/optim/example_walker.py sample
• Make the drone example not specific to USD
• Reduce the time taken to run some examples
• Optimise rendering points with a single colour
• Clarify an error message around needing USD
• Raise exception when module is unloaded during graph capture
• Added wp.synchronize_event() for blocking the host thread until a recorded event completes
• Flush C print buffers when ending stdout capture
• Remove more unneeded CUTLASS files
• Allow setting mempool release threshold as a fractional value

1.0.0 - 2024-03-07

• Add FeatherstoneIntegrator which provides more stable simulation of articulated rigid body dynamics in generalized coordinates (State.joint_q and State.joint_qd)
• Introduce warp.sim.Control struct to store control inputs for simulations (optional, by default the Model control inputs are used as before); integrators now have a different simulation signature: integrator.simulate(model: Model, state_in: State, state_out: State, dt: float, control: Control)
• joint_act can now behave in 3 modes: with joint_axis_mode set to JOINT_MODE_FORCE it behaves as a force/torque, with JOINT_MODE_VELOCITY it behaves as a velocity target, and with JOINT_MODE_POSITION it behaves as a position target; joint_target has been removed
• Add adhesive contact to Euler integrators via Model.shape_materials.ka which controls the contact distance at which the adhesive force is applied
• Improve handling of visual/collision shapes in URDF importer so visual shapes are not involved in contact dynamics
• Experimental JAX kernel callback support
• Improve module load exception message
• Add wp.ScopedCapture
• Removing enable_backward warning for callables
• Copy docstrings and annotations from wrapped kernels, functions, structs

0.15.1 - 2024-03-05

• Add examples assets to the wheel packages
• Fix broken image link in documentation
• Fix codegen for custom grad functions calling their respective forward functions
• Fix custom grad function handling for functions that have no outputs
• Fix issues when wp.config.quiet = True

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
• API change: wp.matmul() no longer accepts a device as a parameter; instead, it infers the correct device from the arrays being multiplied
• Updated DLPack utilities to the latest published standard
  • External arrays can be imported into Warp directly, e.g., wp.from_dlpack(external_array)
  • Warp arrays can be exported to consumer frameworks directly, e.g., jax.dlpack.from_dlpack(warp_array)
  • Added CUDA stream synchronization for CUDA arrays
  • The original DLPack protocol can still be used for better performance when stream synchronization is not required, see interoperability docs for details
  • warp.to_dlpack() is about 3-4x faster in common cases
  • warp.from_dlpack() is about 2x faster when called with a DLPack capsule
  • Fixed a small CPU memory leak related to DLPack interop
• Improved performance of creating arrays

0.13.1 - 2024-02-22

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

0.13.0 - 2024-02-16

• Update the license to NVIDIA Software License, allowing commercial use (see LICENSE.md)
• Add CONTRIBUTING.md guidelines (for NVIDIA employees)
• Hash CUDA snippet and adj_snippet strings to fix caching
• Fix build_docs.py on Windows
• Add missing .py extension to warp/tests/walkthrough_debug
• Allow wp.bool usage in vector and matrix types

0.12.0 - 2024-02-05

• Add a warning when the enable_backward setting is set to False upon calling wp.Tape.backward()
• Fix kernels not being recompiled as expected when defined using a closure
• Change the kernel cache appauthor subdirectory to just "NVIDIA"
• Ensure that gradients attached to PyTorch tensors have compatible strides when calling wp.from_torch()
• Add a Noise Deform node for OmniGraph that deforms points using a perlin/curl noise

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()

1.0.0-beta.6 - 2024-01-10

• Do not create CPU copy of grad array when calling array.numpy()
• Fix assert_np_equal() bug
• Support Linux AArch64 platforms, including Jetson/Tegra devices
• Add parallel testing runner (invoke with python -m warp.tests, use warp/tests/unittest_serial.py for serial testing)
• Fix support for function calls in range()
• wp.matmul() adjoints now accumulate
• Expand available operators (e.g. vector @ matrix, scalar as dividend) and improve support for calling native built-ins
• Fix multi-gpu synchronization issue in sparse.py
• Add depth rendering to wp.render.OpenGLRenderer, document wp.render
• Make wp.atomic_min(), wp.atomic_max() differentiable
• Fix error reporting using the exact source segment
• Add user-friendly mesh query overloads, returning a struct instead of overwriting parameters
• Address multiple differentiability issues
• Fix backpropagation for returning array element references
• Support passing the return value to adjoints
• Add point basis space and explicit point-based quadrature for wp.fem
• Support overriding the LLVM project source directory path using build_lib.py --build_llvm --llvm_source_path=
• Fix the error message for accessing non-existing attributes
• Flatten faces array for Mesh constructor in URDF parser

1.0.0-beta.5 - 2023-11-22

• Fix for kernel caching when function argument types change
• Fix code-gen ordering of dependent structs
• Fix for wp.Mesh build on MGPU systems
• Fix for name clash bug with adjoint code: #154
• Add wp.frac() for returning the fractional part of a floating point value
• Add support for custom native CUDA snippets using @wp.func_native decorator
• Add support for batched matmul with batch size > 2^16-1
• Add support for transposed CUTLASS wp.matmul() and additional error checking
• Add support for quad and hex meshes in wp.fem
• Detect and warn when C++ runtime doesn't match compiler during build, e.g.: libstdc++.so.6: version `GLIBCXX_3.4.30' not found
• Documentation update for wp.BVH
• Documentation and simplified API for runtime kernel specialization wp.Kernel

1.0.0-beta.4 - 2023-11-01

• Add wp.cbrt() for cube root calculation
• Add wp.mesh_furthest_point_no_sign() to compute furthest point on a surface from a query point
• Add support for GPU BVH builds, 10-100x faster than CPU builds for large meshes
• Add support for chained comparisons, i.e.: 0 < x < 2
• Add support for running wp.fem examples headless
• Fix for unit test determinism
• Fix for possible GC collection of array during graph capture
• Fix for wp.utils.array_sum() output initialization when used with vector types
• Coverage and documentation updates

1.0.0-beta.3 - 2023-10-19

• Add support for code coverage scans (test_coverage.py), coverage at 85% in omni.warp.core
• Add support for named component access for vector types, e.g.: a = v.x
• Add support for lvalue expressions, e.g.: array[i] += b
• Add casting constructors for matrix and vector types
• Add support for type() operator that can be used to return type inside kernels
• Add support for grid-stride kernels to support kernels with > 2^31-1 thread blocks
• Fix for multi-process initialization warnings
• Fix alignment issues with empty wp.struct
• Fix for return statement warning with tuple-returning functions
• Fix for wp.batched_matmul() registering the wrong function in the Tape
• Fix and document for wp.sim forward + inverse kinematics
• Fix for wp.func to return a default value if function does not return on all control paths
• Refactor wp.fem support for new basis functions, decoupled function spaces
• Optimizations for wp.noise functions, up to 10x faster in most cases
• Optimizations for type_size_in_bytes() used in array construction'

Breaking Changes

• To support grid-stride kernels, wp.tid() can no longer be called inside wp.func functions.

1.0.0-beta.2 - 2023-09-01

• Fix for passing bool into wp.func functions
• Fix for deprecation warnings appearing on stderr, now redirected to stdout
• Fix for using for i in wp.hash_grid_query(..) syntax

1.0.0-beta.1 - 2023-08-29

• Fix for wp.float16 being passed as kernel arguments
• Fix for compile errors with kernels using structs in backward pass
• Fix for wp.Mesh.refit() not being CUDA graph capturable due to synchronous temp. allocs
• Fix for dynamic texture example flickering / MGPU crashes demo in Kit by reusing ui.DynamicImageProvider instances
• Fix for a regression that disabled bundle change tracking in samples
• Fix for incorrect surface velocities when meshes are deforming in OgnClothSimulate
• Fix for incorrect lower-case when setting USD stage "up_axis" in examples
• Fix for incompatible gradient types when wrapping PyTorch tensor as a vector or matrix type
• Fix for adding open edges when building cloth constraints from meshes in wp.sim.ModelBuilder.add_cloth_mesh()
• Add support for wp.fabricarray to directly access Fabric data from Warp kernels, see https://docs.omniverse.nvidia.com/kit/docs/usdrt/latest/docs/usdrt_prim_selection.html for examples
• Add support for user defined gradient functions, see @wp.func_replay, and @wp.func_grad decorators
• Add support for more OG attribute types in omni.warp.from_omni_graph()
• Add support for creating NanoVDB wp.Volume objects from dense NumPy arrays
• Add support for wp.volume_sample_grad_f() which returns the value + gradient efficiently from an NVDB volume
• Add support for LLVM fp16 intrinsics for half-precision arithmetic
• Add implementation of stochastic gradient descent, see wp.optim.SGD
• Add wp.fem framework for solving weak-form PDE problems (see https://nvidia.github.io/warp/modules/fem.html)
• Optimizations for omni.warp extension load time (2.2s to 625ms cold start)
• Make all omni.ui dependencies optional so that Warp unit tests can run headless
• Deprecation of wp.tid() outside of kernel functions, users should pass tid() values to wp.func functions explicitly
• Deprecation of wp.sim.Model.flatten() for returning all contained tensors from the model
• Add support for clamping particle max velocity in wp.sim.Model.particle_max_velocity
• Remove dependency on urdfpy package, improve MJCF parser handling of default values

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 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

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 wp.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 exclusive)
  • 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

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 walkthrough_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)

0.8.2 - 2023-04-21

• Add ModelBuilder.soft_contact_max to control the maximum number of soft contacts that can be registered. Use Model.allocate_soft_contacts(new_count) to change count on existing Model objects.
• Add support for bool parameters
• Add support for logical boolean operators with int types
• Fix for wp.quat() default constructor
• Fix conditional reassignments
• Add sign determination using angle weighted normal version of wp.mesh_query_point() as wp.mesh_query_sign_normal()
• Add sign determination using winding number of wp.mesh_query_point() as wp.mesh_query_sign_winding_number()
• Add query point without sign determination wp.mesh_query_no_sign()

0.8.1 - 2023-04-13

• Fix for regression when passing flattened numeric lists as matrix arguments to kernels
• Fix for regressions when passing wp.struct types with uninitialized (None) member attributes

0.8.0 - 2023-04-05

• 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

0.7.2 - 2023-02-15

• Reduce test time for vec/math types
• Clean-up CUDA disabled build pipeline
• Remove extension.gen.toml to make Kit packages Python version independent
• Handle additional cases for array indexing inside Python

0.7.1 - 2023-02-14

• Disabling some slow tests for Kit
• Make unit tests run on first GPU only by default

0.7.0 - 2023-02-13

• Add support for arbitrary length / type vector and matrices e.g.: wp.vec(length=7, dtype=wp.float16), see wp.vec(), and wp.mat()
• Add support for array.flatten(), array.reshape(), and array.view() with NumPy semantics
• Add support for slicing wp.array types in Python
• Add wp.from_ptr() helper to construct arrays from an existing allocation
• Add support for break statements in ranged-for and while loops (backward pass support currently not implemented)
• Add built-in mathematic constants, see wp.pi, wp.e, wp.log2e, etc.
• Add built-in conversion between degrees and radians, see wp.degrees(), wp.radians()
• Add security pop-up for Kernel Node
• Improve error handling for kernel return values

0.6.3 - 2023-01-31

• Add DLPack utilities, see wp.from_dlpack(), wp.to_dlpack()
• Add Jax utilities, see wp.from_jax(), wp.to_jax(), wp.device_from_jax(), wp.device_to_jax()
• Fix for Linux Kit extensions OM-80132, OM-80133

0.6.2 - 2023-01-19

• Updated wp.from_torch() to support more data types
• Updated wp.from_torch() to automatically determine the target Warp data type if not specified
• Updated wp.from_torch() to support non-contiguous tensors with arbitrary strides
• Add CUTLASS integration for dense GEMMs, see wp.matmul() and wp.matmul_batched()
• Add QR and Eigen decompositions for mat33 types, see wp.qr3(), and wp.eig3()
• Add default (zero) constructors for matrix types
• Add a flag to suppress all output except errors and warnings (set wp.config.quiet = True)
• Skip recompilation when Kernel Node attributes are edited
• Allow optional attributes for Kernel Node
• Allow disabling backward pass code-gen on a per-kernel basis, use @wp.kernel(enable_backward=False)
• Replace Python imp package with importlib
• Fix for quaternion slerp gradients (wp.quat_slerp())

0.6.1 - 2022-12-05

• Fix for non-CUDA builds
• Fix strides computation in array_t constructor, fixes a bug with accessing mesh indices through mesh.indices[]
• Disable backward pass code generation for kernel node (4-6x faster compilation)
• Switch to linbuild for universal Linux binaries (affects TeamCity builds only)

0.6.0 - 2022-11-28

• Add support for CUDA streams, see wp.Stream, wp.get_stream(), wp.set_stream(), wp.synchronize_stream(), wp.ScopedStream
• Add support for CUDA events, see wp.Event, wp.record_event(), wp.wait_event(), wp.wait_stream(), wp.Stream.record_event(), wp.Stream.wait_event(), wp.Stream.wait_stream()
• Add support for PyTorch stream interop, see wp.stream_from_torch(), wp.stream_to_torch()
• Add support for allocating host arrays in pinned memory for asynchronous data transfers, use wp.array(..., pinned=True) (default is non-pinned)
• Add support for direct conversions between all scalar types, e.g.: x = wp.uint8(wp.float64(3.0))
• Add per-module option to enable fast math, use wp.set_module_options({"fast_math": True}), fast math is now disabled by default
• Add support for generating CUBIN kernels instead of PTX on systems with older drivers
• Add user preference options for CUDA kernel output ("ptx" or "cubin", e.g.: wp.config.cuda_output = "ptx" or per-module wp.set_module_options({"cuda_output": "ptx"}))
• Add kernel node for OmniGraph
• Add wp.quat_slerp(), wp.quat_to_axis_angle(), wp.rotate_rodriquez() and adjoints for all remaining quaternion operations
• Add support for unrolling for-loops when range is a wp.constant
• Add support for arithmetic operators on built-in vector / matrix types outside of wp.kernel
• Add support for multiple solution variables in wp.optim Adam optimization
• Add nested attribute support for wp.struct attributes
• Add missing adjoint implementations for spatial math types, and document all functions with missing adjoints
• Add support for retrieving NanoVDB tiles and voxel size, see wp.Volume.get_tiles(), and wp.Volume.get_voxel_size()
• Add support for store operations on integer NanoVDB volumes, see wp.volume_store_i()
• Expose wp.Mesh points, indices, as arrays inside kernels, see wp.mesh_get()
• Optimizations for wp.array construction, 2-3x faster on average
• Optimizations for URDF import
• Fix various deployment issues by statically linking with all CUDA libs
• Update warp.so/warp.dll to CUDA Toolkit 11.5

0.5.1 - 2022-11-01

• Fix for unit tests in Kit

0.5.0 - 2022-10-31

• Add smoothed particle hydrodynamics (SPH) example, see example_sph.py
• Add support for accessing array.shape inside kernels, e.g.: width = arr.shape[0]
• Add dependency tracking to hot-reload modules if dependencies were modified
• Add lazy acquisition of CUDA kernel contexts (save ~300Mb of GPU memory in MGPU environments)
• Add BVH object, see wp.Bvh and bvh_query_ray(), bvh_query_aabb() functions
• Add component index operations for spatial_vector, spatial_matrix types
• Add wp.lerp() and wp.smoothstep() builtins
• Add wp.optim module with implementation of the Adam optimizer for float and vector types
• Add support for transient Python modules (fix for Houdini integration)
• Add wp.length_sq(), wp.trace() for vector / matrix types respectively
• Add missing adjoints for wp.quat_rpy(), wp.determinant()
• Add wp.atomic_min(), wp.atomic_max() operators
• Add vectorized version of wp.sim.model.add_cloth_mesh()
• Add NVDB volume allocation API, see wp.Volume.allocate(), and wp.Volume.allocate_by_tiles()
• Add NVDB volume write methods, see wp.volume_store_i(), wp.volume_store_f(), wp.volume_store_v()
• Add MGPU documentation
• Add example showing how to compute Jacobian of multiple environments in parallel, see example_jacobian_ik.py
• Add wp.Tape.zero() support for wp.struct types
• Make SampleBrowser an optional dependency for Kit extension
• Make wp.Mesh object accept both 1d and 2d arrays of face vertex indices
• Fix for reloading of class member kernel / function definitions using importlib.reload()
• Fix for hashing of wp.constants() not invalidating kernels
• Fix for reload when multiple .ptx versions are present
• Improved error reporting during code-gen

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 wp.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

Breaking Changes

• Removed wp.runtime reference from the top-level module, as it should be considered private

0.3.2 - 2022-07-19

• Remove Torch import from __init__.py, defer import to wp.from_torch(), wp.to_torch()

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()
• 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"

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 compatibility 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)

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 copies, 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 wp.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

0.2.0 - 2022-05-02

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.array 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 wp.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

0.1.25 - 2022-03-20

• Add support for class methods to be Warp kernels
• Add HashGrid reserve() so it can be used with CUDA graphs
• Add support for CUDA graph capture of tape forward/backward passes
• Add support for Python 3.8.x and 3.9.x
• Add hyperbolic trigonometric functions, see wp.tanh(), wp.sinh(), wp.cosh()
• Add support for floored division on integer types
• Move tests into core library so they can be run in Kit environment

0.1.24 - 2022-03-03

Warp Core

• Add NanoVDB support, see wp.volume_sample*() methods
• Add support for reading compile-time constants in kernels, see wp.constant()
• Add support for cuda_array_interface protocol for zero-copy interop with PyTorch, see wp.torch.to_torch()
• Add support for additional numeric types, i8, u8, i16, u16, etc
• Add better checks for device strings during allocation / launch
• Add support for sampling random numbers with a normal distribution, see wp.randn()
• Upgrade to CUDA 11.3
• Update example scenes to Kit 103.1
• Deduce array dtype from np.array when one is not provided
• Fix for ranged for loops with negative step sizes
• Fix for 3d and 4d spherical gradient distributions

0.1.23 - 2022-02-17

Warp Core

• Fix for generated code folder being removed during Showroom installation
• Fix for macOS support
• Fix for dynamic for-loop code gen edge case
• Add procedural noise primitives, see wp.noise(), wp.pnoise(), wp.curlnoise()
• Move simulation helpers our of test into wp.sim module

0.1.22 - 2022-02-14

Warp Core

• Fix for .so reloading on Linux
• Fix for while loop code-gen in some edge cases
• Add rounding functions wp.round(), wp.rint(), wp.trunc(), wp.floor(), wp.ceil()
• Add support for printing strings and formatted strings from kernels
• Add MSVC compiler version detection and require minimum

Warp Sim

• Add support for universal and compound joint types

0.1.21 - 2022-01-19

Warp Core

• Fix for exception on shutdown in empty wp.array objects
• Fix for hot reload of CPU kernels in Kit
• Add hash grid primitive for point-based spatial queries, see wp.hash_grid_query(), wp.hash_grid_query_next()
• Add new PRNG methods using PCG-based generators, see wp.rand_init(), wp.randf(), wp.randi()
• Add support for AABB mesh queries, see wp.mesh_query_aabb(), wp.mesh_query_aabb_next()
• Add support for all Python range() loop variants
• Add builtin vec2 type and additional math operators, wp.pow(), wp.tan(), wp.atan(), wp.atan2()
• Remove dependency on CUDA driver library at build time
• Remove unused NVRTC binary dependencies (50mb smaller Linux distribution)

Warp Sim

• Bundle import of multiple shapes for simulation nodes
• New OgnParticleVolume node for sampling shapes -> particles
• New OgnParticleSolver node for DEM style granular materials

0.1.20 - 2021-11-02

• Updates to the ripple solver for GTC (support for multiple colliders, buoyancy, etc)

0.1.19 - 2021-10-15

• Publish from 2021.3 to avoid omni.graph database incompatibilities

0.1.18 - 2021-10-08

• Enable Linux support (tested on 20.04)

0.1.17 - 2021-09-30

• Fix for 3x3 SVD adjoint
• Fix for A6000 GPU (bump compute model to sm_52 minimum)
• Fix for .dll unload on rebuild
• Fix for possible array destruction warnings on shutdown
• Rename spatial_transform -> transform
• Documentation update

0.1.16 - 2021-09-06

• Fix for case where simple assignments (a = b) incorrectly generated reference rather than value copy
• Handle passing zero-length (empty) arrays to kernels

0.1.15 - 2021-09-03

• Add additional math library functions (asin, etc)
• Add builtin 3x3 SVD support
• Add support for named constants (True, False, None)
• Add support for if/else statements (differentiable)
• Add custom memset kernel to avoid CPU overhead of cudaMemset()
• Add rigid body joint model to wp.sim (based on Brax)
• Add Linux, MacOS support in core library
• Fix for incorrectly treating pure assignment as reference instead of value copy
• Removes the need to transfer array to CPU before numpy conversion (will be done implicitly)
• Update the example OgnRipple wave equation solver to use bundles

0.1.14 - 2021-08-09

• Fix for out-of-bounds memory access in CUDA BVH
• Better error checking after kernel launches (use wp.config.verify_cuda=True)
• Fix for vec3 normalize adjoint code

0.1.13 - 2021-07-29

• Remove OgnShrinkWrap.py test node

0.1.12 - 2021-07-29

• Switch to Woop et al.'s watertight ray-tri intersection test
• Disable --fast-math in CUDA compilation step for improved precision

0.1.11 - 2021-07-28

• Fix for wp.mesh_query_ray() returning incorrect t-value

0.1.10 - 2021-07-28

• Fix for OV extension fwatcher filters to avoid hot-reload loop due to OGN regeneration

0.1.9 - 2021-07-21

• Fix for loading sibling DLL paths
• Better type checking for built-in function arguments
• Added runtime docs, can now list all builtins using wp.print_builtins()

0.1.8 - 2021-07-14

• Fix for hot-reload of CUDA kernels
• Add Tape object for replaying differentiable kernels
• Add helpers for Torch interop (convert torch.Tensor to wp.Array)

0.1.7 - 2021-07-05

• Switch to NVRTC for CUDA runtime
• Allow running without host compiler
• Disable asserts in kernel release mode (small perf. improvement)

0.1.6 - 2021-06-14

• Look for CUDA toolchain in target-deps

0.1.5 - 2021-06-14

• Rename OgLang -> Warp
• Improve CUDA environment error checking
• Clean-up some logging, add verbose mode (wp.config.verbose)

0.1.4 - 2021-06-10

• Add support for mesh raycast

0.1.3 - 2021-06-09

• Add support for unary negation operator
• Add support for mutating variables during dynamic loops (non-differentiable)
• Add support for in-place operators
• Improve kernel cache start up times (avoids adjointing before cache check)
• Update README.md with requirements / examples

0.1.2 - 2021-06-03

• Add support for querying mesh velocities

• Add CUDA graph support, see wp.capture_begin(), wp.capture_end(), wp.capture_launch()

• Add explicit initialization phase, wp.init()

• Add variational Euler solver (sim)

• Add contact caching, switch to nonlinear friction model (sim)

• Fix for Linux/macOS support

0.1.1 - 2021-05-18

• Fix bug with conflicting CUDA contexts

0.1.0 - 2021-05-17

• Initial publish for alpha testing