warp-lang 1.9.1__py3-none-win_amd64.whl → 1.10.0rc2__py3-none-win_amd64.whl

warp/tests/test_vec_scalar_ops.py

@@ -87,11 +87,11 @@ def get_select_kernel2(dtype):
 def test_arrays(test, device, dtype):
     rng = np.random.default_rng(123)
 
-    wptype = wp.types.np_dtype_to_warp_type[np.dtype(dtype)]
-    vec2 = wp.types.vector(length=2, dtype=wptype)
-    vec3 = wp.types.vector(length=3, dtype=wptype)
-    vec4 = wp.types.vector(length=4, dtype=wptype)
-    vec5 = wp.types.vector(length=5, dtype=wptype)
+    wptype = wp._src.types.np_dtype_to_warp_type[np.dtype(dtype)]
+    vec2 = wp._src.types.vector(length=2, dtype=wptype)
+    vec3 = wp._src.types.vector(length=3, dtype=wptype)
+    vec4 = wp._src.types.vector(length=4, dtype=wptype)
+    vec5 = wp._src.types.vector(length=5, dtype=wptype)
 
     v2_np = randvals(rng, (10, 2), dtype)
     v3_np = randvals(rng, (10, 3), dtype)
@@ -108,9 +108,9 @@ def test_arrays(test, device, dtype):
     assert_np_equal(v4.numpy(), v4_np, tol=1.0e-6)
     assert_np_equal(v5.numpy(), v5_np, tol=1.0e-6)
 
-    vec2 = wp.types.vector(length=2, dtype=wptype)
-    vec3 = wp.types.vector(length=3, dtype=wptype)
-    vec4 = wp.types.vector(length=4, dtype=wptype)
+    vec2 = wp._src.types.vector(length=2, dtype=wptype)
+    vec3 = wp._src.types.vector(length=3, dtype=wptype)
+    vec4 = wp._src.types.vector(length=4, dtype=wptype)
 
     v2 = wp.array(v2_np, dtype=vec2, requires_grad=True, device=device)
     v3 = wp.array(v3_np, dtype=vec3, requires_grad=True, device=device)
@@ -125,8 +125,8 @@ def test_components(test, device, dtype):
     # test accessing vector components from Python - this is especially important
     # for float16, which requires special handling internally
 
-    wptype = wp.types.np_dtype_to_warp_type[np.dtype(dtype)]
-    vec3 = wp.types.vector(length=3, dtype=wptype)
+    wptype = wp._src.types.np_dtype_to_warp_type[np.dtype(dtype)]
+    vec3 = wp._src.types.vector(length=3, dtype=wptype)
 
     v = vec3(1, 2, 3)
 
@@ -184,10 +184,10 @@ def test_components(test, device, dtype):
 
 
 def test_py_arithmetic_ops(test, device, dtype):
-    wptype = wp.types.np_dtype_to_warp_type[np.dtype(dtype)]
+    wptype = wp._src.types.np_dtype_to_warp_type[np.dtype(dtype)]
 
     def make_vec(*args):
-        if wptype in wp.types.int_types:
+        if wptype in wp._src.types.int_types:
             # Cast to the correct integer type to simulate wrapping.
             return tuple(wptype._type_(x).value for x in args)
 
@@ -219,11 +219,11 @@ def test_constructors(test, device, dtype, register_kernels=False):
         np.float64: 1.0e-8,
     }.get(dtype, 0)
 
-    wptype = wp.types.np_dtype_to_warp_type[np.dtype(dtype)]
-    vec2 = wp.types.vector(length=2, dtype=wptype)
-    vec3 = wp.types.vector(length=3, dtype=wptype)
-    vec4 = wp.types.vector(length=4, dtype=wptype)
-    vec5 = wp.types.vector(length=5, dtype=wptype)
+    wptype = wp._src.types.np_dtype_to_warp_type[np.dtype(dtype)]
+    vec2 = wp._src.types.vector(length=2, dtype=wptype)
+    vec3 = wp._src.types.vector(length=3, dtype=wptype)
+    vec4 = wp._src.types.vector(length=4, dtype=wptype)
+    vec5 = wp._src.types.vector(length=5, dtype=wptype)
 
     def check_scalar_constructor(
         input: wp.array(dtype=wptype),
@@ -463,7 +463,7 @@ def test_anon_type_instance(test, device, dtype, register_kernels=False):
         np.float64: 1.0e-8,
     }.get(dtype, 0)
 
-    wptype = wp.types.np_dtype_to_warp_type[np.dtype(dtype)]
+    wptype = wp._src.types.np_dtype_to_warp_type[np.dtype(dtype)]
 
     def check_scalar_init(
         input: wp.array(dtype=wptype),
@@ -586,11 +586,11 @@ def test_indexing(test, device, dtype, register_kernels=False):
         np.float64: 1.0e-8,
     }.get(dtype, 0)
 
-    wptype = wp.types.np_dtype_to_warp_type[np.dtype(dtype)]
-    vec2 = wp.types.vector(length=2, dtype=wptype)
-    vec3 = wp.types.vector(length=3, dtype=wptype)
-    vec4 = wp.types.vector(length=4, dtype=wptype)
-    vec5 = wp.types.vector(length=5, dtype=wptype)
+    wptype = wp._src.types.np_dtype_to_warp_type[np.dtype(dtype)]
+    vec2 = wp._src.types.vector(length=2, dtype=wptype)
+    vec3 = wp._src.types.vector(length=3, dtype=wptype)
+    vec4 = wp._src.types.vector(length=4, dtype=wptype)
+    vec5 = wp._src.types.vector(length=5, dtype=wptype)
 
     def check_indexing(
         v2: wp.array(dtype=vec2),
@@ -691,11 +691,11 @@ def test_indexing(test, device, dtype, register_kernels=False):
 
 
 def test_equality(test, device, dtype, register_kernels=False):
-    wptype = wp.types.np_dtype_to_warp_type[np.dtype(dtype)]
-    vec2 = wp.types.vector(length=2, dtype=wptype)
-    vec3 = wp.types.vector(length=3, dtype=wptype)
-    vec4 = wp.types.vector(length=4, dtype=wptype)
-    vec5 = wp.types.vector(length=5, dtype=wptype)
+    wptype = wp._src.types.np_dtype_to_warp_type[np.dtype(dtype)]
+    vec2 = wp._src.types.vector(length=2, dtype=wptype)
+    vec3 = wp._src.types.vector(length=3, dtype=wptype)
+    vec4 = wp._src.types.vector(length=4, dtype=wptype)
+    vec5 = wp._src.types.vector(length=5, dtype=wptype)
 
     def check_unsigned_equality(
         v20: wp.array(dtype=vec2),
@@ -821,11 +821,11 @@ def test_scalar_multiplication(test, device, dtype, register_kernels=False):
         np.float64: 1.0e-8,
     }.get(dtype, 0)
 
-    wptype = wp.types.np_dtype_to_warp_type[np.dtype(dtype)]
-    vec2 = wp.types.vector(length=2, dtype=wptype)
-    vec3 = wp.types.vector(length=3, dtype=wptype)
-    vec4 = wp.types.vector(length=4, dtype=wptype)
-    vec5 = wp.types.vector(length=5, dtype=wptype)
+    wptype = wp._src.types.np_dtype_to_warp_type[np.dtype(dtype)]
+    vec2 = wp._src.types.vector(length=2, dtype=wptype)
+    vec3 = wp._src.types.vector(length=3, dtype=wptype)
+    vec4 = wp._src.types.vector(length=4, dtype=wptype)
+    vec5 = wp._src.types.vector(length=5, dtype=wptype)
 
     def check_mul(
         s: wp.array(dtype=wptype),
@@ -953,11 +953,11 @@ def test_scalar_multiplication_rightmul(test, device, dtype, register_kernels=Fa
         np.float64: 1.0e-8,
     }.get(dtype, 0)
 
-    wptype = wp.types.np_dtype_to_warp_type[np.dtype(dtype)]
-    vec2 = wp.types.vector(length=2, dtype=wptype)
-    vec3 = wp.types.vector(length=3, dtype=wptype)
-    vec4 = wp.types.vector(length=4, dtype=wptype)
-    vec5 = wp.types.vector(length=5, dtype=wptype)
+    wptype = wp._src.types.np_dtype_to_warp_type[np.dtype(dtype)]
+    vec2 = wp._src.types.vector(length=2, dtype=wptype)
+    vec3 = wp._src.types.vector(length=3, dtype=wptype)
+    vec4 = wp._src.types.vector(length=4, dtype=wptype)
+    vec5 = wp._src.types.vector(length=5, dtype=wptype)
 
     def check_rightmul(
         s: wp.array(dtype=wptype),
@@ -1085,11 +1085,11 @@ def test_cw_multiplication(test, device, dtype, register_kernels=False):
         np.float64: 1.0e-8,
     }.get(dtype, 0)
 
-    wptype = wp.types.np_dtype_to_warp_type[np.dtype(dtype)]
-    vec2 = wp.types.vector(length=2, dtype=wptype)
-    vec3 = wp.types.vector(length=3, dtype=wptype)
-    vec4 = wp.types.vector(length=4, dtype=wptype)
-    vec5 = wp.types.vector(length=5, dtype=wptype)
+    wptype = wp._src.types.np_dtype_to_warp_type[np.dtype(dtype)]
+    vec2 = wp._src.types.vector(length=2, dtype=wptype)
+    vec3 = wp._src.types.vector(length=3, dtype=wptype)
+    vec4 = wp._src.types.vector(length=4, dtype=wptype)
+    vec5 = wp._src.types.vector(length=5, dtype=wptype)
 
     def check_cw_mul(
         s2: wp.array(dtype=vec2),
@@ -1230,11 +1230,11 @@ def test_scalar_division(test, device, dtype, register_kernels=False):
         np.float64: 1.0e-8,
     }.get(dtype, 0)
 
-    wptype = wp.types.np_dtype_to_warp_type[np.dtype(dtype)]
-    vec2 = wp.types.vector(length=2, dtype=wptype)
-    vec3 = wp.types.vector(length=3, dtype=wptype)
-    vec4 = wp.types.vector(length=4, dtype=wptype)
-    vec5 = wp.types.vector(length=5, dtype=wptype)
+    wptype = wp._src.types.np_dtype_to_warp_type[np.dtype(dtype)]
+    vec2 = wp._src.types.vector(length=2, dtype=wptype)
+    vec3 = wp._src.types.vector(length=3, dtype=wptype)
+    vec4 = wp._src.types.vector(length=4, dtype=wptype)
+    vec5 = wp._src.types.vector(length=5, dtype=wptype)
 
     def check_div(
         s: wp.array(dtype=wptype),
@@ -1386,11 +1386,11 @@ def test_cw_division(test, device, dtype, register_kernels=False):
         np.float64: 1.0e-8,
     }.get(dtype, 0)
 
-    wptype = wp.types.np_dtype_to_warp_type[np.dtype(dtype)]
-    vec2 = wp.types.vector(length=2, dtype=wptype)
-    vec3 = wp.types.vector(length=3, dtype=wptype)
-    vec4 = wp.types.vector(length=4, dtype=wptype)
-    vec5 = wp.types.vector(length=5, dtype=wptype)
+    wptype = wp._src.types.np_dtype_to_warp_type[np.dtype(dtype)]
+    vec2 = wp._src.types.vector(length=2, dtype=wptype)
+    vec3 = wp._src.types.vector(length=3, dtype=wptype)
+    vec4 = wp._src.types.vector(length=4, dtype=wptype)
+    vec5 = wp._src.types.vector(length=5, dtype=wptype)
 
     def check_cw_div(
         s2: wp.array(dtype=vec2),
@@ -1554,11 +1554,11 @@ def test_addition(test, device, dtype, register_kernels=False):
         np.float64: 1.0e-8,
     }.get(dtype, 0)
 
-    wptype = wp.types.np_dtype_to_warp_type[np.dtype(dtype)]
-    vec2 = wp.types.vector(length=2, dtype=wptype)
-    vec3 = wp.types.vector(length=3, dtype=wptype)
-    vec4 = wp.types.vector(length=4, dtype=wptype)
-    vec5 = wp.types.vector(length=5, dtype=wptype)
+    wptype = wp._src.types.np_dtype_to_warp_type[np.dtype(dtype)]
+    vec2 = wp._src.types.vector(length=2, dtype=wptype)
+    vec3 = wp._src.types.vector(length=3, dtype=wptype)
+    vec4 = wp._src.types.vector(length=4, dtype=wptype)
+    vec5 = wp._src.types.vector(length=5, dtype=wptype)
 
     def check_add(
         s2: wp.array(dtype=vec2),
@@ -1695,11 +1695,11 @@ def test_dotproduct(test, device, dtype, register_kernels=False):
         np.float64: 1.0e-8,
     }.get(dtype, 0)
 
-    wptype = wp.types.np_dtype_to_warp_type[np.dtype(dtype)]
-    vec2 = wp.types.vector(length=2, dtype=wptype)
-    vec3 = wp.types.vector(length=3, dtype=wptype)
-    vec4 = wp.types.vector(length=4, dtype=wptype)
-    vec5 = wp.types.vector(length=5, dtype=wptype)
+    wptype = wp._src.types.np_dtype_to_warp_type[np.dtype(dtype)]
+    vec2 = wp._src.types.vector(length=2, dtype=wptype)
+    vec3 = wp._src.types.vector(length=3, dtype=wptype)
+    vec4 = wp._src.types.vector(length=4, dtype=wptype)
+    vec5 = wp._src.types.vector(length=5, dtype=wptype)
 
     def check_dot(
         s2: wp.array(dtype=vec2),
@@ -1816,11 +1816,11 @@ def test_modulo(test, device, dtype, register_kernels=False):
         np.float64: 1.0e-8,
     }.get(dtype, 0)
 
-    wptype = wp.types.np_dtype_to_warp_type[np.dtype(dtype)]
-    vec2 = wp.types.vector(length=2, dtype=wptype)
-    vec3 = wp.types.vector(length=3, dtype=wptype)
-    vec4 = wp.types.vector(length=4, dtype=wptype)
-    vec5 = wp.types.vector(length=5, dtype=wptype)
+    wptype = wp._src.types.np_dtype_to_warp_type[np.dtype(dtype)]
+    vec2 = wp._src.types.vector(length=2, dtype=wptype)
+    vec3 = wp._src.types.vector(length=3, dtype=wptype)
+    vec4 = wp._src.types.vector(length=4, dtype=wptype)
+    vec5 = wp._src.types.vector(length=5, dtype=wptype)
 
     def check_mod(
         s2: wp.array(dtype=vec2),
@@ -1942,19 +1942,19 @@ def test_modulo(test, device, dtype, register_kernels=False):
 
 
 def test_equivalent_types(test, device, dtype, register_kernels=False):
-    wptype = wp.types.np_dtype_to_warp_type[np.dtype(dtype)]
+    wptype = wp._src.types.np_dtype_to_warp_type[np.dtype(dtype)]
 
     # vector types
-    vec2 = wp.types.vector(length=2, dtype=wptype)
-    vec3 = wp.types.vector(length=3, dtype=wptype)
-    vec4 = wp.types.vector(length=4, dtype=wptype)
-    vec5 = wp.types.vector(length=5, dtype=wptype)
+    vec2 = wp._src.types.vector(length=2, dtype=wptype)
+    vec3 = wp._src.types.vector(length=3, dtype=wptype)
+    vec4 = wp._src.types.vector(length=4, dtype=wptype)
+    vec5 = wp._src.types.vector(length=5, dtype=wptype)
 
     # vector types equivalent to the above
-    vec2_equiv = wp.types.vector(length=2, dtype=wptype)
-    vec3_equiv = wp.types.vector(length=3, dtype=wptype)
-    vec4_equiv = wp.types.vector(length=4, dtype=wptype)
-    vec5_equiv = wp.types.vector(length=5, dtype=wptype)
+    vec2_equiv = wp._src.types.vector(length=2, dtype=wptype)
+    vec3_equiv = wp._src.types.vector(length=3, dtype=wptype)
+    vec4_equiv = wp._src.types.vector(length=4, dtype=wptype)
+    vec5_equiv = wp._src.types.vector(length=5, dtype=wptype)
 
     # declare kernel with original types
     def check_equivalence(
@@ -2021,11 +2021,11 @@ def test_conversions(test, device, dtype, register_kernels=False):
 
 
 def test_constants(test, device, dtype, register_kernels=False):
-    wptype = wp.types.np_dtype_to_warp_type[np.dtype(dtype)]
-    vec2 = wp.types.vector(length=2, dtype=wptype)
-    vec3 = wp.types.vector(length=3, dtype=wptype)
-    vec4 = wp.types.vector(length=4, dtype=wptype)
-    vec5 = wp.types.vector(length=5, dtype=wptype)
+    wptype = wp._src.types.np_dtype_to_warp_type[np.dtype(dtype)]
+    vec2 = wp._src.types.vector(length=2, dtype=wptype)
+    vec3 = wp._src.types.vector(length=3, dtype=wptype)
+    vec4 = wp._src.types.vector(length=4, dtype=wptype)
+    vec5 = wp._src.types.vector(length=5, dtype=wptype)
 
     cv2 = wp.constant(vec2(1, 2))
     cv3 = wp.constant(vec3(1, 2, 3))
@@ -2047,11 +2047,11 @@ def test_constants(test, device, dtype, register_kernels=False):
 
 
 def test_abs(test, device, dtype, register_kernels=False):
-    wptype = wp.types.np_dtype_to_warp_type[np.dtype(dtype)]
-    vec2 = wp.types.vector(length=2, dtype=wptype)
-    vec3 = wp.types.vector(length=3, dtype=wptype)
-    vec4 = wp.types.vector(length=4, dtype=wptype)
-    vec5 = wp.types.vector(length=5, dtype=wptype)
+    wptype = wp._src.types.np_dtype_to_warp_type[np.dtype(dtype)]
+    vec2 = wp._src.types.vector(length=2, dtype=wptype)
+    vec3 = wp._src.types.vector(length=3, dtype=wptype)
+    vec4 = wp._src.types.vector(length=4, dtype=wptype)
+    vec5 = wp._src.types.vector(length=5, dtype=wptype)
 
     def check_vector_abs():
         res2 = wp.abs(vec2(wptype(-1), wptype(2)))
@@ -2075,11 +2075,11 @@ def test_abs(test, device, dtype, register_kernels=False):
 
 
 def test_sign(test, device, dtype, register_kernels=False):
-    wptype = wp.types.np_dtype_to_warp_type[np.dtype(dtype)]
-    vec2 = wp.types.vector(length=2, dtype=wptype)
-    vec3 = wp.types.vector(length=3, dtype=wptype)
-    vec4 = wp.types.vector(length=4, dtype=wptype)
-    vec5 = wp.types.vector(length=5, dtype=wptype)
+    wptype = wp._src.types.np_dtype_to_warp_type[np.dtype(dtype)]
+    vec2 = wp._src.types.vector(length=2, dtype=wptype)
+    vec3 = wp._src.types.vector(length=3, dtype=wptype)
+    vec4 = wp._src.types.vector(length=4, dtype=wptype)
+    vec5 = wp._src.types.vector(length=5, dtype=wptype)
 
     def check_vector_sign():
         res2 = wp.sign(vec2(wptype(-1), wptype(2)))
@@ -2113,11 +2113,11 @@ def test_minmax(test, device, dtype, register_kernels=False):
         np.float16: 1.0e-2,
     }.get(dtype, 0)
 
-    wptype = wp.types.np_dtype_to_warp_type[np.dtype(dtype)]
-    vec2 = wp.types.vector(length=2, dtype=wptype)
-    vec3 = wp.types.vector(length=3, dtype=wptype)
-    vec4 = wp.types.vector(length=4, dtype=wptype)
-    vec5 = wp.types.vector(length=5, dtype=wptype)
+    wptype = wp._src.types.np_dtype_to_warp_type[np.dtype(dtype)]
+    vec2 = wp._src.types.vector(length=2, dtype=wptype)
+    vec3 = wp._src.types.vector(length=3, dtype=wptype)
+    vec4 = wp._src.types.vector(length=4, dtype=wptype)
+    vec5 = wp._src.types.vector(length=5, dtype=wptype)
 
     # \TODO: Also not quite sure why: this kernel compiles incredibly
     # slowly though...

warp/tests/test_version.py

@@ -0,0 +1,75 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import re
+import unittest
+
+import warp as wp
+from warp._src.context import get_warp_clang_version, get_warp_version
+
+
+class TestVersion(unittest.TestCase):
+    """Tests for native library version verification using string comparison."""
+
+    def test_get_warp_version_returns_string(self):
+        """Test that get_warp_version() returns a string."""
+        version = get_warp_version()
+        self.assertIsInstance(version, str)
+        self.assertRegex(version, r"^\d+\.\d+\.\d+")
+
+    def test_get_warp_clang_version_returns_string(self):
+        """Test that get_warp_clang_version() returns a string."""
+        version = get_warp_clang_version()
+        self.assertIsInstance(version, str)
+        self.assertRegex(version, r"^\d+\.\d+\.\d+")
+
+    def test_dll_versions_match_python_version(self):
+        """Test that native library versions match Python package version exactly."""
+        python_version = wp._src.config.version
+        warp_version = get_warp_version()
+        warp_clang_version = get_warp_clang_version()
+
+        self.assertEqual(
+            warp_version, python_version, f"Warp library version {warp_version} != Python version {python_version}"
+        )
+        self.assertEqual(
+            warp_clang_version,
+            python_version,
+            f"warp-clang library version {warp_clang_version} != Python version {python_version}",
+        )
+
+    def test_version_format_validation(self):
+        """Test that versions follow PEP 440 versioning format."""
+        # PEP 440 pattern: [EPOCH!]MAJOR.MINOR.PATCH[{a|b|rc}N][.postN][.devN][+LOCAL]
+        # Examples: 1.10.0, 1.10.0.dev0, 1.10.0.dev20251017, 1.10.0a1, 1.10.0rc1, 1!1.10.0
+        pep440_pattern = (
+            r"^(\d+!)?"  # Optional epoch
+            r"\d+\.\d+\.\d+"  # Major.minor.patch
+            r"(\.?(a|alpha|b|beta|rc)\.?\d+)?"  # Optional alpha/beta/rc (with or without dots)
+            r"(\.post\d+)?"  # Optional post release
+            r"(\.dev\d+)?"  # Optional dev release
+            r"(\+[a-zA-Z0-9.]+)?$"  # Optional local version identifier
+        )
+
+        warp_version = get_warp_version()
+        warp_clang_version = get_warp_clang_version()
+
+        self.assertIsNotNone(re.match(pep440_pattern, warp_version))
+        self.assertIsNotNone(re.match(pep440_pattern, warp_clang_version))
+
+
+if __name__ == "__main__":
+    wp.clear_kernel_cache()
+    unittest.main(verbosity=2)

warp/tests/tile/test_tile.py

@@ -738,6 +738,28 @@ def test_tile_extract_kernel(a: wp.array2d(dtype=float), b: wp.array2d(dtype=flo
     wp.atomic_add(b, i, j, wp.tile_extract(tile, x, y))
 
 
+@wp.kernel
+def test_tile_extract_vec_kernel(x: wp.array(dtype=wp.vec3), y: wp.array(dtype=float)):
+    i = wp.tid()
+
+    tile = wp.tile_load(x, shape=(TILE_M))
+
+    a = tile[i][1]
+
+    y[i] = a
+
+
+@wp.kernel
+def test_tile_extract_mat_kernel(x: wp.array(dtype=wp.mat33), y: wp.array(dtype=float)):
+    i = wp.tid()
+
+    tile = wp.tile_load(x, shape=(TILE_M))
+
+    a = tile[i][1, 1]
+
+    y[i] = a
+
+
 def test_tile_extract(test, device):
     block_dim = 16
 
@@ -763,6 +785,40 @@ def test_tile_extract(test, device):
     expected_grad = np.ones_like(input)
     assert_np_equal(a.grad.numpy(), expected_grad)
 
+    # vector element test
+    x = wp.ones(TILE_M, dtype=wp.vec3, requires_grad=True, device=device)
+    y = wp.zeros(TILE_M, dtype=float, requires_grad=True, device=device)
+
+    with wp.Tape() as tape:
+        wp.launch(test_tile_extract_vec_kernel, dim=[TILE_M], inputs=[x, y], block_dim=TILE_DIM, device=device)
+
+    y.grad = wp.ones_like(y)
+
+    tape.backward()
+
+    x_grad_np = np.zeros((TILE_M, 3), dtype=float)
+    x_grad_np[:, 1] = 1.0
+
+    assert_np_equal(x.grad.numpy(), x_grad_np)
+    assert_np_equal(y.numpy(), np.ones(TILE_M, dtype=float))
+
+    # matrix element test
+    x = wp.ones(TILE_M, dtype=wp.mat33, requires_grad=True, device=device)
+    y = wp.zeros(TILE_M, dtype=float, requires_grad=True, device=device)
+
+    with wp.Tape() as tape:
+        wp.launch(test_tile_extract_mat_kernel, dim=[TILE_M], inputs=[x, y], block_dim=TILE_DIM, device=device)
+
+    y.grad = wp.ones_like(y)
+
+    tape.backward()
+
+    x_grad_np = np.zeros((TILE_M, 3, 3), dtype=float)
+    x_grad_np[:, 1, 1] = 1.0
+
+    assert_np_equal(y.numpy(), np.ones(TILE_M, dtype=float))
+    assert_np_equal(x.grad.numpy(), x_grad_np)
+
 
 @wp.kernel(module="unique")
 def test_tile_extract_repeated_kernel(a: wp.array2d(dtype=float), b: wp.array2d(dtype=float)):
@@ -822,6 +878,28 @@ def test_tile_assign_kernel(x: wp.array(dtype=float), y: wp.array(dtype=float)):
     wp.tile_atomic_add(y, a, offset=(0,))
 
 
+@wp.kernel
+def test_tile_assign_vec_kernel(x: wp.array(dtype=float), y: wp.array(dtype=wp.vec3)):
+    i = wp.tid()
+
+    a = wp.tile_zeros(shape=(TILE_M,), dtype=wp.vec3)
+
+    a[i][1] = x[i]
+
+    wp.tile_atomic_add(y, a, offset=(0,))
+
+
+@wp.kernel
+def test_tile_assign_mat_kernel(x: wp.array(dtype=float), y: wp.array(dtype=wp.mat33)):
+    i = wp.tid()
+
+    a = wp.tile_zeros(shape=(TILE_M,), dtype=wp.mat33)
+
+    a[i][1, 1] = x[i]
+
+    wp.tile_atomic_add(y, a, offset=(0,))
+
+
 def test_tile_assign(test, device):
     x = wp.full(TILE_M, 2.0, dtype=float, device=device, requires_grad=True)
     y = wp.zeros(TILE_M, dtype=float, device=device, requires_grad=True)
@@ -836,6 +914,40 @@ def test_tile_assign(test, device):
     assert_np_equal(y.numpy(), np.full(TILE_M, 2.0, dtype=np.float32))
     assert_np_equal(x.grad.numpy(), np.full(TILE_M, 1.0, dtype=np.float32))
 
+    # vector element test
+    x = wp.full(TILE_M, 2.0, dtype=float, device=device, requires_grad=True)
+    y = wp.zeros(TILE_M, dtype=wp.vec3, device=device, requires_grad=True)
+
+    tape = wp.Tape()
+    with tape:
+        wp.launch(test_tile_assign_vec_kernel, dim=[TILE_M], inputs=[x], outputs=[y], block_dim=TILE_DIM, device=device)
+
+    y.grad = wp.ones_like(y)
+    tape.backward()
+
+    y_np = np.zeros((TILE_M, 3), dtype=float)
+    y_np[:, 1] = 2.0
+
+    assert_np_equal(y.numpy(), y_np)
+    assert_np_equal(x.grad.numpy(), np.full(TILE_M, 1.0, dtype=np.float32))
+
+    # matrix element test
+    x = wp.full(TILE_M, 2.0, dtype=float, device=device, requires_grad=True)
+    y = wp.zeros(TILE_M, dtype=wp.mat33, device=device, requires_grad=True)
+
+    tape = wp.Tape()
+    with tape:
+        wp.launch(test_tile_assign_mat_kernel, dim=[TILE_M], inputs=[x], outputs=[y], block_dim=TILE_DIM, device=device)
+
+    y.grad = wp.ones_like(y)
+    tape.backward()
+
+    y_np = np.zeros((TILE_M, 3, 3), dtype=float)
+    y_np[:, 1, 1] = 2.0
+
+    assert_np_equal(y.numpy(), y_np)
+    assert_np_equal(x.grad.numpy(), np.full(TILE_M, 1.0, dtype=np.float32))
+
 
 @wp.kernel
 def test_tile_where_kernel(select: int, x: wp.array(dtype=float), y: wp.array(dtype=float), z: wp.array(dtype=float)):
@@ -1178,6 +1290,71 @@ def test_tile_len(test, device):
     test.assertEqual(out.numpy()[0], TILE_M)
 
 
+@wp.struct
+class TestStruct:
+    x: wp.float32
+    y: wp.vec3
+
+
+@wp.kernel
+def test_tile_construction_kernel(
+    out_zeros: wp.array(dtype=float),
+    out_ones: wp.array(dtype=float),
+    out_arange: wp.array(dtype=float),
+    out_full_twos: wp.array(dtype=float),
+    out_full_vecs: wp.array(dtype=wp.vec3),
+    out_full_mats: wp.array(dtype=wp.mat33),
+    out_full_structs: wp.array(dtype=TestStruct),
+):
+    zeros = wp.tile_zeros(TILE_M, dtype=float)
+    ones = wp.tile_ones(TILE_M, dtype=float)
+    arange = wp.tile_arange(TILE_M, dtype=float)
+    full_twos = wp.tile_full(TILE_M, value=2.0, dtype=float)
+    full_vecs = wp.tile_full(TILE_M, value=wp.vec3(1.0), dtype=wp.vec3)
+    full_mats = wp.tile_full(TILE_M, value=wp.mat33(1.0), dtype=wp.mat33)
+
+    ts = TestStruct()
+    ts.x = wp.float32(2.0)
+    ts.y = wp.vec3(1.0)
+    full_structs = wp.tile_full(TILE_M, value=ts, dtype=TestStruct)
+
+    wp.tile_store(out_zeros, zeros)
+    wp.tile_store(out_ones, ones)
+    wp.tile_store(out_arange, arange)
+    wp.tile_store(out_full_twos, full_twos)
+    wp.tile_store(out_full_vecs, full_vecs)
+    wp.tile_store(out_full_mats, full_mats)
+    wp.tile_store(out_full_structs, full_structs)
+
+
+def test_tile_construction(test, device):
+    zeros = wp.empty(TILE_M, dtype=float, device=device)
+    ones = wp.empty(TILE_M, dtype=float, device=device)
+    arange = wp.empty(TILE_M, dtype=float, device=device)
+    full_twos = wp.empty(TILE_M, dtype=float, device=device)
+    full_vecs = wp.empty(TILE_M, dtype=wp.vec3, device=device)
+    full_mats = wp.empty(TILE_M, dtype=wp.mat33, device=device)
+    full_structs = wp.empty(TILE_M, dtype=TestStruct, device=device)
+
+    wp.launch_tiled(
+        test_tile_construction_kernel,
+        dim=1,
+        inputs=[],
+        outputs=[zeros, ones, arange, full_twos, full_vecs, full_mats, full_structs],
+        block_dim=TILE_DIM,
+        device=device,
+    )
+
+    assert_np_equal(zeros.numpy(), np.zeros(TILE_M, dtype=float))
+    assert_np_equal(ones.numpy(), np.ones(TILE_M, dtype=float))
+    assert_np_equal(full_twos.numpy(), np.full(TILE_M, 2.0, dtype=float))
+    assert_np_equal(full_vecs.numpy(), np.ones((TILE_M, 3), dtype=float))
+    assert_np_equal(full_mats.numpy(), np.ones((TILE_M, 3, 3), dtype=float))
+    assert_np_equal(full_structs.numpy()["x"], np.full(TILE_M, 2.0, dtype=float))
+    assert_np_equal(full_structs.numpy()["y"], np.ones((TILE_M, 3), dtype=float))
+    assert_np_equal(arange.numpy(), np.arange(TILE_M, dtype=float))
+
+
 @wp.kernel
 def test_tile_print_kernel():
     # shared tile
@@ -1330,6 +1507,7 @@ add_function_test(TestTile, "test_tile_broadcast_grad", test_tile_broadcast_grad
 add_function_test(TestTile, "test_tile_squeeze", test_tile_squeeze, devices=devices)
 add_function_test(TestTile, "test_tile_reshape", test_tile_reshape, devices=devices)
 add_function_test(TestTile, "test_tile_len", test_tile_len, devices=devices)
+add_function_test(TestTile, "test_tile_construction", test_tile_construction, devices=devices)
 # add_function_test(TestTile, "test_tile_print", test_tile_print, devices=devices, check_output=False)
 # add_function_test(TestTile, "test_tile_inplace", test_tile_inplace, devices=devices)
 # add_function_test(TestTile, "test_tile_astype", test_tile_astype, devices=devices)