warp-lang 1.9.0__py3-none-manylinux_2_34_aarch64.whl → 1.10.0__py3-none-manylinux_2_34_aarch64.whl

warp/__init__.pyi

@@ -20,6 +20,7 @@ from typing import Tuple
 from typing import Callable
 from typing import TypeVar
 from typing import Generic
+from typing import Sequence
 from typing import overload as over
 
 Length = TypeVar("Length", bound=int)
@@ -36,302 +37,1731 @@ FabricArray = Generic[DType]
 IndexedFabricArray = Generic[DType]
 Tile = Generic[DType, Shape]
 
-from warp.types import array as array
-from warp.types import array1d as array1d
-from warp.types import array2d as array2d
-from warp.types import array3d as array3d
-from warp.types import array4d as array4d
-from warp.types import constant as constant
-from warp.types import from_ptr as from_ptr
-from warp.types import fixedarray as fixedarray
-from warp.types import indexedarray as indexedarray
-from warp.types import indexedarray1d as indexedarray1d
-from warp.types import indexedarray2d as indexedarray2d
-from warp.types import indexedarray3d as indexedarray3d
-from warp.types import indexedarray4d as indexedarray4d
-from warp.fabric import fabricarray as fabricarray
-from warp.fabric import fabricarrayarray as fabricarrayarray
-from warp.fabric import indexedfabricarray as indexedfabricarray
-from warp.fabric import indexedfabricarrayarray as indexedfabricarrayarray
-from warp.types import tile as tile
-
-from warp.types import bool as bool
-from warp.types import int8 as int8
-from warp.types import uint8 as uint8
-from warp.types import int16 as int16
-from warp.types import uint16 as uint16
-from warp.types import int32 as int32
-from warp.types import uint32 as uint32
-from warp.types import int64 as int64
-from warp.types import uint64 as uint64
-from warp.types import float16 as float16
-from warp.types import float32 as float32
-from warp.types import float64 as float64
-
-from warp.types import vec2 as vec2
-from warp.types import vec2b as vec2b
-from warp.types import vec2ub as vec2ub
-from warp.types import vec2s as vec2s
-from warp.types import vec2us as vec2us
-from warp.types import vec2i as vec2i
-from warp.types import vec2ui as vec2ui
-from warp.types import vec2l as vec2l
-from warp.types import vec2ul as vec2ul
-from warp.types import vec2h as vec2h
-from warp.types import vec2f as vec2f
-from warp.types import vec2d as vec2d
-
-from warp.types import vec3 as vec3
-from warp.types import vec3b as vec3b
-from warp.types import vec3ub as vec3ub
-from warp.types import vec3s as vec3s
-from warp.types import vec3us as vec3us
-from warp.types import vec3i as vec3i
-from warp.types import vec3ui as vec3ui
-from warp.types import vec3l as vec3l
-from warp.types import vec3ul as vec3ul
-from warp.types import vec3h as vec3h
-from warp.types import vec3f as vec3f
-from warp.types import vec3d as vec3d
-
-from warp.types import vec4 as vec4
-from warp.types import vec4b as vec4b
-from warp.types import vec4ub as vec4ub
-from warp.types import vec4s as vec4s
-from warp.types import vec4us as vec4us
-from warp.types import vec4i as vec4i
-from warp.types import vec4ui as vec4ui
-from warp.types import vec4l as vec4l
-from warp.types import vec4ul as vec4ul
-from warp.types import vec4h as vec4h
-from warp.types import vec4f as vec4f
-from warp.types import vec4d as vec4d
-
-from warp.types import mat22 as mat22
-from warp.types import mat22h as mat22h
-from warp.types import mat22f as mat22f
-from warp.types import mat22d as mat22d
-
-from warp.types import mat33 as mat33
-from warp.types import mat33h as mat33h
-from warp.types import mat33f as mat33f
-from warp.types import mat33d as mat33d
-
-from warp.types import mat44 as mat44
-from warp.types import mat44h as mat44h
-from warp.types import mat44f as mat44f
-from warp.types import mat44d as mat44d
-
-from warp.types import quat as quat
-from warp.types import quath as quath
-from warp.types import quatf as quatf
-from warp.types import quatd as quatd
-
-from warp.types import transform as transform
-from warp.types import transformh as transformh
-from warp.types import transformf as transformf
-from warp.types import transformd as transformd
-
-from warp.types import spatial_vector as spatial_vector
-from warp.types import spatial_vectorh as spatial_vectorh
-from warp.types import spatial_vectorf as spatial_vectorf
-from warp.types import spatial_vectord as spatial_vectord
-
-from warp.types import spatial_matrix as spatial_matrix
-from warp.types import spatial_matrixh as spatial_matrixh
-from warp.types import spatial_matrixf as spatial_matrixf
-from warp.types import spatial_matrixd as spatial_matrixd
-
-from warp.types import Int as Int
-from warp.types import Float as Float
-from warp.types import Scalar as Scalar
-
-from warp.types import Bvh as Bvh
-from warp.types import Mesh as Mesh
-from warp.types import HashGrid as HashGrid
-from warp.types import Volume as Volume
-from warp.types import BvhQuery as BvhQuery
-from warp.types import HashGridQuery as HashGridQuery
-from warp.types import MeshQueryAABB as MeshQueryAABB
-from warp.types import MeshQueryPoint as MeshQueryPoint
-from warp.types import MeshQueryRay as MeshQueryRay
-
-from warp.types import matmul as matmul
-from warp.types import adj_matmul as adj_matmul
-from warp.types import batched_matmul as batched_matmul
-from warp.types import adj_batched_matmul as adj_batched_matmul
-
-from warp.types import vector as vec
-from warp.types import matrix as mat
-
-from warp.types import matrix_from_cols as matrix_from_cols
-from warp.types import matrix_from_rows as matrix_from_rows
-
-from warp.types import dtype_from_numpy as dtype_from_numpy
-from warp.types import dtype_to_numpy as dtype_to_numpy
-
-from warp.types import from_ipc_handle as from_ipc_handle
-
-from warp.context import init as init
-from warp.context import func as func
-from warp.context import func_grad as func_grad
-from warp.context import func_replay as func_replay
-from warp.context import func_native as func_native
-from warp.context import kernel as kernel
-from warp.context import struct as struct
-from warp.context import overload as overload
-
-from warp.context import is_cpu_available as is_cpu_available
-from warp.context import is_cuda_available as is_cuda_available
-from warp.context import is_device_available as is_device_available
-from warp.context import get_devices as get_devices
-from warp.context import get_preferred_device as get_preferred_device
-from warp.context import get_cuda_devices as get_cuda_devices
-from warp.context import get_cuda_device_count as get_cuda_device_count
-from warp.context import get_cuda_device as get_cuda_device
-from warp.context import map_cuda_device as map_cuda_device
-from warp.context import unmap_cuda_device as unmap_cuda_device
-from warp.context import get_device as get_device
-from warp.context import set_device as set_device
-from warp.context import synchronize_device as synchronize_device
-
-from warp.context import zeros as zeros
-from warp.context import zeros_like as zeros_like
-from warp.context import ones as ones
-from warp.context import ones_like as ones_like
-from warp.context import full as full
-from warp.context import full_like as full_like
-from warp.context import clone as clone
-from warp.context import empty as empty
-from warp.context import empty_like as empty_like
-from warp.context import copy as copy
-from warp.context import from_numpy as from_numpy
-
-from warp.context import launch as launch
-from warp.context import launch_tiled as launch_tiled
-from warp.context import synchronize as synchronize
-from warp.context import compile_aot_module as compile_aot_module
-from warp.context import force_load as force_load
-from warp.context import load_module as load_module
-from warp.context import load_aot_module as load_aot_module
-from warp.context import event_from_ipc_handle as event_from_ipc_handle
-
-from warp.context import set_module_options as set_module_options
-from warp.context import get_module_options as get_module_options
-from warp.context import get_module as get_module
-
-from warp.context import capture_begin as capture_begin
-from warp.context import capture_end as capture_end
-from warp.context import capture_launch as capture_launch
-from warp.context import capture_if as capture_if
-from warp.context import capture_while as capture_while
-from warp.context import capture_debug_dot_print as capture_debug_dot_print
-
-from warp.context import Kernel as Kernel
-from warp.context import Function as Function
-from warp.context import Launch as Launch
-
-from warp.context import Stream as Stream
-from warp.context import get_stream as get_stream
-from warp.context import set_stream as set_stream
-from warp.context import wait_stream as wait_stream
-from warp.context import synchronize_stream as synchronize_stream
-
-from warp.context import Event as Event
-from warp.context import record_event as record_event
-from warp.context import wait_event as wait_event
-from warp.context import synchronize_event as synchronize_event
-from warp.context import get_event_elapsed_time as get_event_elapsed_time
-
-from warp.context import RegisteredGLBuffer as RegisteredGLBuffer
-
-from warp.context import is_mempool_supported as is_mempool_supported
-from warp.context import is_mempool_enabled as is_mempool_enabled
-from warp.context import set_mempool_enabled as set_mempool_enabled
-
-from warp.context import set_mempool_release_threshold as set_mempool_release_threshold
-from warp.context import get_mempool_release_threshold as get_mempool_release_threshold
-from warp.context import get_mempool_used_mem_current as get_mempool_used_mem_current
-from warp.context import get_mempool_used_mem_high as get_mempool_used_mem_high
-
-from warp.context import is_mempool_access_supported as is_mempool_access_supported
-from warp.context import is_mempool_access_enabled as is_mempool_access_enabled
-from warp.context import set_mempool_access_enabled as set_mempool_access_enabled
-
-from warp.context import is_peer_access_supported as is_peer_access_supported
-from warp.context import is_peer_access_enabled as is_peer_access_enabled
-from warp.context import set_peer_access_enabled as set_peer_access_enabled
-
-from warp.tape import Tape as Tape
-
-from warp.utils import ScopedTimer as ScopedTimer
-from warp.utils import ScopedDevice as ScopedDevice
-from warp.utils import ScopedStream as ScopedStream
-from warp.utils import ScopedMempool as ScopedMempool
-from warp.utils import ScopedMempoolAccess as ScopedMempoolAccess
-from warp.utils import ScopedPeerAccess as ScopedPeerAccess
-from warp.utils import ScopedCapture as ScopedCapture
-
-from warp.utils import transform_expand as transform_expand
-from warp.utils import quat_between_vectors as quat_between_vectors
-
-from warp.utils import TimingResult as TimingResult
-from warp.utils import timing_begin as timing_begin
-from warp.utils import timing_end as timing_end
-from warp.utils import timing_print as timing_print
-
-from warp.utils import TIMING_KERNEL as TIMING_KERNEL
-from warp.utils import TIMING_KERNEL_BUILTIN as TIMING_KERNEL_BUILTIN
-from warp.utils import TIMING_MEMCPY as TIMING_MEMCPY
-from warp.utils import TIMING_MEMSET as TIMING_MEMSET
-from warp.utils import TIMING_GRAPH as TIMING_GRAPH
-from warp.utils import TIMING_ALL as TIMING_ALL
-
-from warp.utils import map as map
-
-from warp.marching_cubes import MarchingCubes as MarchingCubes
-
-from warp.torch import from_torch as from_torch
-from warp.torch import to_torch as to_torch
-from warp.torch import dtype_from_torch as dtype_from_torch
-from warp.torch import dtype_to_torch as dtype_to_torch
-from warp.torch import device_from_torch as device_from_torch
-from warp.torch import device_to_torch as device_to_torch
-from warp.torch import stream_from_torch as stream_from_torch
-from warp.torch import stream_to_torch as stream_to_torch
-
-from warp.jax import from_jax as from_jax
-from warp.jax import to_jax as to_jax
-from warp.jax import dtype_from_jax as dtype_from_jax
-from warp.jax import dtype_to_jax as dtype_to_jax
-from warp.jax import device_from_jax as device_from_jax
-from warp.jax import device_to_jax as device_to_jax
-
-from warp.dlpack import from_dlpack as from_dlpack
-from warp.dlpack import to_dlpack as to_dlpack
-
-from warp.paddle import from_paddle as from_paddle
-from warp.paddle import to_paddle as to_paddle
-from warp.paddle import dtype_from_paddle as dtype_from_paddle
-from warp.paddle import dtype_to_paddle as dtype_to_paddle
-from warp.paddle import device_from_paddle as device_from_paddle
-from warp.paddle import device_to_paddle as device_to_paddle
-from warp.paddle import stream_from_paddle as stream_from_paddle
-
-from warp.build import clear_kernel_cache as clear_kernel_cache
-from warp.build import clear_lto_cache as clear_lto_cache
-
-from warp.constants import *
-
-from . import builtins
-from warp.builtins import static as static
-
-from warp.math import *
-
-from . import config as config
+from warp._src.types import array as array
+from warp._src.types import array1d as array1d
+from warp._src.types import array2d as array2d
+from warp._src.types import array3d as array3d
+from warp._src.types import array4d as array4d
+from warp._src.types import constant as constant
+from warp._src.types import from_ptr as from_ptr
+from warp._src.types import fixedarray as fixedarray
+from warp._src.types import indexedarray as indexedarray
+from warp._src.types import indexedarray1d as indexedarray1d
+from warp._src.types import indexedarray2d as indexedarray2d
+from warp._src.types import indexedarray3d as indexedarray3d
+from warp._src.types import indexedarray4d as indexedarray4d
+from warp._src.fabric import fabricarray as fabricarray
+from warp._src.fabric import fabricarrayarray as fabricarrayarray
+from warp._src.fabric import indexedfabricarray as indexedfabricarray
+from warp._src.fabric import indexedfabricarrayarray as indexedfabricarrayarray
+from warp._src.types import tile as tile
+
+from warp._src.types import bool as bool
+from warp._src.types import int8 as int8
+from warp._src.types import uint8 as uint8
+from warp._src.types import int16 as int16
+from warp._src.types import uint16 as uint16
+from warp._src.types import int32 as int32
+from warp._src.types import uint32 as uint32
+from warp._src.types import int64 as int64
+from warp._src.types import uint64 as uint64
+from warp._src.types import float16 as float16
+from warp._src.types import float32 as float32
+from warp._src.types import float64 as float64
+
+from warp._src.types import vec2 as vec2
+from warp._src.types import vec2b as vec2b
+from warp._src.types import vec2ub as vec2ub
+from warp._src.types import vec2s as vec2s
+from warp._src.types import vec2us as vec2us
+from warp._src.types import vec2i as vec2i
+from warp._src.types import vec2ui as vec2ui
+from warp._src.types import vec2l as vec2l
+from warp._src.types import vec2ul as vec2ul
+from warp._src.types import vec2h as vec2h
+from warp._src.types import vec2f as vec2f
+from warp._src.types import vec2d as vec2d
+
+from warp._src.types import vec3 as vec3
+from warp._src.types import vec3b as vec3b
+from warp._src.types import vec3ub as vec3ub
+from warp._src.types import vec3s as vec3s
+from warp._src.types import vec3us as vec3us
+from warp._src.types import vec3i as vec3i
+from warp._src.types import vec3ui as vec3ui
+from warp._src.types import vec3l as vec3l
+from warp._src.types import vec3ul as vec3ul
+from warp._src.types import vec3h as vec3h
+from warp._src.types import vec3f as vec3f
+from warp._src.types import vec3d as vec3d
+
+from warp._src.types import vec4 as vec4
+from warp._src.types import vec4b as vec4b
+from warp._src.types import vec4ub as vec4ub
+from warp._src.types import vec4s as vec4s
+from warp._src.types import vec4us as vec4us
+from warp._src.types import vec4i as vec4i
+from warp._src.types import vec4ui as vec4ui
+from warp._src.types import vec4l as vec4l
+from warp._src.types import vec4ul as vec4ul
+from warp._src.types import vec4h as vec4h
+from warp._src.types import vec4f as vec4f
+from warp._src.types import vec4d as vec4d
+
+from warp._src.types import mat22 as mat22
+from warp._src.types import mat22h as mat22h
+from warp._src.types import mat22f as mat22f
+from warp._src.types import mat22d as mat22d
+
+from warp._src.types import mat33 as mat33
+from warp._src.types import mat33h as mat33h
+from warp._src.types import mat33f as mat33f
+from warp._src.types import mat33d as mat33d
+
+from warp._src.types import mat44 as mat44
+from warp._src.types import mat44h as mat44h
+from warp._src.types import mat44f as mat44f
+from warp._src.types import mat44d as mat44d
+
+from warp._src.types import quat as quat
+from warp._src.types import quath as quath
+from warp._src.types import quatf as quatf
+from warp._src.types import quatd as quatd
+
+from warp._src.types import transform as transform
+from warp._src.types import transformh as transformh
+from warp._src.types import transformf as transformf
+from warp._src.types import transformd as transformd
+
+from warp._src.types import spatial_vector as spatial_vector
+from warp._src.types import spatial_vectorh as spatial_vectorh
+from warp._src.types import spatial_vectorf as spatial_vectorf
+from warp._src.types import spatial_vectord as spatial_vectord
+
+from warp._src.types import spatial_matrix as spatial_matrix
+from warp._src.types import spatial_matrixh as spatial_matrixh
+from warp._src.types import spatial_matrixf as spatial_matrixf
+from warp._src.types import spatial_matrixd as spatial_matrixd
+
+from warp._src.types import Int as Int
+from warp._src.types import Float as Float
+from warp._src.types import Scalar as Scalar
+
+from warp._src.types import Bvh as Bvh
+from warp._src.types import Mesh as Mesh
+from warp._src.types import HashGrid as HashGrid
+from warp._src.types import Volume as Volume
+from warp._src.types import BvhQuery as BvhQuery
+from warp._src.types import HashGridQuery as HashGridQuery
+from warp._src.types import MeshQueryAABB as MeshQueryAABB
+from warp._src.types import MeshQueryPoint as MeshQueryPoint
+from warp._src.types import MeshQueryRay as MeshQueryRay
+
+from warp._src.types import vector as vec
+from warp._src.types import matrix as mat
+
+from warp._src.types import matrix_from_cols as matrix_from_cols
+from warp._src.types import matrix_from_rows as matrix_from_rows
+
+from warp._src.types import dtype_from_numpy as dtype_from_numpy
+from warp._src.types import dtype_to_numpy as dtype_to_numpy
+
+from warp._src.types import from_ipc_handle as from_ipc_handle
+
+from warp._src.context import init as init
+from warp._src.context import func as func
+from warp._src.context import func_grad as func_grad
+from warp._src.context import func_replay as func_replay
+from warp._src.context import func_native as func_native
+from warp._src.context import kernel as kernel
+from warp._src.context import struct as struct
+from warp._src.context import overload as overload
+
+from warp._src.context import is_cpu_available as is_cpu_available
+from warp._src.context import is_cuda_available as is_cuda_available
+from warp._src.context import is_device_available as is_device_available
+from warp._src.context import get_cuda_supported_archs as get_cuda_supported_archs
+from warp._src.context import get_devices as get_devices
+from warp._src.context import get_preferred_device as get_preferred_device
+from warp._src.context import get_cuda_devices as get_cuda_devices
+from warp._src.context import get_cuda_device_count as get_cuda_device_count
+from warp._src.context import get_cuda_device as get_cuda_device
+from warp._src.context import map_cuda_device as map_cuda_device
+from warp._src.context import unmap_cuda_device as unmap_cuda_device
+from warp._src.context import get_device as get_device
+from warp._src.context import set_device as set_device
+from warp._src.context import synchronize_device as synchronize_device
+
+from warp._src.context import zeros as zeros
+from warp._src.context import zeros_like as zeros_like
+from warp._src.context import ones as ones
+from warp._src.context import ones_like as ones_like
+from warp._src.context import full as full
+from warp._src.context import full_like as full_like
+from warp._src.context import clone as clone
+from warp._src.context import empty as empty
+from warp._src.context import empty_like as empty_like
+from warp._src.context import copy as copy
+from warp._src.context import from_numpy as from_numpy
+
+from warp._src.context import launch as launch
+from warp._src.context import launch_tiled as launch_tiled
+from warp._src.context import synchronize as synchronize
+from warp._src.context import compile_aot_module as compile_aot_module
+from warp._src.context import force_load as force_load
+from warp._src.context import load_module as load_module
+from warp._src.context import load_aot_module as load_aot_module
+from warp._src.context import event_from_ipc_handle as event_from_ipc_handle
+
+from warp._src.context import set_module_options as set_module_options
+from warp._src.context import get_module_options as get_module_options
+from warp._src.context import get_module as get_module
+
+from warp._src.context import capture_begin as capture_begin
+from warp._src.context import capture_end as capture_end
+from warp._src.context import capture_launch as capture_launch
+from warp._src.context import capture_if as capture_if
+from warp._src.context import capture_while as capture_while
+from warp._src.context import capture_debug_dot_print as capture_debug_dot_print
+
+from warp._src.context import Kernel as Kernel
+from warp._src.context import Function as Function
+from warp._src.context import Launch as Launch
+
+from warp._src.context import Stream as Stream
+from warp._src.context import get_stream as get_stream
+from warp._src.context import set_stream as set_stream
+from warp._src.context import wait_stream as wait_stream
+from warp._src.context import synchronize_stream as synchronize_stream
+
+from warp._src.context import Event as Event
+from warp._src.context import record_event as record_event
+from warp._src.context import wait_event as wait_event
+from warp._src.context import synchronize_event as synchronize_event
+from warp._src.context import get_event_elapsed_time as get_event_elapsed_time
+
+from warp._src.context import RegisteredGLBuffer as RegisteredGLBuffer
+
+from warp._src.context import is_mempool_supported as is_mempool_supported
+from warp._src.context import is_mempool_enabled as is_mempool_enabled
+from warp._src.context import set_mempool_enabled as set_mempool_enabled
+
+from warp._src.context import set_mempool_release_threshold as set_mempool_release_threshold
+from warp._src.context import get_mempool_release_threshold as get_mempool_release_threshold
+from warp._src.context import get_mempool_used_mem_current as get_mempool_used_mem_current
+from warp._src.context import get_mempool_used_mem_high as get_mempool_used_mem_high
+
+from warp._src.context import is_mempool_access_supported as is_mempool_access_supported
+from warp._src.context import is_mempool_access_enabled as is_mempool_access_enabled
+from warp._src.context import set_mempool_access_enabled as set_mempool_access_enabled
+
+from warp._src.context import is_peer_access_supported as is_peer_access_supported
+from warp._src.context import is_peer_access_enabled as is_peer_access_enabled
+from warp._src.context import set_peer_access_enabled as set_peer_access_enabled
+
+from warp._src.tape import Tape as Tape
+
+from warp._src.utils import ScopedTimer as ScopedTimer
+from warp._src.utils import ScopedDevice as ScopedDevice
+from warp._src.utils import ScopedStream as ScopedStream
+from warp._src.utils import ScopedMempool as ScopedMempool
+from warp._src.utils import ScopedMempoolAccess as ScopedMempoolAccess
+from warp._src.utils import ScopedPeerAccess as ScopedPeerAccess
+from warp._src.utils import ScopedCapture as ScopedCapture
+
+from warp._src.utils import transform_expand as transform_expand
+from warp._src.utils import quat_between_vectors as quat_between_vectors
+
+from warp._src.utils import TimingResult as TimingResult
+from warp._src.utils import timing_begin as timing_begin
+from warp._src.utils import timing_end as timing_end
+from warp._src.utils import timing_print as timing_print
+
+from warp._src.utils import TIMING_KERNEL as TIMING_KERNEL
+from warp._src.utils import TIMING_KERNEL_BUILTIN as TIMING_KERNEL_BUILTIN
+from warp._src.utils import TIMING_MEMCPY as TIMING_MEMCPY
+from warp._src.utils import TIMING_MEMSET as TIMING_MEMSET
+from warp._src.utils import TIMING_GRAPH as TIMING_GRAPH
+from warp._src.utils import TIMING_ALL as TIMING_ALL
+
+from warp._src.utils import map as map
+
+from warp._src.marching_cubes import MarchingCubes as MarchingCubes
+
+from warp._src.torch import from_torch as from_torch
+from warp._src.torch import to_torch as to_torch
+from warp._src.torch import dtype_from_torch as dtype_from_torch
+from warp._src.torch import dtype_to_torch as dtype_to_torch
+from warp._src.torch import device_from_torch as device_from_torch
+from warp._src.torch import device_to_torch as device_to_torch
+from warp._src.torch import stream_from_torch as stream_from_torch
+from warp._src.torch import stream_to_torch as stream_to_torch
+
+from warp._src.jax import from_jax as from_jax
+from warp._src.jax import to_jax as to_jax
+from warp._src.jax import dtype_from_jax as dtype_from_jax
+from warp._src.jax import dtype_to_jax as dtype_to_jax
+from warp._src.jax import device_from_jax as device_from_jax
+from warp._src.jax import device_to_jax as device_to_jax
+
+from warp._src.dlpack import from_dlpack as from_dlpack
+from warp._src.dlpack import to_dlpack as to_dlpack
+
+from warp._src.paddle import from_paddle as from_paddle
+from warp._src.paddle import to_paddle as to_paddle
+from warp._src.paddle import dtype_from_paddle as dtype_from_paddle
+from warp._src.paddle import dtype_to_paddle as dtype_to_paddle
+from warp._src.paddle import device_from_paddle as device_from_paddle
+from warp._src.paddle import device_to_paddle as device_to_paddle
+from warp._src.paddle import stream_from_paddle as stream_from_paddle
+
+from warp._src.build import clear_kernel_cache as clear_kernel_cache
+from warp._src.build import clear_lto_cache as clear_lto_cache
+
+from warp._src.builtins import static as static
+
+from warp._src.constants import *
+
+from warp._src.math import *
+
+from warp._src import builtins as builtins
+from warp._src import config as config
 
 __version__ = config.version
 
+from . import build as build
+from . import codegen as codegen
+from . import constants as constants
+from . import context as context
+from . import dlpack as dlpack
+from . import fabric as fabric
+from . import jax as jax
+from . import marching_cubes as marching_cubes
+from . import math as math
+from . import paddle as paddle
+from . import sparse as sparse
+from . import tape as tape
+from . import torch as torch
+from . import types as types
+from . import utils as utils
+
+class vec2h:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized vector."""
+        ...
+
+    @over
+    def __init__(self, other: vec2h) -> None:
+        """Construct a vector by copy."""
+        ...
+
+    @over
+    def __init__(self, x: float16, y: float16) -> None:
+        """Construct a vector from its component values."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[float16]) -> None:
+        """Construct a vector from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: float16) -> None:
+        """Construct a vector filled with a value."""
+        ...
+
+class vec2f:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized vector."""
+        ...
+
+    @over
+    def __init__(self, other: vec2f) -> None:
+        """Construct a vector by copy."""
+        ...
+
+    @over
+    def __init__(self, x: float32, y: float32) -> None:
+        """Construct a vector from its component values."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[float32]) -> None:
+        """Construct a vector from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: float32) -> None:
+        """Construct a vector filled with a value."""
+        ...
+
+class vec2d:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized vector."""
+        ...
+
+    @over
+    def __init__(self, other: vec2d) -> None:
+        """Construct a vector by copy."""
+        ...
+
+    @over
+    def __init__(self, x: float64, y: float64) -> None:
+        """Construct a vector from its component values."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[float64]) -> None:
+        """Construct a vector from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: float64) -> None:
+        """Construct a vector filled with a value."""
+        ...
+
+class vec2b:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized vector."""
+        ...
+
+    @over
+    def __init__(self, other: vec2b) -> None:
+        """Construct a vector by copy."""
+        ...
+
+    @over
+    def __init__(self, x: int8, y: int8) -> None:
+        """Construct a vector from its component values."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[int8]) -> None:
+        """Construct a vector from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: int8) -> None:
+        """Construct a vector filled with a value."""
+        ...
+
+class vec2ub:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized vector."""
+        ...
+
+    @over
+    def __init__(self, other: vec2ub) -> None:
+        """Construct a vector by copy."""
+        ...
+
+    @over
+    def __init__(self, x: uint8, y: uint8) -> None:
+        """Construct a vector from its component values."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[uint8]) -> None:
+        """Construct a vector from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: uint8) -> None:
+        """Construct a vector filled with a value."""
+        ...
+
+class vec2s:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized vector."""
+        ...
+
+    @over
+    def __init__(self, other: vec2s) -> None:
+        """Construct a vector by copy."""
+        ...
+
+    @over
+    def __init__(self, x: int16, y: int16) -> None:
+        """Construct a vector from its component values."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[int16]) -> None:
+        """Construct a vector from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: int16) -> None:
+        """Construct a vector filled with a value."""
+        ...
+
+class vec2us:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized vector."""
+        ...
+
+    @over
+    def __init__(self, other: vec2us) -> None:
+        """Construct a vector by copy."""
+        ...
+
+    @over
+    def __init__(self, x: uint16, y: uint16) -> None:
+        """Construct a vector from its component values."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[uint16]) -> None:
+        """Construct a vector from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: uint16) -> None:
+        """Construct a vector filled with a value."""
+        ...
+
+class vec2i:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized vector."""
+        ...
+
+    @over
+    def __init__(self, other: vec2i) -> None:
+        """Construct a vector by copy."""
+        ...
+
+    @over
+    def __init__(self, x: int32, y: int32) -> None:
+        """Construct a vector from its component values."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[int32]) -> None:
+        """Construct a vector from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: int32) -> None:
+        """Construct a vector filled with a value."""
+        ...
+
+class vec2ui:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized vector."""
+        ...
+
+    @over
+    def __init__(self, other: vec2ui) -> None:
+        """Construct a vector by copy."""
+        ...
+
+    @over
+    def __init__(self, x: uint32, y: uint32) -> None:
+        """Construct a vector from its component values."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[uint32]) -> None:
+        """Construct a vector from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: uint32) -> None:
+        """Construct a vector filled with a value."""
+        ...
+
+class vec2l:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized vector."""
+        ...
+
+    @over
+    def __init__(self, other: vec2l) -> None:
+        """Construct a vector by copy."""
+        ...
+
+    @over
+    def __init__(self, x: int64, y: int64) -> None:
+        """Construct a vector from its component values."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[int64]) -> None:
+        """Construct a vector from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: int64) -> None:
+        """Construct a vector filled with a value."""
+        ...
+
+class vec2ul:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized vector."""
+        ...
+
+    @over
+    def __init__(self, other: vec2ul) -> None:
+        """Construct a vector by copy."""
+        ...
+
+    @over
+    def __init__(self, x: uint64, y: uint64) -> None:
+        """Construct a vector from its component values."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[uint64]) -> None:
+        """Construct a vector from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: uint64) -> None:
+        """Construct a vector filled with a value."""
+        ...
+
+vec2 = vec2f
+
+class vec3h:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized vector."""
+        ...
+
+    @over
+    def __init__(self, other: vec3h) -> None:
+        """Construct a vector by copy."""
+        ...
+
+    @over
+    def __init__(self, x: float16, y: float16, z: float16) -> None:
+        """Construct a vector from its component values."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[float16]) -> None:
+        """Construct a vector from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: float16) -> None:
+        """Construct a vector filled with a value."""
+        ...
+
+class vec3f:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized vector."""
+        ...
+
+    @over
+    def __init__(self, other: vec3f) -> None:
+        """Construct a vector by copy."""
+        ...
+
+    @over
+    def __init__(self, x: float32, y: float32, z: float32) -> None:
+        """Construct a vector from its component values."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[float32]) -> None:
+        """Construct a vector from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: float32) -> None:
+        """Construct a vector filled with a value."""
+        ...
+
+class vec3d:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized vector."""
+        ...
+
+    @over
+    def __init__(self, other: vec3d) -> None:
+        """Construct a vector by copy."""
+        ...
+
+    @over
+    def __init__(self, x: float64, y: float64, z: float64) -> None:
+        """Construct a vector from its component values."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[float64]) -> None:
+        """Construct a vector from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: float64) -> None:
+        """Construct a vector filled with a value."""
+        ...
+
+class vec3b:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized vector."""
+        ...
+
+    @over
+    def __init__(self, other: vec3b) -> None:
+        """Construct a vector by copy."""
+        ...
+
+    @over
+    def __init__(self, x: int8, y: int8, z: int8) -> None:
+        """Construct a vector from its component values."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[int8]) -> None:
+        """Construct a vector from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: int8) -> None:
+        """Construct a vector filled with a value."""
+        ...
+
+class vec3ub:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized vector."""
+        ...
+
+    @over
+    def __init__(self, other: vec3ub) -> None:
+        """Construct a vector by copy."""
+        ...
+
+    @over
+    def __init__(self, x: uint8, y: uint8, z: uint8) -> None:
+        """Construct a vector from its component values."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[uint8]) -> None:
+        """Construct a vector from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: uint8) -> None:
+        """Construct a vector filled with a value."""
+        ...
+
+class vec3s:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized vector."""
+        ...
+
+    @over
+    def __init__(self, other: vec3s) -> None:
+        """Construct a vector by copy."""
+        ...
+
+    @over
+    def __init__(self, x: int16, y: int16, z: int16) -> None:
+        """Construct a vector from its component values."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[int16]) -> None:
+        """Construct a vector from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: int16) -> None:
+        """Construct a vector filled with a value."""
+        ...
+
+class vec3us:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized vector."""
+        ...
+
+    @over
+    def __init__(self, other: vec3us) -> None:
+        """Construct a vector by copy."""
+        ...
+
+    @over
+    def __init__(self, x: uint16, y: uint16, z: uint16) -> None:
+        """Construct a vector from its component values."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[uint16]) -> None:
+        """Construct a vector from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: uint16) -> None:
+        """Construct a vector filled with a value."""
+        ...
+
+class vec3i:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized vector."""
+        ...
+
+    @over
+    def __init__(self, other: vec3i) -> None:
+        """Construct a vector by copy."""
+        ...
+
+    @over
+    def __init__(self, x: int32, y: int32, z: int32) -> None:
+        """Construct a vector from its component values."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[int32]) -> None:
+        """Construct a vector from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: int32) -> None:
+        """Construct a vector filled with a value."""
+        ...
+
+class vec3ui:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized vector."""
+        ...
+
+    @over
+    def __init__(self, other: vec3ui) -> None:
+        """Construct a vector by copy."""
+        ...
+
+    @over
+    def __init__(self, x: uint32, y: uint32, z: uint32) -> None:
+        """Construct a vector from its component values."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[uint32]) -> None:
+        """Construct a vector from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: uint32) -> None:
+        """Construct a vector filled with a value."""
+        ...
+
+class vec3l:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized vector."""
+        ...
+
+    @over
+    def __init__(self, other: vec3l) -> None:
+        """Construct a vector by copy."""
+        ...
+
+    @over
+    def __init__(self, x: int64, y: int64, z: int64) -> None:
+        """Construct a vector from its component values."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[int64]) -> None:
+        """Construct a vector from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: int64) -> None:
+        """Construct a vector filled with a value."""
+        ...
+
+class vec3ul:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized vector."""
+        ...
+
+    @over
+    def __init__(self, other: vec3ul) -> None:
+        """Construct a vector by copy."""
+        ...
+
+    @over
+    def __init__(self, x: uint64, y: uint64, z: uint64) -> None:
+        """Construct a vector from its component values."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[uint64]) -> None:
+        """Construct a vector from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: uint64) -> None:
+        """Construct a vector filled with a value."""
+        ...
+
+vec3 = vec3f
+
+class vec4h:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized vector."""
+        ...
+
+    @over
+    def __init__(self, other: vec4h) -> None:
+        """Construct a vector by copy."""
+        ...
+
+    @over
+    def __init__(self, x: float16, y: float16, z: float16, w: float16) -> None:
+        """Construct a vector from its component values."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[float16]) -> None:
+        """Construct a vector from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: float16) -> None:
+        """Construct a vector filled with a value."""
+        ...
+
+class vec4f:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized vector."""
+        ...
+
+    @over
+    def __init__(self, other: vec4f) -> None:
+        """Construct a vector by copy."""
+        ...
+
+    @over
+    def __init__(self, x: float32, y: float32, z: float32, w: float32) -> None:
+        """Construct a vector from its component values."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[float32]) -> None:
+        """Construct a vector from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: float32) -> None:
+        """Construct a vector filled with a value."""
+        ...
+
+class vec4d:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized vector."""
+        ...
+
+    @over
+    def __init__(self, other: vec4d) -> None:
+        """Construct a vector by copy."""
+        ...
+
+    @over
+    def __init__(self, x: float64, y: float64, z: float64, w: float64) -> None:
+        """Construct a vector from its component values."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[float64]) -> None:
+        """Construct a vector from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: float64) -> None:
+        """Construct a vector filled with a value."""
+        ...
+
+class vec4b:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized vector."""
+        ...
+
+    @over
+    def __init__(self, other: vec4b) -> None:
+        """Construct a vector by copy."""
+        ...
+
+    @over
+    def __init__(self, x: int8, y: int8, z: int8, w: int8) -> None:
+        """Construct a vector from its component values."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[int8]) -> None:
+        """Construct a vector from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: int8) -> None:
+        """Construct a vector filled with a value."""
+        ...
+
+class vec4ub:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized vector."""
+        ...
+
+    @over
+    def __init__(self, other: vec4ub) -> None:
+        """Construct a vector by copy."""
+        ...
+
+    @over
+    def __init__(self, x: uint8, y: uint8, z: uint8, w: uint8) -> None:
+        """Construct a vector from its component values."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[uint8]) -> None:
+        """Construct a vector from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: uint8) -> None:
+        """Construct a vector filled with a value."""
+        ...
+
+class vec4s:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized vector."""
+        ...
+
+    @over
+    def __init__(self, other: vec4s) -> None:
+        """Construct a vector by copy."""
+        ...
+
+    @over
+    def __init__(self, x: int16, y: int16, z: int16, w: int16) -> None:
+        """Construct a vector from its component values."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[int16]) -> None:
+        """Construct a vector from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: int16) -> None:
+        """Construct a vector filled with a value."""
+        ...
+
+class vec4us:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized vector."""
+        ...
+
+    @over
+    def __init__(self, other: vec4us) -> None:
+        """Construct a vector by copy."""
+        ...
+
+    @over
+    def __init__(self, x: uint16, y: uint16, z: uint16, w: uint16) -> None:
+        """Construct a vector from its component values."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[uint16]) -> None:
+        """Construct a vector from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: uint16) -> None:
+        """Construct a vector filled with a value."""
+        ...
+
+class vec4i:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized vector."""
+        ...
+
+    @over
+    def __init__(self, other: vec4i) -> None:
+        """Construct a vector by copy."""
+        ...
+
+    @over
+    def __init__(self, x: int32, y: int32, z: int32, w: int32) -> None:
+        """Construct a vector from its component values."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[int32]) -> None:
+        """Construct a vector from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: int32) -> None:
+        """Construct a vector filled with a value."""
+        ...
+
+class vec4ui:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized vector."""
+        ...
+
+    @over
+    def __init__(self, other: vec4ui) -> None:
+        """Construct a vector by copy."""
+        ...
+
+    @over
+    def __init__(self, x: uint32, y: uint32, z: uint32, w: uint32) -> None:
+        """Construct a vector from its component values."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[uint32]) -> None:
+        """Construct a vector from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: uint32) -> None:
+        """Construct a vector filled with a value."""
+        ...
+
+class vec4l:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized vector."""
+        ...
+
+    @over
+    def __init__(self, other: vec4l) -> None:
+        """Construct a vector by copy."""
+        ...
+
+    @over
+    def __init__(self, x: int64, y: int64, z: int64, w: int64) -> None:
+        """Construct a vector from its component values."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[int64]) -> None:
+        """Construct a vector from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: int64) -> None:
+        """Construct a vector filled with a value."""
+        ...
+
+class vec4ul:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized vector."""
+        ...
+
+    @over
+    def __init__(self, other: vec4ul) -> None:
+        """Construct a vector by copy."""
+        ...
+
+    @over
+    def __init__(self, x: uint64, y: uint64, z: uint64, w: uint64) -> None:
+        """Construct a vector from its component values."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[uint64]) -> None:
+        """Construct a vector from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: uint64) -> None:
+        """Construct a vector filled with a value."""
+        ...
+
+vec4 = vec4f
+
+class mat22h:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized matrix."""
+        ...
+
+    @over
+    def __init__(self, other: mat22h) -> None:
+        """Construct a matrix by copy."""
+        ...
+
+    @over
+    def __init__(self, m00: float16, m01: float16, m10: float16, m11: float16) -> None:
+        """Construct a matrix from its component values."""
+        ...
+
+    @over
+    def __init__(self, v0: vec2h, v1: vec2h) -> None:
+        """Construct a matrix from its row vectors."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[float16]) -> None:
+        """Construct a matrix from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: float16) -> None:
+        """Construct a matrix filled with a value."""
+        ...
+
+class mat22f:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized matrix."""
+        ...
+
+    @over
+    def __init__(self, other: mat22f) -> None:
+        """Construct a matrix by copy."""
+        ...
+
+    @over
+    def __init__(self, m00: float32, m01: float32, m10: float32, m11: float32) -> None:
+        """Construct a matrix from its component values."""
+        ...
+
+    @over
+    def __init__(self, v0: vec2f, v1: vec2f) -> None:
+        """Construct a matrix from its row vectors."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[float32]) -> None:
+        """Construct a matrix from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: float32) -> None:
+        """Construct a matrix filled with a value."""
+        ...
+
+class mat22d:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized matrix."""
+        ...
+
+    @over
+    def __init__(self, other: mat22d) -> None:
+        """Construct a matrix by copy."""
+        ...
+
+    @over
+    def __init__(self, m00: float64, m01: float64, m10: float64, m11: float64) -> None:
+        """Construct a matrix from its component values."""
+        ...
+
+    @over
+    def __init__(self, v0: vec2d, v1: vec2d) -> None:
+        """Construct a matrix from its row vectors."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[float64]) -> None:
+        """Construct a matrix from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: float64) -> None:
+        """Construct a matrix filled with a value."""
+        ...
+
+mat22 = mat22f
+
+class mat33h:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized matrix."""
+        ...
+
+    @over
+    def __init__(self, other: mat33h) -> None:
+        """Construct a matrix by copy."""
+        ...
+
+    @over
+    def __init__(
+        self,
+        m00: float16,
+        m01: float16,
+        m02: float16,
+        m10: float16,
+        m11: float16,
+        m12: float16,
+        m20: float16,
+        m21: float16,
+        m22: float16,
+    ) -> None:
+        """Construct a matrix from its component values."""
+        ...
+
+    @over
+    def __init__(self, v0: vec3h, v1: vec3h, v2: vec3h) -> None:
+        """Construct a matrix from its row vectors."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[float16]) -> None:
+        """Construct a matrix from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: float16) -> None:
+        """Construct a matrix filled with a value."""
+        ...
+
+class mat33f:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized matrix."""
+        ...
+
+    @over
+    def __init__(self, other: mat33f) -> None:
+        """Construct a matrix by copy."""
+        ...
+
+    @over
+    def __init__(
+        self,
+        m00: float32,
+        m01: float32,
+        m02: float32,
+        m10: float32,
+        m11: float32,
+        m12: float32,
+        m20: float32,
+        m21: float32,
+        m22: float32,
+    ) -> None:
+        """Construct a matrix from its component values."""
+        ...
+
+    @over
+    def __init__(self, v0: vec3f, v1: vec3f, v2: vec3f) -> None:
+        """Construct a matrix from its row vectors."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[float32]) -> None:
+        """Construct a matrix from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: float32) -> None:
+        """Construct a matrix filled with a value."""
+        ...
+
+class mat33d:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized matrix."""
+        ...
+
+    @over
+    def __init__(self, other: mat33d) -> None:
+        """Construct a matrix by copy."""
+        ...
+
+    @over
+    def __init__(
+        self,
+        m00: float64,
+        m01: float64,
+        m02: float64,
+        m10: float64,
+        m11: float64,
+        m12: float64,
+        m20: float64,
+        m21: float64,
+        m22: float64,
+    ) -> None:
+        """Construct a matrix from its component values."""
+        ...
+
+    @over
+    def __init__(self, v0: vec3d, v1: vec3d, v2: vec3d) -> None:
+        """Construct a matrix from its row vectors."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[float64]) -> None:
+        """Construct a matrix from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: float64) -> None:
+        """Construct a matrix filled with a value."""
+        ...
+
+mat33 = mat33f
+
+class mat44h:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized matrix."""
+        ...
+
+    @over
+    def __init__(self, other: mat44h) -> None:
+        """Construct a matrix by copy."""
+        ...
+
+    @over
+    def __init__(
+        self,
+        m00: float16,
+        m01: float16,
+        m02: float16,
+        m03: float16,
+        m10: float16,
+        m11: float16,
+        m12: float16,
+        m13: float16,
+        m20: float16,
+        m21: float16,
+        m22: float16,
+        m23: float16,
+        m30: float16,
+        m31: float16,
+        m32: float16,
+        m33: float16,
+    ) -> None:
+        """Construct a matrix from its component values."""
+        ...
+
+    @over
+    def __init__(self, v0: vec4h, v1: vec4h, v2: vec4h, v3: vec4h) -> None:
+        """Construct a matrix from its row vectors."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[float16]) -> None:
+        """Construct a matrix from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: float16) -> None:
+        """Construct a matrix filled with a value."""
+        ...
+
+class mat44f:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized matrix."""
+        ...
+
+    @over
+    def __init__(self, other: mat44f) -> None:
+        """Construct a matrix by copy."""
+        ...
+
+    @over
+    def __init__(
+        self,
+        m00: float32,
+        m01: float32,
+        m02: float32,
+        m03: float32,
+        m10: float32,
+        m11: float32,
+        m12: float32,
+        m13: float32,
+        m20: float32,
+        m21: float32,
+        m22: float32,
+        m23: float32,
+        m30: float32,
+        m31: float32,
+        m32: float32,
+        m33: float32,
+    ) -> None:
+        """Construct a matrix from its component values."""
+        ...
+
+    @over
+    def __init__(self, v0: vec4f, v1: vec4f, v2: vec4f, v3: vec4f) -> None:
+        """Construct a matrix from its row vectors."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[float32]) -> None:
+        """Construct a matrix from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: float32) -> None:
+        """Construct a matrix filled with a value."""
+        ...
+
+class mat44d:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized matrix."""
+        ...
+
+    @over
+    def __init__(self, other: mat44d) -> None:
+        """Construct a matrix by copy."""
+        ...
+
+    @over
+    def __init__(
+        self,
+        m00: float64,
+        m01: float64,
+        m02: float64,
+        m03: float64,
+        m10: float64,
+        m11: float64,
+        m12: float64,
+        m13: float64,
+        m20: float64,
+        m21: float64,
+        m22: float64,
+        m23: float64,
+        m30: float64,
+        m31: float64,
+        m32: float64,
+        m33: float64,
+    ) -> None:
+        """Construct a matrix from its component values."""
+        ...
+
+    @over
+    def __init__(self, v0: vec4d, v1: vec4d, v2: vec4d, v3: vec4d) -> None:
+        """Construct a matrix from its row vectors."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[float64]) -> None:
+        """Construct a matrix from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: float64) -> None:
+        """Construct a matrix filled with a value."""
+        ...
+
+mat44 = mat44f
+
+class quath:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized quaternion."""
+        ...
+
+    @over
+    def __init__(self, other: quath) -> None:
+        """Construct a quaternion by copy."""
+        ...
+
+    @over
+    def __init__(self, x: float16, y: float16, z: float16, w: float16) -> None:
+        """Construct a quaternion from its component values."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[float16]) -> None:
+        """Construct a quaternion from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: float16) -> None:
+        """Construct a quaternion filled with a value."""
+        ...
+
+class quatf:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized quaternion."""
+        ...
+
+    @over
+    def __init__(self, other: quatf) -> None:
+        """Construct a quaternion by copy."""
+        ...
+
+    @over
+    def __init__(self, x: float32, y: float32, z: float32, w: float32) -> None:
+        """Construct a quaternion from its component values."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[float32]) -> None:
+        """Construct a quaternion from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: float32) -> None:
+        """Construct a quaternion filled with a value."""
+        ...
+
+class quatd:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized quaternion."""
+        ...
+
+    @over
+    def __init__(self, other: quatd) -> None:
+        """Construct a quaternion by copy."""
+        ...
+
+    @over
+    def __init__(self, x: float64, y: float64, z: float64, w: float64) -> None:
+        """Construct a quaternion from its component values."""
+        ...
+
+    @over
+    def __init__(self, args: Sequence[float64]) -> None:
+        """Construct a quaternion from a sequence of values."""
+        ...
+
+    @over
+    def __init__(self, value: float64) -> None:
+        """Construct a quaternion filled with a value."""
+        ...
+
+quat = quatf
+
+class transformh:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized transformation."""
+        ...
+
+    @over
+    def __init__(self, other: transformh) -> None:
+        """Construct a transformation by copy."""
+        ...
+
+    @over
+    def __init__(self, p: vec3h, q: quath) -> None:
+        """Construct a transformation from its p and q components."""
+        ...
+
+    @over
+    def __init__(
+        self, px: float16, py: float16, pz: float16, qx: float16, qy: float16, qz: float16, qw: float16
+    ) -> None:
+        """Construct a transformation from its component values."""
+        ...
+
+    @over
+    def __init__(self, p: Sequence[float16], q: Sequence[float16]) -> None:
+        """Construct a transformation from two sequences of values."""
+        ...
+
+    @over
+    def __init__(self, value: float16) -> None:
+        """Construct a transformation filled with a value."""
+        ...
+
+class transformf:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized transformation."""
+        ...
+
+    @over
+    def __init__(self, other: transformf) -> None:
+        """Construct a transformation by copy."""
+        ...
+
+    @over
+    def __init__(self, p: vec3f, q: quatf) -> None:
+        """Construct a transformation from its p and q components."""
+        ...
+
+    @over
+    def __init__(
+        self, px: float32, py: float32, pz: float32, qx: float32, qy: float32, qz: float32, qw: float32
+    ) -> None:
+        """Construct a transformation from its component values."""
+        ...
+
+    @over
+    def __init__(self, p: Sequence[float32], q: Sequence[float32]) -> None:
+        """Construct a transformation from two sequences of values."""
+        ...
+
+    @over
+    def __init__(self, value: float32) -> None:
+        """Construct a transformation filled with a value."""
+        ...
+
+class transformd:
+    @over
+    def __init__(self) -> None:
+        """Construct a zero-initialized transformation."""
+        ...
+
+    @over
+    def __init__(self, other: transformd) -> None:
+        """Construct a transformation by copy."""
+        ...
+
+    @over
+    def __init__(self, p: vec3d, q: quatd) -> None:
+        """Construct a transformation from its p and q components."""
+        ...
+
+    @over
+    def __init__(
+        self, px: float64, py: float64, pz: float64, qx: float64, qy: float64, qz: float64, qw: float64
+    ) -> None:
+        """Construct a transformation from its component values."""
+        ...
+
+    @over
+    def __init__(self, p: Sequence[float64], q: Sequence[float64]) -> None:
+        """Construct a transformation from two sequences of values."""
+        ...
+
+    @over
+    def __init__(self, value: float64) -> None:
+        """Construct a transformation filled with a value."""
+        ...
+
+transform = transformf
+
 @over
 def min(a: Scalar, b: Scalar) -> Scalar:
     """Return the minimum of two scalars."""
@@ -492,6 +1922,26 @@ def pow(x: Float, y: Float) -> Float:
     """Return the result of ``x`` raised to power of ``y``."""
     ...
 
+@over
+def erf(x: Float) -> Float:
+    """Return the error function of ``x``."""
+    ...
+
+@over
+def erfc(x: Float) -> Float:
+    """Return the complementary error function of ``x``."""
+    ...
+
+@over
+def erfinv(x: Float) -> Float:
+    """Return the inverse error function of ``x``."""
+    ...
+
+@over
+def erfcinv(x: Float) -> Float:
+    """Return the inverse complementary error function of ``x``."""
+    ...
+
 @over
 def round(x: Float) -> Float:
     """Return the nearest integer value to ``x``, rounding halfway cases away from zero.
@@ -747,8 +2197,10 @@ def matrix(pos: Vector[3, Float], rot: Quaternion[Float], scale: Vector[3, Float
     """Construct a 4x4 transformation matrix that applies the transformations as
     Translation(pos)*Rotation(rot)*Scaling(scale) when applied to column vectors, i.e.: y = (TRS)*x
 
-    .. warning::
-       This function has been deprecated in favor of :func:`warp.math.transform_compose()`.
+    .. versionremoved:: 1.10
+       This function has been removed in favor of :func:`warp.math.transform_compose()`.
+
+    .. deprecated:: 1.8
     """
     ...
 
@@ -1084,6 +2536,19 @@ def tile_ones(shape: Tuple[int, ...], dtype: Any, storage: str) -> Tile[Any, Tup
     """
     ...
 
+@over
+def tile_full(shape: Tuple[int, ...], value: Any, dtype: Any, storage: str) -> Tile[Any, Tuple[int, ...]]:
+    """Allocate a tile filled with the specified value.
+
+    :param shape: Shape of the output tile
+    :param value: Value to fill the tile with
+    :param dtype: Data type of output tile's elements
+    :param storage: The storage location for the tile: ``"register"`` for registers
+      (default) or ``"shared"`` for shared memory.
+    :returns: A tile filled with the specified value
+    """
+    ...
+
 @over
 def tile_arange(*args: Scalar, dtype: Scalar, storage: str) -> Tile[Scalar, Tuple[int]]:
     """Generate a tile of linearly spaced elements.
@@ -1458,6 +2923,37 @@ def tile_broadcast(a: Tile[Any, Tuple[int, ...]], shape: Tuple[int, ...]) -> Til
     """
     ...
 
+@over
+def tile_sum(a: Tile[Scalar, Tuple[int, ...]], axis: int32) -> Tile[Scalar, Tuple[int, ...]]:
+    """Cooperatively compute the sum of the tile elements across an axis of the tile using all threads in the block.
+
+    :param a: The input tile. Must reside in shared memory.
+    :param axis: The tile axis to compute the sum across. Must be a compile-time constant.
+    :returns: A tile with the same shape as the input tile less the axis dimension and the same data type as the input tile.
+
+    Example:
+
+    .. code-block:: python
+
+        @wp.kernel
+        def compute():
+            t = wp.tile_ones(dtype=float, shape=(8, 8))
+            s = wp.tile_sum(t, axis=0)
+
+            print(s)
+
+        wp.launch_tiled(compute, dim=[1], inputs=[], block_dim=64)
+
+    Prints:
+
+    .. code-block:: text
+
+        [8 8 8 8 8 8 8 8] = tile(shape=(8), storage=register)
+
+
+    """
+    ...
+
 @over
 def tile_sum(a: Tile[Scalar, Tuple[int, ...]]) -> Tile[Scalar, Tuple[1]]:
     """Cooperatively compute the sum of the tile elements using all threads in the block.
@@ -1674,6 +3170,53 @@ def tile_reduce(op: Callable, a: Tile[Scalar, Tuple[int, ...]]) -> Tile[Scalar,
     """
     ...
 
+@over
+def tile_reduce(op: Callable, a: Tile[Scalar, Tuple[int, ...]], axis: int32) -> Tile[Scalar, Tuple[int, ...]]:
+    """Apply a custom reduction operator across a tile axis.
+
+    This function cooperatively performs a reduction using the provided operator across an axis of the tile.
+
+    :param op: A callable function that accepts two arguments and returns one argument, may be a user function or builtin
+    :param a: The input tile, the operator (or one of its overloads) must be able to accept the tile's data type. Must reside in shared memory.
+    :param axis: The tile axis to perform the reduction across. Must be a compile-time constant.
+    :returns: A tile with the same shape as the input tile less the axis dimension and the same data type as the input tile.
+
+    Example:
+
+    .. code-block:: python
+
+        TILE_M = wp.constant(4)
+        TILE_N = wp.constant(2)
+
+        @wp.kernel
+        def compute(x: wp.array2d(dtype=float), y: wp.array(dtype=float)):
+            a = wp.tile_load(x, shape=(TILE_M, TILE_N))
+            b = wp.tile_reduce(wp.add, a, axis=1)
+            wp.tile_store(y, b)
+
+        arr = np.arange(TILE_M * TILE_N).reshape(TILE_M, TILE_N)
+
+        x = wp.array(arr, dtype=float)
+        y = wp.zeros(TILE_M, dtype=float)
+
+        wp.launch_tiled(compute, dim=[1], inputs=[x], outputs=[y], block_dim=32)
+
+        print(x.numpy())
+        print(y.numpy())
+
+    Prints:
+
+    .. code-block:: text
+
+        [[0. 1.]
+         [2. 3.]
+         [4. 5.]
+         [6. 7.]]
+        [ 1.  5.  9. 13.]
+
+    """
+    ...
+
 @over
 def tile_scan_inclusive(a: Tile[Scalar, Tuple[int, ...]]) -> Tile[Scalar, Tuple[int, ...]]:
     """Inclusive scan (prefix sum) across the tile.
@@ -1923,7 +3466,7 @@ def mesh_query_ray(id: uint64, start: vec3f, dir: vec3f, max_t: float32) -> Mesh
 def mesh_query_aabb(id: uint64, low: vec3f, high: vec3f) -> MeshQueryAABB:
     """Construct an axis-aligned bounding box query against a :class:`Mesh`.
 
-    This query can be used to iterate over all triangles inside a volume.
+    This query can be used to iterate over all bounding boxes of the triangles inside a volume.
 
     :param id: The mesh identifier
     :param low: The lower bound of the bounding box in mesh space
@@ -1933,7 +3476,7 @@ def mesh_query_aabb(id: uint64, low: vec3f, high: vec3f) -> MeshQueryAABB:
 
 @over
 def mesh_query_aabb_next(query: MeshQueryAABB, index: int32) -> bool:
-    """Move to the next triangle overlapping the query bounding box.
+    """Move to the next triangle whose bounding box overlaps the query bounding box.
 
     The index of the current face is stored in ``index``, returns ``False`` if there are no more overlapping triangles.
     """
@@ -1979,6 +3522,18 @@ def hash_grid_point_id(id: uint64, index: int32) -> int:
 def intersect_tri_tri(v0: vec3f, v1: vec3f, v2: vec3f, u0: vec3f, u1: vec3f, u2: vec3f) -> int:
     """Tests for intersection between two triangles (v0, v1, v2) and (u0, u1, u2) using Moller's method.
 
+    This function works with single precision, may return incorrect results in some case.
+
+    Returns > 0 if triangles intersect.
+    """
+    ...
+
+@over
+def intersect_tri_tri(v0: vec3d, v1: vec3d, v2: vec3d, u0: vec3d, u1: vec3d, u2: vec3d) -> int:
+    """Tests for intersection between two triangles (v0, v1, v2) and (u0, u1, u2) using Moller's method.
+
+    This function works with double precision, results are more accurate than the single precision version.
+
     Returns > 0 if triangles intersect.
     """
     ...
@@ -2407,9 +3962,11 @@ def block_dim() -> int:
 def select(cond: bool, value_if_false: Any, value_if_true: Any) -> Any:
     """Select between two arguments, if ``cond`` is ``False`` then return ``value_if_false``, otherwise return ``value_if_true``.
 
-    .. deprecated:: 1.7
+    .. versionremoved:: 1.10
          Use :func:`where` instead, which has the more intuitive argument order:
          ``where(cond, value_if_true, value_if_false)``.
+
+    .. deprecated:: 1.7
     """
     ...
 
@@ -2417,9 +3974,11 @@ def select(cond: bool, value_if_false: Any, value_if_true: Any) -> Any:
 def select(cond: int8, value_if_false: Any, value_if_true: Any) -> Any:
     """Select between two arguments, if ``cond`` is ``False`` then return ``value_if_false``, otherwise return ``value_if_true``.
 
-    .. deprecated:: 1.7
+    .. versionremoved:: 1.10
          Use :func:`where` instead, which has the more intuitive argument order:
          ``where(cond, value_if_true, value_if_false)``.
+
+    .. deprecated:: 1.7
     """
     ...
 
@@ -2427,9 +3986,11 @@ def select(cond: int8, value_if_false: Any, value_if_true: Any) -> Any:
 def select(cond: uint8, value_if_false: Any, value_if_true: Any) -> Any:
     """Select between two arguments, if ``cond`` is ``False`` then return ``value_if_false``, otherwise return ``value_if_true``.
 
-    .. deprecated:: 1.7
+    .. versionremoved:: 1.10
          Use :func:`where` instead, which has the more intuitive argument order:
          ``where(cond, value_if_true, value_if_false)``.
+
+    .. deprecated:: 1.7
     """
     ...
 
@@ -2437,9 +3998,11 @@ def select(cond: uint8, value_if_false: Any, value_if_true: Any) -> Any:
 def select(cond: int16, value_if_false: Any, value_if_true: Any) -> Any:
     """Select between two arguments, if ``cond`` is ``False`` then return ``value_if_false``, otherwise return ``value_if_true``.
 
-    .. deprecated:: 1.7
+    .. versionremoved:: 1.10
          Use :func:`where` instead, which has the more intuitive argument order:
          ``where(cond, value_if_true, value_if_false)``.
+
+    .. deprecated:: 1.7
     """
     ...
 
@@ -2447,9 +4010,11 @@ def select(cond: int16, value_if_false: Any, value_if_true: Any) -> Any:
 def select(cond: uint16, value_if_false: Any, value_if_true: Any) -> Any:
     """Select between two arguments, if ``cond`` is ``False`` then return ``value_if_false``, otherwise return ``value_if_true``.
 
-    .. deprecated:: 1.7
+    .. versionremoved:: 1.10
          Use :func:`where` instead, which has the more intuitive argument order:
          ``where(cond, value_if_true, value_if_false)``.
+
+    .. deprecated:: 1.7
     """
     ...
 
@@ -2457,9 +4022,11 @@ def select(cond: uint16, value_if_false: Any, value_if_true: Any) -> Any:
 def select(cond: int32, value_if_false: Any, value_if_true: Any) -> Any:
     """Select between two arguments, if ``cond`` is ``False`` then return ``value_if_false``, otherwise return ``value_if_true``.
 
-    .. deprecated:: 1.7
+    .. versionremoved:: 1.10
          Use :func:`where` instead, which has the more intuitive argument order:
          ``where(cond, value_if_true, value_if_false)``.
+
+    .. deprecated:: 1.7
     """
     ...
 
@@ -2467,9 +4034,11 @@ def select(cond: int32, value_if_false: Any, value_if_true: Any) -> Any:
 def select(cond: uint32, value_if_false: Any, value_if_true: Any) -> Any:
     """Select between two arguments, if ``cond`` is ``False`` then return ``value_if_false``, otherwise return ``value_if_true``.
 
-    .. deprecated:: 1.7
+    .. versionremoved:: 1.10
          Use :func:`where` instead, which has the more intuitive argument order:
          ``where(cond, value_if_true, value_if_false)``.
+
+    .. deprecated:: 1.7
     """
     ...
 
@@ -2477,9 +4046,11 @@ def select(cond: uint32, value_if_false: Any, value_if_true: Any) -> Any:
 def select(cond: int64, value_if_false: Any, value_if_true: Any) -> Any:
     """Select between two arguments, if ``cond`` is ``False`` then return ``value_if_false``, otherwise return ``value_if_true``.
 
-    .. deprecated:: 1.7
+    .. versionremoved:: 1.10
          Use :func:`where` instead, which has the more intuitive argument order:
          ``where(cond, value_if_true, value_if_false)``.
+
+    .. deprecated:: 1.7
     """
     ...
 
@@ -2487,9 +4058,11 @@ def select(cond: int64, value_if_false: Any, value_if_true: Any) -> Any:
 def select(cond: uint64, value_if_false: Any, value_if_true: Any) -> Any:
     """Select between two arguments, if ``cond`` is ``False`` then return ``value_if_false``, otherwise return ``value_if_true``.
 
-    .. deprecated:: 1.7
+    .. versionremoved:: 1.10
          Use :func:`where` instead, which has the more intuitive argument order:
          ``where(cond, value_if_true, value_if_false)``.
+
+    .. deprecated:: 1.7
     """
     ...
 
@@ -2497,9 +4070,11 @@ def select(cond: uint64, value_if_false: Any, value_if_true: Any) -> Any:
 def select(arr: Array[Any], value_if_false: Any, value_if_true: Any) -> Any:
     """Select between two arguments, if ``arr`` is null then return ``value_if_false``, otherwise return ``value_if_true``.
 
-    .. deprecated:: 1.7
+    .. versionremoved:: 1.10
          Use :func:`where` instead, which has the more intuitive argument order:
          ``where(arr, value_if_true, value_if_false)``.
+
+    .. deprecated:: 1.7
     """
     ...
 
@@ -2556,6 +4131,7 @@ def where(arr: Array[Any], value_if_true: Any, value_if_false: Any) -> Any:
 @over
 def atomic_add(arr: Array[Any], i: Int, value: Any) -> Any:
     """Atomically adds ``value`` onto ``arr[i]`` and returns the original value of ``arr[i]``.
+
     This function is automatically invoked when using the syntax ``arr[i] += value``.
     """
     ...
@@ -2563,6 +4139,7 @@ def atomic_add(arr: Array[Any], i: Int, value: Any) -> Any:
 @over
 def atomic_add(arr: Array[Any], i: Int, j: Int, value: Any) -> Any:
     """Atomically adds ``value`` onto ``arr[i,j]`` and returns the original value of ``arr[i,j]``.
+
     This function is automatically invoked when using the syntax ``arr[i,j] += value``.
     """
     ...
@@ -2570,6 +4147,7 @@ def atomic_add(arr: Array[Any], i: Int, j: Int, value: Any) -> Any:
 @over
 def atomic_add(arr: Array[Any], i: Int, j: Int, k: Int, value: Any) -> Any:
     """Atomically adds ``value`` onto ``arr[i,j,k]`` and returns the original value of ``arr[i,j,k]``.
+
     This function is automatically invoked when using the syntax ``arr[i,j,k] += value``.
     """
     ...
@@ -2577,6 +4155,7 @@ def atomic_add(arr: Array[Any], i: Int, j: Int, k: Int, value: Any) -> Any:
 @over
 def atomic_add(arr: Array[Any], i: Int, j: Int, k: Int, l: Int, value: Any) -> Any:
     """Atomically adds ``value`` onto ``arr[i,j,k,l]`` and returns the original value of ``arr[i,j,k,l]``.
+
     This function is automatically invoked when using the syntax ``arr[i,j,k,l] += value``.
     """
     ...
@@ -2584,6 +4163,7 @@ def atomic_add(arr: Array[Any], i: Int, j: Int, k: Int, l: Int, value: Any) -> A
 @over
 def atomic_add(arr: FabricArray[Any], i: Int, value: Any) -> Any:
     """Atomically adds ``value`` onto ``arr[i]`` and returns the original value of ``arr[i]``.
+
     This function is automatically invoked when using the syntax ``arr[i] += value``.
     """
     ...
@@ -2591,6 +4171,7 @@ def atomic_add(arr: FabricArray[Any], i: Int, value: Any) -> Any:
 @over
 def atomic_add(arr: FabricArray[Any], i: Int, j: Int, value: Any) -> Any:
     """Atomically adds ``value`` onto ``arr[i,j]`` and returns the original value of ``arr[i,j]``.
+
     This function is automatically invoked when using the syntax ``arr[i,j] += value``.
     """
     ...
@@ -2598,6 +4179,7 @@ def atomic_add(arr: FabricArray[Any], i: Int, j: Int, value: Any) -> Any:
 @over
 def atomic_add(arr: FabricArray[Any], i: Int, j: Int, k: Int, value: Any) -> Any:
     """Atomically adds ``value`` onto ``arr[i,j,k]`` and returns the original value of ``arr[i,j,k]``.
+
     This function is automatically invoked when using the syntax ``arr[i,j,k] += value``.
     """
     ...
@@ -2605,6 +4187,7 @@ def atomic_add(arr: FabricArray[Any], i: Int, j: Int, k: Int, value: Any) -> Any
 @over
 def atomic_add(arr: FabricArray[Any], i: Int, j: Int, k: Int, l: Int, value: Any) -> Any:
     """Atomically adds ``value`` onto ``arr[i,j,k,l]`` and returns the original value of ``arr[i,j,k,l]``.
+
     This function is automatically invoked when using the syntax ``arr[i,j,k,l] += value``.
     """
     ...
@@ -2612,6 +4195,7 @@ def atomic_add(arr: FabricArray[Any], i: Int, j: Int, k: Int, l: Int, value: Any
 @over
 def atomic_add(arr: IndexedFabricArray[Any], i: Int, value: Any) -> Any:
     """Atomically adds ``value`` onto ``arr[i]`` and returns the original value of ``arr[i]``.
+
     This function is automatically invoked when using the syntax ``arr[i] += value``.
     """
     ...
@@ -2619,6 +4203,7 @@ def atomic_add(arr: IndexedFabricArray[Any], i: Int, value: Any) -> Any:
 @over
 def atomic_add(arr: IndexedFabricArray[Any], i: Int, j: Int, value: Any) -> Any:
     """Atomically adds ``value`` onto ``arr[i,j]`` and returns the original value of ``arr[i,j]``.
+
     This function is automatically invoked when using the syntax ``arr[i,j] += value``.
     """
     ...
@@ -2626,6 +4211,7 @@ def atomic_add(arr: IndexedFabricArray[Any], i: Int, j: Int, value: Any) -> Any:
 @over
 def atomic_add(arr: IndexedFabricArray[Any], i: Int, j: Int, k: Int, value: Any) -> Any:
     """Atomically adds ``value`` onto ``arr[i,j,k]`` and returns the original value of ``arr[i,j,k]``.
+
     This function is automatically invoked when using the syntax ``arr[i,j,k] += value``.
     """
     ...
@@ -2633,6 +4219,7 @@ def atomic_add(arr: IndexedFabricArray[Any], i: Int, j: Int, k: Int, value: Any)
 @over
 def atomic_add(arr: IndexedFabricArray[Any], i: Int, j: Int, k: Int, l: Int, value: Any) -> Any:
     """Atomically adds ``value`` onto ``arr[i,j,k,l]`` and returns the original value of ``arr[i,j,k,l]``.
+
     This function is automatically invoked when using the syntax ``arr[i,j,k,l] += value``.
     """
     ...
@@ -2640,6 +4227,7 @@ def atomic_add(arr: IndexedFabricArray[Any], i: Int, j: Int, k: Int, l: Int, val
 @over
 def atomic_sub(arr: Array[Any], i: Int, value: Any) -> Any:
     """Atomically subtracts ``value`` onto ``arr[i]`` and returns the original value of ``arr[i]``.
+
     This function is automatically invoked when using the syntax ``arr[i] -= value``.
     """
     ...
@@ -2647,6 +4235,7 @@ def atomic_sub(arr: Array[Any], i: Int, value: Any) -> Any:
 @over
 def atomic_sub(arr: Array[Any], i: Int, j: Int, value: Any) -> Any:
     """Atomically subtracts ``value`` onto ``arr[i,j]`` and returns the original value of ``arr[i,j]``.
+
     This function is automatically invoked when using the syntax ``arr[i,j] -= value``.
     """
     ...
@@ -2654,6 +4243,7 @@ def atomic_sub(arr: Array[Any], i: Int, j: Int, value: Any) -> Any:
 @over
 def atomic_sub(arr: Array[Any], i: Int, j: Int, k: Int, value: Any) -> Any:
     """Atomically subtracts ``value`` onto ``arr[i,j,k]`` and returns the original value of ``arr[i,j,k]``.
+
     This function is automatically invoked when using the syntax ``arr[i,j,k] -= value``.
     """
     ...
@@ -2661,6 +4251,7 @@ def atomic_sub(arr: Array[Any], i: Int, j: Int, k: Int, value: Any) -> Any:
 @over
 def atomic_sub(arr: Array[Any], i: Int, j: Int, k: Int, l: Int, value: Any) -> Any:
     """Atomically subtracts ``value`` onto ``arr[i,j,k,l]`` and returns the original value of ``arr[i,j,k,l]``.
+
     This function is automatically invoked when using the syntax ``arr[i,j,k,l] -= value``.
     """
     ...
@@ -2668,6 +4259,7 @@ def atomic_sub(arr: Array[Any], i: Int, j: Int, k: Int, l: Int, value: Any) -> A
 @over
 def atomic_sub(arr: FabricArray[Any], i: Int, value: Any) -> Any:
     """Atomically subtracts ``value`` onto ``arr[i]`` and returns the original value of ``arr[i]``.
+
     This function is automatically invoked when using the syntax ``arr[i] -= value``.
     """
     ...
@@ -2675,6 +4267,7 @@ def atomic_sub(arr: FabricArray[Any], i: Int, value: Any) -> Any:
 @over
 def atomic_sub(arr: FabricArray[Any], i: Int, j: Int, value: Any) -> Any:
     """Atomically subtracts ``value`` onto ``arr[i,j]`` and returns the original value of ``arr[i,j]``.
+
     This function is automatically invoked when using the syntax ``arr[i,j] -= value``.
     """
     ...
@@ -2682,6 +4275,7 @@ def atomic_sub(arr: FabricArray[Any], i: Int, j: Int, value: Any) -> Any:
 @over
 def atomic_sub(arr: FabricArray[Any], i: Int, j: Int, k: Int, value: Any) -> Any:
     """Atomically subtracts ``value`` onto ``arr[i,j,k]`` and returns the original value of ``arr[i,j,k]``.
+
     This function is automatically invoked when using the syntax ``arr[i,j,k] -= value``.
     """
     ...
@@ -2689,6 +4283,7 @@ def atomic_sub(arr: FabricArray[Any], i: Int, j: Int, k: Int, value: Any) -> Any
 @over
 def atomic_sub(arr: FabricArray[Any], i: Int, j: Int, k: Int, l: Int, value: Any) -> Any:
     """Atomically subtracts ``value`` onto ``arr[i,j,k,l]`` and returns the original value of ``arr[i,j,k,l]``.
+
     This function is automatically invoked when using the syntax ``arr[i,j,k,l] -= value``.
     """
     ...
@@ -2696,6 +4291,7 @@ def atomic_sub(arr: FabricArray[Any], i: Int, j: Int, k: Int, l: Int, value: Any
 @over
 def atomic_sub(arr: IndexedFabricArray[Any], i: Int, value: Any) -> Any:
     """Atomically subtracts ``value`` onto ``arr[i]`` and returns the original value of ``arr[i]``.
+
     This function is automatically invoked when using the syntax ``arr[i] -= value``.
     """
     ...
@@ -2703,6 +4299,7 @@ def atomic_sub(arr: IndexedFabricArray[Any], i: Int, value: Any) -> Any:
 @over
 def atomic_sub(arr: IndexedFabricArray[Any], i: Int, j: Int, value: Any) -> Any:
     """Atomically subtracts ``value`` onto ``arr[i,j]`` and returns the original value of ``arr[i,j]``.
+
     This function is automatically invoked when using the syntax ``arr[i,j] -= value``.
     """
     ...
@@ -2710,6 +4307,7 @@ def atomic_sub(arr: IndexedFabricArray[Any], i: Int, j: Int, value: Any) -> Any:
 @over
 def atomic_sub(arr: IndexedFabricArray[Any], i: Int, j: Int, k: Int, value: Any) -> Any:
     """Atomically subtracts ``value`` onto ``arr[i,j,k]`` and returns the original value of ``arr[i,j,k]``.
+
     This function is automatically invoked when using the syntax ``arr[i,j,k] -= value``.
     """
     ...
@@ -2717,6 +4315,7 @@ def atomic_sub(arr: IndexedFabricArray[Any], i: Int, j: Int, k: Int, value: Any)
 @over
 def atomic_sub(arr: IndexedFabricArray[Any], i: Int, j: Int, k: Int, l: Int, value: Any) -> Any:
     """Atomically subtracts ``value`` onto ``arr[i,j,k,l]`` and returns the original value of ``arr[i,j,k,l]``.
+
     This function is automatically invoked when using the syntax ``arr[i,j,k,l] -= value``.
     """
     ...
@@ -3105,6 +4704,294 @@ def atomic_exch(arr: IndexedFabricArray[Any], i: Int, j: Int, k: Int, l: Int, va
     """
     ...
 
+@over
+def atomic_and(arr: Array[Any], i: Int, value: Any) -> Any:
+    """Atomically performs a bitwise AND between ``value`` and ``arr[i]``, atomically update the array, and return the old value.
+
+    This function is automatically invoked when using the syntax ``arr[i] &= value``.
+    """
+    ...
+
+@over
+def atomic_and(arr: Array[Any], i: Int, j: Int, value: Any) -> Any:
+    """Atomically performs a bitwise AND between ``value`` and ``arr[i,j]``, atomically update the array, and return the old value.
+
+    This function is automatically invoked when using the syntax ``arr[i,j] &= value``.
+    """
+    ...
+
+@over
+def atomic_and(arr: Array[Any], i: Int, j: Int, k: Int, value: Any) -> Any:
+    """Atomically performs a bitwise AND between ``value`` and ``arr[i,j,k]``, atomically update the array, and return the old value.
+
+    This function is automatically invoked when using the syntax ``arr[i,j,k] &= value``.
+    """
+    ...
+
+@over
+def atomic_and(arr: Array[Any], i: Int, j: Int, k: Int, l: Int, value: Any) -> Any:
+    """Atomically performs a bitwise AND between ``value`` and ``arr[i,j,k,l]``, atomically update the array, and return the old value.
+
+    This function is automatically invoked when using the syntax ``arr[i,j,k,l] &= value``.
+    """
+    ...
+
+@over
+def atomic_and(arr: FabricArray[Any], i: Int, value: Any) -> Any:
+    """Atomically performs a bitwise AND between ``value`` and ``arr[i]``, atomically update the array, and return the old value.
+
+    This function is automatically invoked when using the syntax ``arr[i] &= value``.
+    """
+    ...
+
+@over
+def atomic_and(arr: FabricArray[Any], i: Int, j: Int, value: Any) -> Any:
+    """Atomically performs a bitwise AND between ``value`` and ``arr[i,j]``, atomically update the array, and return the old value.
+
+    This function is automatically invoked when using the syntax ``arr[i,j] &= value``.
+    """
+    ...
+
+@over
+def atomic_and(arr: FabricArray[Any], i: Int, j: Int, k: Int, value: Any) -> Any:
+    """Atomically performs a bitwise AND between ``value`` and ``arr[i,j,k]``, atomically update the array, and return the old value.
+
+    This function is automatically invoked when using the syntax ``arr[i,j,k] &= value``.
+    """
+    ...
+
+@over
+def atomic_and(arr: FabricArray[Any], i: Int, j: Int, k: Int, l: Int, value: Any) -> Any:
+    """Atomically performs a bitwise AND between ``value`` and ``arr[i,j,k,l]``, atomically update the array, and return the old value.
+
+    This function is automatically invoked when using the syntax ``arr[i,j,k,l] &= value``.
+    """
+    ...
+
+@over
+def atomic_and(arr: IndexedFabricArray[Any], i: Int, value: Any) -> Any:
+    """Atomically performs a bitwise AND between ``value`` and ``arr[i]``, atomically update the array, and return the old value.
+
+    This function is automatically invoked when using the syntax ``arr[i] &= value``.
+    """
+    ...
+
+@over
+def atomic_and(arr: IndexedFabricArray[Any], i: Int, j: Int, value: Any) -> Any:
+    """Atomically performs a bitwise AND between ``value`` and ``arr[i,j]``, atomically update the array, and return the old value.
+
+    This function is automatically invoked when using the syntax ``arr[i,j] &= value``.
+    """
+    ...
+
+@over
+def atomic_and(arr: IndexedFabricArray[Any], i: Int, j: Int, k: Int, value: Any) -> Any:
+    """Atomically performs a bitwise AND between ``value`` and ``arr[i,j,k]``, atomically update the array, and return the old value.
+
+    This function is automatically invoked when using the syntax ``arr[i,j,k] &= value``.
+    """
+    ...
+
+@over
+def atomic_and(arr: IndexedFabricArray[Any], i: Int, j: Int, k: Int, l: Int, value: Any) -> Any:
+    """Atomically performs a bitwise AND between ``value`` and ``arr[i,j,k,l]``, atomically update the array, and return the old value.
+
+    This function is automatically invoked when using the syntax ``arr[i,j,k,l] &= value``.
+    """
+    ...
+
+@over
+def atomic_or(arr: Array[Any], i: Int, value: Any) -> Any:
+    """Atomically performs a bitwise OR between ``value`` and ``arr[i]``, atomically update the array, and return the old value.
+
+    This function is automatically invoked when using the syntax ``arr[i] |= value``.
+    """
+    ...
+
+@over
+def atomic_or(arr: Array[Any], i: Int, j: Int, value: Any) -> Any:
+    """Atomically performs a bitwise OR between ``value`` and ``arr[i,j]``, atomically update the array, and return the old value.
+
+    This function is automatically invoked when using the syntax ``arr[i,j] |= value``.
+    """
+    ...
+
+@over
+def atomic_or(arr: Array[Any], i: Int, j: Int, k: Int, value: Any) -> Any:
+    """Atomically performs a bitwise OR between ``value`` and ``arr[i,j,k]``, atomically update the array, and return the old value.
+
+    This function is automatically invoked when using the syntax ``arr[i,j,k] |= value``.
+    """
+    ...
+
+@over
+def atomic_or(arr: Array[Any], i: Int, j: Int, k: Int, l: Int, value: Any) -> Any:
+    """Atomically performs a bitwise OR between ``value`` and ``arr[i,j,k,l]``, atomically update the array, and return the old value.
+
+    This function is automatically invoked when using the syntax ``arr[i,j,k,l] |= value``.
+    """
+    ...
+
+@over
+def atomic_or(arr: FabricArray[Any], i: Int, value: Any) -> Any:
+    """Atomically performs a bitwise OR between ``value`` and ``arr[i]``, atomically update the array, and return the old value.
+
+    This function is automatically invoked when using the syntax ``arr[i] |= value``.
+    """
+    ...
+
+@over
+def atomic_or(arr: FabricArray[Any], i: Int, j: Int, value: Any) -> Any:
+    """Atomically performs a bitwise OR between ``value`` and ``arr[i,j]``, atomically update the array, and return the old value.
+
+    This function is automatically invoked when using the syntax ``arr[i,j] |= value``.
+    """
+    ...
+
+@over
+def atomic_or(arr: FabricArray[Any], i: Int, j: Int, k: Int, value: Any) -> Any:
+    """Atomically performs a bitwise OR between ``value`` and ``arr[i,j,k]``, atomically update the array, and return the old value.
+
+    This function is automatically invoked when using the syntax ``arr[i,j,k] |= value``.
+    """
+    ...
+
+@over
+def atomic_or(arr: FabricArray[Any], i: Int, j: Int, k: Int, l: Int, value: Any) -> Any:
+    """Atomically performs a bitwise OR between ``value`` and ``arr[i,j,k,l]``, atomically update the array, and return the old value.
+
+    This function is automatically invoked when using the syntax ``arr[i,j,k,l] |= value``.
+    """
+    ...
+
+@over
+def atomic_or(arr: IndexedFabricArray[Any], i: Int, value: Any) -> Any:
+    """Atomically performs a bitwise OR between ``value`` and ``arr[i]``, atomically update the array, and return the old value.
+
+    This function is automatically invoked when using the syntax ``arr[i] |= value``.
+    """
+    ...
+
+@over
+def atomic_or(arr: IndexedFabricArray[Any], i: Int, j: Int, value: Any) -> Any:
+    """Atomically performs a bitwise OR between ``value`` and ``arr[i,j]``, atomically update the array, and return the old value.
+
+    This function is automatically invoked when using the syntax ``arr[i,j] |= value``.
+    """
+    ...
+
+@over
+def atomic_or(arr: IndexedFabricArray[Any], i: Int, j: Int, k: Int, value: Any) -> Any:
+    """Atomically performs a bitwise OR between ``value`` and ``arr[i,j,k]``, atomically update the array, and return the old value.
+
+    This function is automatically invoked when using the syntax ``arr[i,j,k] |= value``.
+    """
+    ...
+
+@over
+def atomic_or(arr: IndexedFabricArray[Any], i: Int, j: Int, k: Int, l: Int, value: Any) -> Any:
+    """Atomically performs a bitwise OR between ``value`` and ``arr[i,j,k,l]``, atomically update the array, and return the old value.
+
+    This function is automatically invoked when using the syntax ``arr[i,j,k,l] |= value``.
+    """
+    ...
+
+@over
+def atomic_xor(arr: Array[Any], i: Int, value: Any) -> Any:
+    """Atomically performs a bitwise XOR between ``value`` and ``arr[i]``, atomically update the array, and return the old value.
+
+    This function is automatically invoked when using the syntax ``arr[i] ^= value``.
+    """
+    ...
+
+@over
+def atomic_xor(arr: Array[Any], i: Int, j: Int, value: Any) -> Any:
+    """Atomically performs a bitwise XOR between ``value`` and ``arr[i,j]``, atomically update the array, and return the old value.
+
+    This function is automatically invoked when using the syntax ``arr[i,j] ^= value``.
+    """
+    ...
+
+@over
+def atomic_xor(arr: Array[Any], i: Int, j: Int, k: Int, value: Any) -> Any:
+    """Atomically performs a bitwise XOR between ``value`` and ``arr[i,j,k]``, atomically update the array, and return the old value.
+
+    This function is automatically invoked when using the syntax ``arr[i,j,k] ^= value``.
+    """
+    ...
+
+@over
+def atomic_xor(arr: Array[Any], i: Int, j: Int, k: Int, l: Int, value: Any) -> Any:
+    """Atomically performs a bitwise XOR between ``value`` and ``arr[i,j,k,l]``, atomically update the array, and return the old value.
+
+    This function is automatically invoked when using the syntax ``arr[i,j,k,l] ^= value``.
+    """
+    ...
+
+@over
+def atomic_xor(arr: FabricArray[Any], i: Int, value: Any) -> Any:
+    """Atomically performs a bitwise XOR between ``value`` and ``arr[i]``, atomically update the array, and return the old value.
+
+    This function is automatically invoked when using the syntax ``arr[i] ^= value``.
+    """
+    ...
+
+@over
+def atomic_xor(arr: FabricArray[Any], i: Int, j: Int, value: Any) -> Any:
+    """Atomically performs a bitwise XOR between ``value`` and ``arr[i,j]``, atomically update the array, and return the old value.
+
+    This function is automatically invoked when using the syntax ``arr[i,j] ^= value``.
+    """
+    ...
+
+@over
+def atomic_xor(arr: FabricArray[Any], i: Int, j: Int, k: Int, value: Any) -> Any:
+    """Atomically performs a bitwise XOR between ``value`` and ``arr[i,j,k]``, atomically update the array, and return the old value.
+
+    This function is automatically invoked when using the syntax ``arr[i,j,k] ^= value``.
+    """
+    ...
+
+@over
+def atomic_xor(arr: FabricArray[Any], i: Int, j: Int, k: Int, l: Int, value: Any) -> Any:
+    """Atomically performs a bitwise XOR between ``value`` and ``arr[i,j,k,l]``, atomically update the array, and return the old value.
+
+    This function is automatically invoked when using the syntax ``arr[i,j,k,l] ^= value``.
+    """
+    ...
+
+@over
+def atomic_xor(arr: IndexedFabricArray[Any], i: Int, value: Any) -> Any:
+    """Atomically performs a bitwise XOR between ``value`` and ``arr[i]``, atomically update the array, and return the old value.
+
+    This function is automatically invoked when using the syntax ``arr[i] ^= value``.
+    """
+    ...
+
+@over
+def atomic_xor(arr: IndexedFabricArray[Any], i: Int, j: Int, value: Any) -> Any:
+    """Atomically performs a bitwise XOR between ``value`` and ``arr[i,j]``, atomically update the array, and return the old value.
+
+    This function is automatically invoked when using the syntax ``arr[i,j] ^= value``.
+    """
+    ...
+
+@over
+def atomic_xor(arr: IndexedFabricArray[Any], i: Int, j: Int, k: Int, value: Any) -> Any:
+    """Atomically performs a bitwise XOR between ``value`` and ``arr[i,j,k]``, atomically update the array, and return the old value.
+
+    This function is automatically invoked when using the syntax ``arr[i,j,k] ^= value``.
+    """
+    ...
+
+@over
+def atomic_xor(arr: IndexedFabricArray[Any], i: Int, j: Int, k: Int, l: Int, value: Any) -> Any:
+    """Atomically performs a bitwise XOR between ``value`` and ``arr[i,j,k,l]``, atomically update the array, and return the old value.
+
+    This function is automatically invoked when using the syntax ``arr[i,j,k,l] ^= value``.
+    """
+    ...
+
 @over
 def lerp(a: Float, b: Float, t: Float) -> Float:
     """Linearly interpolate two values ``a`` and ``b`` using factor ``t``, computed as ``a*(1-t) + b*t``"""
@@ -3232,31 +5119,106 @@ def bit_and(a: Int, b: Int) -> Int:
     """ """
     ...
 
+@over
+def bit_and(a: Vector[Any, Int], b: Vector[Any, Int]) -> Vector[Any, Int]:
+    """ """
+    ...
+
+@over
+def bit_and(a: Matrix[Any, Any, Int], b: Matrix[Any, Any, Int]) -> Matrix[Any, Any, Int]:
+    """ """
+    ...
+
+@over
+def bit_and(a: Tile[Any, Tuple[int, ...]], b: Tile[Any, Tuple[int, ...]]) -> Tile[Scalar, Tuple[int, ...]]:
+    """Bitwise AND each element of two tiles together"""
+    ...
+
 @over
 def bit_or(a: Int, b: Int) -> Int:
     """ """
     ...
 
+@over
+def bit_or(a: Vector[Any, Int], b: Vector[Any, Int]) -> Vector[Any, Int]:
+    """ """
+    ...
+
+@over
+def bit_or(a: Matrix[Any, Any, Int], b: Matrix[Any, Any, Int]) -> Matrix[Any, Any, Int]:
+    """ """
+    ...
+
+@over
+def bit_or(a: Tile[Any, Tuple[int, ...]], b: Tile[Any, Tuple[int, ...]]) -> Tile[Scalar, Tuple[int, ...]]:
+    """Bitwise OR each element of two tiles together"""
+    ...
+
 @over
 def bit_xor(a: Int, b: Int) -> Int:
     """ """
     ...
 
+@over
+def bit_xor(a: Vector[Any, Int], b: Vector[Any, Int]) -> Vector[Any, Int]:
+    """ """
+    ...
+
+@over
+def bit_xor(a: Matrix[Any, Any, Int], b: Matrix[Any, Any, Int]) -> Matrix[Any, Any, Int]:
+    """ """
+    ...
+
+@over
+def bit_xor(a: Tile[Any, Tuple[int, ...]], b: Tile[Any, Tuple[int, ...]]) -> Tile[Scalar, Tuple[int, ...]]:
+    """Bitwise XOR each element of two tiles together"""
+    ...
+
 @over
 def lshift(a: Int, b: Int) -> Int:
     """ """
     ...
 
+@over
+def lshift(a: Vector[Any, Int], b: Vector[Any, Int]) -> Vector[Any, Int]:
+    """ """
+    ...
+
+@over
+def lshift(a: Matrix[Any, Any, Int], b: Matrix[Any, Any, Int]) -> Matrix[Any, Any, Int]:
+    """ """
+    ...
+
 @over
 def rshift(a: Int, b: Int) -> Int:
     """ """
     ...
 
+@over
+def rshift(a: Vector[Any, Int], b: Vector[Any, Int]) -> Vector[Any, Int]:
+    """ """
+    ...
+
+@over
+def rshift(a: Matrix[Any, Any, Int], b: Matrix[Any, Any, Int]) -> Matrix[Any, Any, Int]:
+    """ """
+    ...
+
 @over
 def invert(a: Int) -> Int:
     """ """
     ...
 
+@over
+def invert(a: Vector[Any, Int]) -> Vector[Any, Int]:
+    """ """
+    ...
+
+@over
+def invert(a: Matrix[Any, Any, Int]) -> Matrix[Any, Any, Int]:
+    """ """
+    ...
+
 @over
 def mul(a: Scalar, b: Scalar) -> Scalar:
     """ """
@@ -3672,6 +5634,39 @@ def len(a: Tuple) -> int:
     """Return the number of elements in a tuple."""
     ...
 
+@over
+def cast(a: Any, dtype: Any) -> Any:
+    """Reinterpret a value as a different type while preserving its bit pattern.
+
+    :param a: The value to cast
+    :param dtype: The target type
+
+    Example:
+
+    .. code-block:: python
+
+        @wp.struct
+        class MyStruct:
+            f: wp.float16
+            i: wp.int16
+
+        @wp.kernel
+        def compute():
+            x = wp.int32(0x40000000)
+            x_casted = wp.cast(x, wp.float32)
+            wp.expect_eq(x_casted, 2.0)  # 0x40000000
+
+            s = MyStruct()
+            s.f = wp.float16(2.0)  # 0x4000
+            s.i = wp.int16(4096)  # 0x1000
+            s_casted = wp.cast(s, wp.int32)
+            wp.expect_eq(s_casted, 0x10004000)
+
+        wp.launch(compute, dim=1)
+
+    """
+    ...
+
 @over
 def norm_l1(v: Any):
     """Computes the L1 norm of a vector v.