warp-lang 1.8.0__py3-none-win_amd64.whl → 1.9.0__py3-none-win_amd64.whl

warp/utils.py

@@ -131,16 +131,16 @@ def array_scan(in_array, out_array, inclusive=True):
 
     if in_array.device.is_cpu:
         if in_array.dtype == wp.int32:
-            runtime.core.array_scan_int_host(in_array.ptr, out_array.ptr, in_array.size, inclusive)
+            runtime.core.wp_array_scan_int_host(in_array.ptr, out_array.ptr, in_array.size, inclusive)
         elif in_array.dtype == wp.float32:
-            runtime.core.array_scan_float_host(in_array.ptr, out_array.ptr, in_array.size, inclusive)
+            runtime.core.wp_array_scan_float_host(in_array.ptr, out_array.ptr, in_array.size, inclusive)
         else:
             raise RuntimeError(f"Unsupported data type: {type_repr(in_array.dtype)}")
     elif in_array.device.is_cuda:
         if in_array.dtype == wp.int32:
-            runtime.core.array_scan_int_device(in_array.ptr, out_array.ptr, in_array.size, inclusive)
+            runtime.core.wp_array_scan_int_device(in_array.ptr, out_array.ptr, in_array.size, inclusive)
         elif in_array.dtype == wp.float32:
-            runtime.core.array_scan_float_device(in_array.ptr, out_array.ptr, in_array.size, inclusive)
+            runtime.core.wp_array_scan_float_device(in_array.ptr, out_array.ptr, in_array.size, inclusive)
         else:
             raise RuntimeError(f"Unsupported data type: {type_repr(in_array.dtype)}")
 
@@ -173,22 +173,22 @@ def radix_sort_pairs(keys, values, count: int):
 
     if keys.device.is_cpu:
         if keys.dtype == wp.int32 and values.dtype == wp.int32:
-            runtime.core.radix_sort_pairs_int_host(keys.ptr, values.ptr, count)
+            runtime.core.wp_radix_sort_pairs_int_host(keys.ptr, values.ptr, count)
         elif keys.dtype == wp.float32 and values.dtype == wp.int32:
-            runtime.core.radix_sort_pairs_float_host(keys.ptr, values.ptr, count)
+            runtime.core.wp_radix_sort_pairs_float_host(keys.ptr, values.ptr, count)
         elif keys.dtype == wp.int64 and values.dtype == wp.int32:
-            runtime.core.radix_sort_pairs_int64_host(keys.ptr, values.ptr, count)
+            runtime.core.wp_radix_sort_pairs_int64_host(keys.ptr, values.ptr, count)
         else:
             raise RuntimeError(
                 f"Unsupported keys and values data types: {type_repr(keys.dtype)}, {type_repr(values.dtype)}"
             )
     elif keys.device.is_cuda:
         if keys.dtype == wp.int32 and values.dtype == wp.int32:
-            runtime.core.radix_sort_pairs_int_device(keys.ptr, values.ptr, count)
+            runtime.core.wp_radix_sort_pairs_int_device(keys.ptr, values.ptr, count)
         elif keys.dtype == wp.float32 and values.dtype == wp.int32:
-            runtime.core.radix_sort_pairs_float_device(keys.ptr, values.ptr, count)
+            runtime.core.wp_radix_sort_pairs_float_device(keys.ptr, values.ptr, count)
         elif keys.dtype == wp.int64 and values.dtype == wp.int32:
-            runtime.core.radix_sort_pairs_int64_device(keys.ptr, values.ptr, count)
+            runtime.core.wp_radix_sort_pairs_int64_device(keys.ptr, values.ptr, count)
         else:
             raise RuntimeError(
                 f"Unsupported keys and values data types: {type_repr(keys.dtype)}, {type_repr(values.dtype)}"
@@ -256,7 +256,7 @@ def segmented_sort_pairs(
 
     if keys.device.is_cpu:
         if keys.dtype == wp.int32 and values.dtype == wp.int32:
-            runtime.core.segmented_sort_pairs_int_host(
+            runtime.core.wp_segmented_sort_pairs_int_host(
                 keys.ptr,
                 values.ptr,
                 count,
@@ -265,7 +265,7 @@ def segmented_sort_pairs(
                 num_segments,
             )
         elif keys.dtype == wp.float32 and values.dtype == wp.int32:
-            runtime.core.segmented_sort_pairs_float_host(
+            runtime.core.wp_segmented_sort_pairs_float_host(
                 keys.ptr,
                 values.ptr,
                 count,
@@ -277,7 +277,7 @@ def segmented_sort_pairs(
             raise RuntimeError(f"Unsupported data type: {type_repr(keys.dtype)}")
     elif keys.device.is_cuda:
         if keys.dtype == wp.int32 and values.dtype == wp.int32:
-            runtime.core.segmented_sort_pairs_int_device(
+            runtime.core.wp_segmented_sort_pairs_int_device(
                 keys.ptr,
                 values.ptr,
                 count,
@@ -286,7 +286,7 @@ def segmented_sort_pairs(
                 num_segments,
             )
         elif keys.dtype == wp.float32 and values.dtype == wp.int32:
-            runtime.core.segmented_sort_pairs_float_device(
+            runtime.core.wp_segmented_sort_pairs_float_device(
                 keys.ptr,
                 values.ptr,
                 count,
@@ -356,14 +356,14 @@ def runlength_encode(values, run_values, run_lengths, run_count=None, value_coun
 
     if values.device.is_cpu:
         if values.dtype == wp.int32:
-            runtime.core.runlength_encode_int_host(
+            runtime.core.wp_runlength_encode_int_host(
                 values.ptr, run_values.ptr, run_lengths.ptr, run_count.ptr, value_count
             )
         else:
             raise RuntimeError(f"Unsupported data type: {type_repr(values.dtype)}")
     elif values.device.is_cuda:
         if values.dtype == wp.int32:
-            runtime.core.runlength_encode_int_device(
+            runtime.core.wp_runlength_encode_int_device(
                 values.ptr, run_values.ptr, run_lengths.ptr, run_count.ptr, value_count
             )
         else:
@@ -435,16 +435,16 @@ def array_sum(values, out=None, value_count=None, axis=None):
 
     if values.device.is_cpu:
         if scalar_type == wp.float32:
-            native_func = runtime.core.array_sum_float_host
+            native_func = runtime.core.wp_array_sum_float_host
         elif scalar_type == wp.float64:
-            native_func = runtime.core.array_sum_double_host
+            native_func = runtime.core.wp_array_sum_double_host
         else:
             raise RuntimeError(f"Unsupported data type: {type_repr(values.dtype)}")
     elif values.device.is_cuda:
         if scalar_type == wp.float32:
-            native_func = runtime.core.array_sum_float_device
+            native_func = runtime.core.wp_array_sum_float_device
         elif scalar_type == wp.float64:
-            native_func = runtime.core.array_sum_double_device
+            native_func = runtime.core.wp_array_sum_double_device
         else:
             raise RuntimeError(f"Unsupported data type: {type_repr(values.dtype)}")
 
@@ -543,16 +543,16 @@ def array_inner(a, b, out=None, count=None, axis=None):
 
     if a.device.is_cpu:
         if scalar_type == wp.float32:
-            native_func = runtime.core.array_inner_float_host
+            native_func = runtime.core.wp_array_inner_float_host
         elif scalar_type == wp.float64:
-            native_func = runtime.core.array_inner_double_host
+            native_func = runtime.core.wp_array_inner_double_host
         else:
             raise RuntimeError(f"Unsupported data type: {type_repr(a.dtype)}")
     elif a.device.is_cuda:
         if scalar_type == wp.float32:
-            native_func = runtime.core.array_inner_float_device
+            native_func = runtime.core.wp_array_inner_float_device
         elif scalar_type == wp.float64:
-            native_func = runtime.core.array_inner_double_device
+            native_func = runtime.core.wp_array_inner_double_device
         else:
             raise RuntimeError(f"Unsupported data type: {type_repr(a.dtype)}")
 
@@ -914,7 +914,6 @@ def map(
 
     module = None
     out_dtypes = None
-    skip_arg_type_checks = False
     if isinstance(func, wp.Function):
         func_name = func.key
         wp_func = func
@@ -924,72 +923,50 @@ def map(
             raise TypeError("func must be a callable function or a warp.Function")
         wp_func, module = create_warp_function(func)
         func_name = wp_func.key
-        # we created a generic function here (arg types are all Any)
-        skip_arg_type_checks = True
     if module is None:
         module = warp.context.get_module(f"map_{func_name}")
 
     arg_names = list(wp_func.input_types.keys())
+
+    if len(inputs) != len(arg_names):
+        raise TypeError(
+            f"Number of input arguments ({len(inputs)}) does not match expected number of function arguments ({len(arg_names)})"
+        )
+
     # determine output dtype
-    if wp_func.value_func is not None or wp_func.value_type is not None:
-        arg_types = {}
-        arg_values = {}
-        for i, arg_name in enumerate(arg_names):
-            if is_array(inputs[i]):
-                # we will pass an element of the array to the function
-                arg_types[arg_name] = inputs[i].dtype
-                if device is None:
-                    device = inputs[i].device
-            else:
-                # we pass the input value directly to the function
-                arg_types[arg_name] = get_warp_type(inputs[i])
-        func_or_none = wp_func.get_overload(list(arg_types.values()), {})
-        if func_or_none is None:
-            raise TypeError(
-                f"Function {func_name} does not support the provided argument types {', '.join(type_repr(t) for t in arg_types.values())}"
-            )
-        func = func_or_none
-        if func.value_func is not None:
-            out_dtype = func.value_func(arg_types, arg_values)
-        else:
-            out_dtype = func.value_type
-        if isinstance(out_dtype, tuple) or isinstance(out_dtype, list):
-            out_dtypes = out_dtype
+    arg_types = {}
+    arg_values = {}
+    for i, arg_name in enumerate(arg_names):
+        if is_array(inputs[i]):
+            # we will pass an element of the array to the function
+            arg_types[arg_name] = inputs[i].dtype
+            if device is None:
+                device = inputs[i].device
         else:
-            out_dtypes = (out_dtype,)
+            # we pass the input value directly to the function
+            arg_types[arg_name] = get_warp_type(inputs[i])
+    func_or_none = wp_func.get_overload(list(arg_types.values()), {})
+    if func_or_none is None:
+        raise TypeError(
+            f"Function {func_name} does not support the provided argument types {', '.join(type_repr(t) for t in arg_types.values())}"
+        )
+    func = func_or_none
+
+    if func.value_type is not None:
+        out_dtype = func.value_type
+    elif func.value_func is not None:
+        out_dtype = func.value_func(arg_types, arg_values)
     else:
-        # try to evaluate the function to determine the output type
-        args = []
-        arg_types = wp_func.input_types
-        if len(inputs) != len(arg_types):
-            raise TypeError(
-                f"Number of input arguments ({len(inputs)}) does not match expected number of function arguments ({len(arg_types)})"
-            )
-        for (arg_name, arg_type), input in zip(arg_types.items(), inputs):
-            if is_array(input):
-                if not skip_arg_type_checks and not types_equal(input.dtype, arg_type):
-                    raise TypeError(
-                        f'Incorrect input provided for argument "{arg_name}": received array of dtype {type_repr(input.dtype)}, expected {type_repr(arg_type)}'
-                    )
-                args.append(input.dtype())
-                if device is None:
-                    device = input.device
-            else:
-                if not skip_arg_type_checks and not types_equal(type(input), arg_type):
-                    raise TypeError(
-                        f'Incorrect input provided for argument "{arg_name}": received {type_repr(type(input))}, expected {type_repr(arg_type)}'
-                    )
-                args.append(input)
-        result = wp_func(*args)
-        if result is None:
-            raise TypeError("The provided function must return a value")
-        if isinstance(result, tuple) or isinstance(result, list):
-            out_dtypes = tuple(get_warp_type(r) for r in result)
-        else:
-            out_dtypes = (get_warp_type(result),)
+        func.build(None)
+        out_dtype = func.value_func(arg_types, arg_values)
 
-    if out_dtypes is None:
-        raise TypeError("Could not determine the output type of the function, make sure it returns a value")
+    if out_dtype is None:
+        raise TypeError("The provided function must return a value")
+
+    if isinstance(out_dtype, tuple) or isinstance(out_dtype, list):
+        out_dtypes = out_dtype
+    else:
+        out_dtypes = (out_dtype,)
 
     if out is None:
         requires_grad = any(getattr(a, "requires_grad", False) for a in inputs if is_array(a))
@@ -1514,6 +1491,11 @@ class ScopedCapture:
         if self.active:
             try:
                 self.graph = wp.capture_end(device=self.device, stream=self.stream)
+            except Exception:
+                # Only report this exception if __exit__() was reached without an exception,
+                # otherwise re-raise the original exception.
+                if exc_type is None:
+                    raise
             finally:
                 self.active = False
 
@@ -1583,7 +1565,7 @@ def timing_begin(cuda_filter: int = TIMING_ALL, synchronize: bool = True) -> Non
     if synchronize:
         warp.synchronize()
 
-    warp.context.runtime.core.cuda_timing_begin(cuda_filter)
+    warp.context.runtime.core.wp_cuda_timing_begin(cuda_filter)
 
 
 def timing_end(synchronize: bool = True) -> list[TimingResult]:
@@ -1600,11 +1582,11 @@ def timing_end(synchronize: bool = True) -> list[TimingResult]:
         warp.synchronize()
 
     # get result count
-    count = warp.context.runtime.core.cuda_timing_get_result_count()
+    count = warp.context.runtime.core.wp_cuda_timing_get_result_count()
 
     # get result array from C++
     result_buffer = (timing_result_t * count)()
-    warp.context.runtime.core.cuda_timing_end(ctypes.byref(result_buffer), count)
+    warp.context.runtime.core.wp_cuda_timing_end(ctypes.byref(result_buffer), count)
 
     # prepare Python result list
     results = []

{warp_lang-1.8.0.dist-info → warp_lang-1.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: warp-lang
-Version: 1.8.0
+Version: 1.9.0
 Summary: A Python framework for high-performance simulation and graphics programming
 Author-email: NVIDIA Corporation <warp-python@nvidia.com>
 License: Apache-2.0
@@ -88,19 +88,16 @@ pip install warp-lang
 
 You can also use `pip install warp-lang[extras]` to install additional dependencies for running examples and USD-related features.
 
-The binaries hosted on PyPI are currently built with the CUDA 12 runtime and therefore
-require a minimum version of the CUDA driver of 525.60.13 (Linux x86-64) or 528.33 (Windows x86-64).
-
-If you require GPU support on a system with an older CUDA driver, you can build Warp from source or
-install wheels built with the CUDA 11.8 runtime from the [GitHub Releases](https://github.com/NVIDIA/warp/releases) page.
-Copy the URL of the appropriate wheel file (`warp-lang-{ver}+cu12-py3-none-{platform}.whl`) and pass it to
+The binaries hosted on PyPI are currently built with the CUDA 12 runtime.
+We also provide binaries built with the CUDA 13.0 runtime on the [GitHub Releases](https://github.com/NVIDIA/warp/releases) page.
+Copy the URL of the appropriate wheel file (`warp-lang-{ver}+cu13-py3-none-{platform}.whl`) and pass it to
 the `pip install` command, e.g.
 
 | Platform        | Install Command                                                                                                               |
 | --------------- | ----------------------------------------------------------------------------------------------------------------------------- |
-| Linux aarch64   | `pip install https://github.com/NVIDIA/warp/releases/download/v1.8.0/warp_lang-1.8.0+cu11-py3-none-manylinux2014_aarch64.whl` |
-| Linux x86-64    | `pip install https://github.com/NVIDIA/warp/releases/download/v1.8.0/warp_lang-1.8.0+cu11-py3-none-manylinux2014_x86_64.whl`  |
-| Windows x86-64  | `pip install https://github.com/NVIDIA/warp/releases/download/v1.8.0/warp_lang-1.8.0+cu11-py3-none-win_amd64.whl`             |
+| Linux aarch64   | `pip install https://github.com/NVIDIA/warp/releases/download/v1.9.0/warp_lang-1.9.0+cu13-py3-none-manylinux_2_34_aarch64.whl` |
+| Linux x86-64    | `pip install https://github.com/NVIDIA/warp/releases/download/v1.9.0/warp_lang-1.9.0+cu13-py3-none-manylinux_2_34_x86_64.whl`  |
+| Windows x86-64  | `pip install https://github.com/NVIDIA/warp/releases/download/v1.9.0/warp_lang-1.9.0+cu13-py3-none-win_amd64.whl`             |
 
 The `--force-reinstall` option may need to be used to overwrite a previous installation.
 
@@ -127,8 +124,8 @@ This ensures the index is automatically used for `pip` commands, avoiding the ne
 
 ### CUDA Requirements
 
-* Warp packages built with CUDA Toolkit 11.x require NVIDIA driver 470 or newer.
 * Warp packages built with CUDA Toolkit 12.x require NVIDIA driver 525 or newer.
+* Warp packages built with CUDA Toolkit 13.x require NVIDIA driver 580 or newer.
 
 This applies to pre-built packages distributed on PyPI and GitHub and also when building Warp from source.
 
@@ -151,66 +148,32 @@ To remedy the situation there are a few options:
 * Install a compatible pre-built Warp package.
 * Build Warp from source using a CUDA Toolkit that's compatible with the installed driver.
 
-## Getting Started
-
-An example first program that computes the lengths of random 3D vectors is given below:
-
-```python
-import warp as wp
-import numpy as np
-
-num_points = 1024
-
-@wp.kernel
-def length(points: wp.array(dtype=wp.vec3),
-           lengths: wp.array(dtype=float)):
-
-    # thread index
-    tid = wp.tid()
-    
-    # compute distance of each point from origin
-    lengths[tid] = wp.length(points[tid])
-
-
-# allocate an array of 3d points
-points = wp.array(np.random.rand(num_points, 3), dtype=wp.vec3)
-lengths = wp.zeros(num_points, dtype=float)
-
-# launch kernel
-wp.launch(kernel=length,
-          dim=len(points),
-          inputs=[points, lengths])
+## Tutorial Notebooks
 
-print(lengths)
-```
-
-## Running Notebooks
-
-A few notebooks are available in the [notebooks](./notebooks/) directory to provide an overview over the key features available in Warp.
+The [NVIDIA Accelerated Computing Hub](https://github.com/NVIDIA/accelerated-computing-hub) contains the current,
+actively maintained set of Warp tutorials:
 
-To run these notebooks, ``jupyterlab`` is required to be installed using:
+| Notebook | Colab Link |
+|----------|------------|
+| [Introduction to NVIDIA Warp](https://github.com/NVIDIA/accelerated-computing-hub/blob/9c334fcfcbbaf8d0cff91d012cdb2c11bf0f3dba/Accelerated_Python_User_Guide/notebooks/Chapter_12_Intro_to_NVIDIA_Warp.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/NVIDIA/accelerated-computing-hub/blob/9c334fcfcbbaf8d0cff91d012cdb2c11bf0f3dba/Accelerated_Python_User_Guide/notebooks/Chapter_12_Intro_to_NVIDIA_Warp.ipynb) |
+| [GPU-Accelerated Ising Model Simulation in NVIDIA Warp](https://github.com/NVIDIA/accelerated-computing-hub/blob/9c334fcfcbbaf8d0cff91d012cdb2c11bf0f3dba/Accelerated_Python_User_Guide/notebooks/Chapter_12.1_IsingModel_In_Warp.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/NVIDIA/accelerated-computing-hub/blob/9c334fcfcbbaf8d0cff91d012cdb2c11bf0f3dba/Accelerated_Python_User_Guide/notebooks/Chapter_12.1_IsingModel_In_Warp.ipynb) |
 
-```text
-pip install jupyterlab
-```
-
-From there, opening the notebooks can be done with the following command:
-
-```text
-jupyter lab ./notebooks
-```
+Additionally, several notebooks in the [notebooks](https://github.com/NVIDIA/warp/tree/main/notebooks) directory
+provide additional examples and cover key Warp features:
 
-* [Warp Core Tutorial: Basics](./notebooks/core_01_basics.ipynb) [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/NVIDIA/warp/blob/main/notebooks/core_01_basics.ipynb)
-* [Warp Core Tutorial: Generics](./notebooks/core_02_generics.ipynb) [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/NVIDIA/warp/blob/main/notebooks/core_02_generics.ipynb)
-* [Warp Core Tutorial: Points](./notebooks/core_03_points.ipynb) [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/NVIDIA/warp/blob/main/notebooks/core_03_points.ipynb)
-* [Warp Core Tutorial: Meshes](./notebooks/core_04_meshes.ipynb) [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/NVIDIA/warp/blob/main/notebooks/core_04_meshes.ipynb)
-* [Warp Core Tutorial: Volumes](./notebooks/core_05_volumes.ipynb) [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/NVIDIA/warp/blob/main/notebooks/core_05_volumes.ipynb)
-* [Warp PyTorch Tutorial: Basics](./notebooks/pytorch_01_basics.ipynb) [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/NVIDIA/warp/blob/main/notebooks/pytorch_01_basics.ipynb)
-* [Warp PyTorch Tutorial: Custom Operators](./notebooks/pytorch_02_custom_operators.ipynb) [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/NVIDIA/warp/blob/main/notebooks/pytorch_02_custom_operators.ipynb)
+| Notebook | Colab Link |
+|----------|------------|
+| [Warp Core Tutorial: Basics](https://github.com/NVIDIA/warp/blob/main/notebooks/core_01_basics.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/NVIDIA/warp/blob/main/notebooks/core_01_basics.ipynb) |
+| [Warp Core Tutorial: Generics](https://github.com/NVIDIA/warp/blob/main/notebooks/core_02_generics.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/NVIDIA/warp/blob/main/notebooks/core_02_generics.ipynb) |
+| [Warp Core Tutorial: Points](https://github.com/NVIDIA/warp/blob/main/notebooks/core_03_points.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/NVIDIA/warp/blob/main/notebooks/core_03_points.ipynb) |
+| [Warp Core Tutorial: Meshes](https://github.com/NVIDIA/warp/blob/main/notebooks/core_04_meshes.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/NVIDIA/warp/blob/main/notebooks/core_04_meshes.ipynb) |
+| [Warp Core Tutorial: Volumes](https://github.com/NVIDIA/warp/blob/main/notebooks/core_05_volumes.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/NVIDIA/warp/blob/main/notebooks/core_05_volumes.ipynb) |
+| [Warp PyTorch Tutorial: Basics](https://github.com/NVIDIA/warp/blob/main/notebooks/pytorch_01_basics.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/NVIDIA/warp/blob/main/notebooks/pytorch_01_basics.ipynb) |
+| [Warp PyTorch Tutorial: Custom Operators](https://github.com/NVIDIA/warp/blob/main/notebooks/pytorch_02_custom_operators.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/NVIDIA/warp/blob/main/notebooks/pytorch_02_custom_operators.ipynb) |
 
 ## Running Examples
 
-The [warp/examples](./warp/examples/) directory contains a number of scripts categorized under subdirectories
+The [warp/examples](https://github.com/NVIDIA/warp/tree/main/warp/examples) directory contains a number of scripts categorized under subdirectories
 that show how to implement various simulation methods using the Warp API.
 Most examples will generate USD files containing time-sampled animations in the current working directory.
 Before running examples, users should ensure that the ``usd-core``, ``matplotlib``, and ``pyglet`` packages are installed using:
@@ -454,7 +417,7 @@ For developers who want to build the library themselves, the following tools are
 
 * Microsoft Visual Studio 2019 upwards (Windows)
 * GCC 9.4 upwards (Linux)
-* CUDA Toolkit 11.5 or higher
+* CUDA Toolkit 12.0 or higher
 * [Git LFS](https://git-lfs.github.com/) installed
 
 After cloning the repository, users should run: