warp-lang 1.0.0b2__py3-none-manylinux2014_x86_64.whl → 1.0.0b6__py3-none-manylinux2014_x86_64.whl

examples/fem/mesh_utils.py

@@ -1,6 +1,8 @@
 import numpy as np
 import warp as wp
 
+from warp.fem.utils import grid_to_tets, grid_to_tris, grid_to_quads, grid_to_hexes
+
 
 def gen_trimesh(res, bounds_lo: wp.vec2 = wp.vec2(0.0), bounds_hi: wp.vec2 = wp.vec2(1.0)):
     """Constructs a triangular mesh by diving each cell of a dense 2D grid into two triangles
@@ -14,7 +16,6 @@ def gen_trimesh(res, bounds_lo: wp.vec2 = wp.vec2(0.0), bounds_hi: wp.vec2 = wp.
         Tuple of ndarrays: (Vertex positions, Triangle vertex indices)
     """
 
-
     Nx = res[0]
     Ny = res[1]
 
@@ -23,20 +24,7 @@ def gen_trimesh(res, bounds_lo: wp.vec2 = wp.vec2(0.0), bounds_hi: wp.vec2 = wp.
 
     positions = np.transpose(np.meshgrid(x, y, indexing="ij"), axes=(1, 2, 0)).reshape(-1, 2)
 
-    cx, cy = np.meshgrid(np.arange(Nx, dtype=int), np.arange(Ny, dtype=int), indexing="ij")
-
-    vidx = np.transpose(
-        np.array(
-            [
-                (Ny + 1) * cx + cy,
-                (Ny + 1) * (cx + 1) + cy,
-                (Ny + 1) * (cx + 1) + (cy + 1),
-                (Ny + 1) * cx + cy,
-                (Ny + 1) * (cx + 1) + (cy + 1),
-                (Ny + 1) * (cx) + (cy + 1),
-            ]
-        )
-    ).reshape((-1, 3))
+    vidx = grid_to_tris(Nx, Ny)
 
     return wp.array(positions, dtype=wp.vec2), wp.array(vidx, dtype=int)
 
@@ -63,85 +51,59 @@ def gen_tetmesh(res, bounds_lo: wp.vec3 = wp.vec3(0.0), bounds_hi: wp.vec3 = wp.
 
     positions = np.transpose(np.meshgrid(x, y, z, indexing="ij"), axes=(1, 2, 3, 0)).reshape(-1, 3)
 
-    # Global node indices for each cell
-    cx, cy, cz = np.meshgrid(
-        np.arange(Nx, dtype=int), np.arange(Ny, dtype=int), np.arange(Nz, dtype=int), indexing="ij"
-    )
-
-    grid_vidx = np.array(
-        [
-            (Ny + 1) * (Nz + 1) * cx + (Nz + 1) * cy + cz,
-            (Ny + 1) * (Nz + 1) * cx + (Nz + 1) * cy + cz + 1,
-            (Ny + 1) * (Nz + 1) * cx + (Nz + 1) * (cy + 1) + cz,
-            (Ny + 1) * (Nz + 1) * cx + (Nz + 1) * (cy + 1) + cz + 1,
-            (Ny + 1) * (Nz + 1) * (cx + 1) + (Nz + 1) * cy + cz,
-            (Ny + 1) * (Nz + 1) * (cx + 1) + (Nz + 1) * cy + cz + 1,
-            (Ny + 1) * (Nz + 1) * (cx + 1) + (Nz + 1) * (cy + 1) + cz,
-            (Ny + 1) * (Nz + 1) * (cx + 1) + (Nz + 1) * (cy + 1) + cz + 1,
-        ]
-    )
-
-    # decompose grid cells into 5 tets
-    tet_vidx = np.array(
-        [
-            [0, 1, 2, 4],
-            [3, 2, 1, 7],
-            [5, 1, 7, 4],
-            [6, 7, 4, 2],
-            [4, 1, 2, 7],
-        ]
-    )
-
-    # Convert to 3d index coordinates
-    vidx_coords = np.array(
-        [
-            [0, 0, 0],
-            [0, 0, 1],
-            [0, 1, 0],
-            [0, 1, 1],
-            [1, 0, 0],
-            [1, 0, 1],
-            [1, 1, 0],
-            [1, 1, 1],
-        ]
-    )
-    tet_coords = vidx_coords[tet_vidx]
-
-    # Symmetry bits for each cell
-    ox, oy, oz = np.meshgrid(
-        np.arange(Nx, dtype=int) % 2, np.arange(Ny, dtype=int) % 2, np.arange(Nz, dtype=int) % 2, indexing="ij"
-    )
-    tet_coords = np.broadcast_to(tet_coords, shape=(*ox.shape, *tet_coords.shape))
-
-    # Flip coordinates according to symmetry
-    ox_bk = np.broadcast_to(ox.reshape(*ox.shape, 1, 1), tet_coords.shape[:-1])
-    oy_bk = np.broadcast_to(oy.reshape(*oy.shape, 1, 1), tet_coords.shape[:-1])
-    oz_bk = np.broadcast_to(oz.reshape(*oz.shape, 1, 1), tet_coords.shape[:-1])
-
-    tet_coords_x = tet_coords[..., 0] ^ ox_bk
-    tet_coords_y = tet_coords[..., 1] ^ oy_bk
-    tet_coords_z = tet_coords[..., 2] ^ oz_bk
-
-    # Back to local vertex indices
-    corner_indices = 4 * tet_coords_x + 2 * tet_coords_y + tet_coords_z
-
-    # Now go from cell-local to global node indices
-    # There must be a nicer way than this, but for example purposes this works
-
-    corner_indices = corner_indices.reshape(-1, 4)
-
-    grid_vidx = grid_vidx.reshape((8, -1, 1))
-    grid_vidx = np.broadcast_to(grid_vidx, shape=(8, grid_vidx.shape[1], 5))
-    grid_vidx = grid_vidx.reshape((8, -1))
-
-    node_indices = np.arange(corner_indices.shape[0])
-    tet_grid_vidx = np.transpose(
-        [
-            grid_vidx[corner_indices[:, 0], node_indices],
-            grid_vidx[corner_indices[:, 1], node_indices],
-            grid_vidx[corner_indices[:, 2], node_indices],
-            grid_vidx[corner_indices[:, 3], node_indices],
-        ]
-    )
-
-    return wp.array(positions, dtype=wp.vec3), wp.array(tet_grid_vidx, dtype=int)
+    vidx = grid_to_tets(Nx, Ny, Nz)
+
+    return wp.array(positions, dtype=wp.vec3), wp.array(vidx, dtype=int)
+
+
+def gen_quadmesh(res, bounds_lo: wp.vec2 = wp.vec2(0.0), bounds_hi: wp.vec2 = wp.vec2(1.0)):
+    """Constructs a quadrilateral mesh from a dense 2D grid
+
+    Args:
+        res: Resolution of the grid along each dimension
+        bounds_lo: Position of the lower bound of the axis-aligned grid
+        bounds_up: Position of the upper bound of the axis-aligned grid
+
+    Returns:
+        Tuple of ndarrays: (Vertex positions, Triangle vertex indices)
+    """
+
+    Nx = res[0]
+    Ny = res[1]
+
+    x = np.linspace(bounds_lo[0], bounds_hi[0], Nx + 1)
+    y = np.linspace(bounds_lo[1], bounds_hi[1], Ny + 1)
+
+    positions = np.transpose(np.meshgrid(x, y, indexing="ij"), axes=(1, 2, 0)).reshape(-1, 2)
+
+    vidx = grid_to_quads(Nx, Ny)
+
+    return wp.array(positions, dtype=wp.vec2), wp.array(vidx, dtype=int)
+
+
+def gen_hexmesh(res, bounds_lo: wp.vec3 = wp.vec3(0.0), bounds_hi: wp.vec3 = wp.vec3(1.0)):
+    """Constructs a quadrilateral mesh from a dense 2D grid
+
+    Args:
+        res: Resolution of the grid along each dimension
+        bounds_lo: Position of the lower bound of the axis-aligned grid
+        bounds_up: Position of the upper bound of the axis-aligned grid
+
+    Returns:
+        Tuple of ndarrays: (Vertex positions, Triangle vertex indices)
+    """
+
+    Nx = res[0]
+    Ny = res[1]
+    Nz = res[2]
+
+    x = np.linspace(bounds_lo[0], bounds_hi[0], Nx + 1)
+    y = np.linspace(bounds_lo[1], bounds_hi[1], Ny + 1)
+    z = np.linspace(bounds_lo[1], bounds_hi[1], Nz + 1)
+
+    positions = np.transpose(np.meshgrid(x, y, z, indexing="ij"), axes=(1, 2, 3, 0)).reshape(-1, 3)
+
+    vidx = grid_to_hexes(Nx, Ny, Nz)
+
+    return wp.array(positions, dtype=wp.vec3), wp.array(vidx, dtype=int)
+

examples/fem/plot_utils.py

@@ -1,5 +1,9 @@
+from typing import Set
+
 import numpy as np
 
+from warp.fem import DiscreteField
+
 
 def plot_grid_surface(field, axes=None):
     import matplotlib.pyplot as plt
@@ -8,7 +12,7 @@ def plot_grid_surface(field, axes=None):
     if axes is None:
         fig, axes = plt.subplots(subplot_kw={"projection": "3d"})
 
-    node_positions = field.space.node_positions()
+    node_positions = field.space.node_grid()
 
     # Make data.
     X = node_positions[0]
@@ -27,10 +31,10 @@ def plot_tri_surface(field, axes=None):
     if axes is None:
         fig, axes = plt.subplots(subplot_kw={"projection": "3d"})
 
-    node_positions = field.space.node_positions()
-
+    node_positions = field.space.node_positions().numpy()
+    
     triangulation = Triangulation(
-        x=node_positions[0], y=node_positions[1], triangles=field.space.node_triangulation()
+        x=node_positions[:, 0], y=node_positions[:, 1], triangles=field.space.node_triangulation()
     )
 
     Z = field.dof_values.numpy()
@@ -46,7 +50,7 @@ def plot_scatter_surface(field, axes=None):
     if axes is None:
         fig, axes = plt.subplots(subplot_kw={"projection": "3d"})
 
-    X, Y = field.space.node_positions()
+    X, Y = field.space.node_positions().numpy().T
 
     # Make data.
     Z = field.dof_values.numpy().reshape(X.shape)
@@ -56,13 +60,12 @@ def plot_scatter_surface(field, axes=None):
 
 
 def plot_surface(field, axes=None):
-    if hasattr(field.space, "node_triangulation"):
+    if hasattr(field.space, "node_grid"):
+        return plot_grid_surface(field, axes)
+    elif hasattr(field.space, "node_triangulation"):
         return plot_tri_surface(field, axes)
     else:
-        try:
-            return plot_grid_surface(field, axes)
-        except:
-            return plot_scatter_surface(field, axes)
+        return plot_scatter_surface(field, axes)
 
 
 def plot_grid_color(field, axes=None):
@@ -72,7 +75,7 @@ def plot_grid_color(field, axes=None):
     if axes is None:
         fig, axes = plt.subplots()
 
-    node_positions = field.space.node_positions()
+    node_positions = field.space.node_grid()
 
     # Make data.
     X = node_positions[0]
@@ -89,11 +92,11 @@ def plot_velocities(field, axes=None):
     if axes is None:
         fig, axes = plt.subplots()
 
-    node_positions = field.space.node_positions()
+    node_positions = field.space.node_positions().numpy()
 
     # Make data.
-    X = node_positions[0]
-    Y = node_positions[1]
+    X = node_positions[:, 0]
+    Y = node_positions[:, 1]
 
     vel = field.dof_values.numpy()
     u = np.ascontiguousarray(vel[:, 0])
@@ -111,7 +114,7 @@ def plot_grid_streamlines(field, axes=None):
     if axes is None:
         fig, axes = plt.subplots()
 
-    node_positions = field.space.node_positions()
+    node_positions = field.space.node_grid()
 
     # Make data.
     X = node_positions[0][:, 0]
@@ -136,7 +139,7 @@ def plot_3d_scatter(field, axes=None):
     if axes is None:
         fig, axes = plt.subplots(subplot_kw={"projection": "3d"})
 
-    X, Y, Z = field.space.node_positions()
+    X, Y, Z = field.space.node_positions().numpy().T
 
     # Make data.
     f = field.dof_values.numpy().reshape(X.shape)
@@ -151,7 +154,7 @@ def plot_3d_velocities(field, axes=None):
     if axes is None:
         fig, axes = plt.subplots(subplot_kw={"projection": "3d"})
 
-    X, Y, Z = field.space.node_positions()
+    X, Y, Z = field.space.node_positions().numpy().T
 
     vel = field.dof_values.numpy()
     u = np.ascontiguousarray(vel[:, 0])
@@ -163,3 +166,121 @@ def plot_3d_velocities(field, axes=None):
     w = w.reshape(X.shape)
 
     return axes.quiver(X, Y, Z, u, v, w, length=1.0 / X.shape[0], normalize=False)
+
+
+class Plot:
+    def __init__(self, stage=None, default_point_radius=0.01):
+        self.default_point_radius = default_point_radius
+
+        self._surfaces = {}
+        self._surface_vectors = {}
+        self._volumes = {}
+
+        if stage is not None:
+            from warp.render import UsdRenderer
+
+            self._usd_renderer = UsdRenderer(stage)
+            self._plt = None
+        else:
+            self._usd_renderer = None
+
+    def begin_frame(self, time):
+        if self._usd_renderer is not None:
+            self._usd_renderer.begin_frame(time=time)
+
+    def end_frame(self):
+        if self._usd_renderer is not None:
+            self._usd_renderer.end_frame()
+
+    def add_surface(self, name: str, field: DiscreteField):
+        if self._usd_renderer is not None:
+            points_2d = field.space.node_positions().numpy()
+            values = field.dof_values.numpy()
+            points_3d = np.hstack((points_2d, values.reshape(-1, 1)))
+
+            if hasattr(field.space, "node_triangulation"):
+                indices = field.space.node_triangulation()
+                self._usd_renderer.render_mesh(name, points=points_3d, indices=indices)
+            else:
+                self._usd_renderer.render_points(name, points=points_3d, radius=self.default_point_radius)
+
+        if name not in self._surfaces:
+            field_clone = field.space.make_field(space_partition=field.space_partition)
+            self._surfaces[name] = (field_clone, [])
+
+        self._surfaces[name][1].append(field.dof_values.numpy())
+
+    def add_surface_vector(self, name: str, field: DiscreteField):
+        if self._usd_renderer is not None:
+            points_2d = field.space.node_positions().numpy()
+            values = field.dof_values.numpy()
+            points_3d = np.hstack((points_2d + values, np.zeros_like(points_2d[:, 0]).reshape(-1, 1)))
+
+            if hasattr(field.space, "node_triangulation"):
+                indices = field.space.node_triangulation()
+                self._usd_renderer.render_mesh(name, points=points_3d, indices=indices)
+            else:
+                self._usd_renderer.render_points(name, points=points_3d, radius=self.default_point_radius)
+
+        if name not in self._surface_vectors:
+            field_clone = field.space.make_field(space_partition=field.space_partition)
+            self._surface_vectors[name] = (field_clone, [])
+
+        self._surface_vectors[name][1].append(field.dof_values.numpy())
+
+    def add_volume(self, name: str, field: DiscreteField):
+        if self._usd_renderer is not None:
+            points_3d = field.space.node_positions().numpy()
+            values = field.dof_values.numpy()
+
+            self._usd_renderer.render_points(name, points_3d, radius=values)
+
+        if name not in self._volumes:
+            field_clone = field.space.make_field(space_partition=field.space_partition)
+            self._volumes[name] = (field_clone, [])
+
+        self._volumes[name][1].append(field.dof_values.numpy())
+
+    def plot(self, streamlines: Set[str] = []):
+        return self._plot_matplotlib(streamlines)
+
+    def _plot_matplotlib(self, streamlines: Set[str] = []):
+        import matplotlib.pyplot as plt
+        import matplotlib.animation as animation
+
+        def make_animation(ax, field, values, plot_func, num_frames: int):
+            def animate(i):
+                ax.clear()
+                field.dof_values = values[i]
+                return plot_func(field, axes=ax)
+
+            return animation.FuncAnimation(
+                ax.figure,
+                animate,
+                interval=30,
+                blit=False,
+                frames=len(values),
+            )
+
+        for name, (field, values) in self._surfaces.items():
+            field.dof_values = values[0]
+            ax = plot_surface(field).axes
+
+            if len(values) > 1:
+                anim = make_animation(ax, field, values, plot_func=plot_surface, num_frames=len(values))
+
+        for name, (field, values) in self._surface_vectors.items():
+            field.dof_values = values[0]
+            if name in streamlines and hasattr(field.space, "node_grid"):
+                ax = plot_grid_streamlines(field).axes
+            else:
+                ax = plot_velocities(field).axes
+
+                if len(values) > 1:
+                    anim = make_animation(ax, field, values, plot_func=plot_velocities, num_frames=len(values))
+
+        for name, (field, values) in self._volumes.items():
+            field.dof_values = values[0]
+            ax = plot_3d_scatter(field).axes
+
+        plt.show()

tools/ci/publishing/build_nodes_info.py

@@ -0,0 +1,54 @@
+# Copyright (c) 2023 NVIDIA CORPORATION.  All rights reserved.
+# NVIDIA CORPORATION and its licensors retain all intellectual property
+# and proprietary rights in and to this software, related documentation
+# and any modifications thereto.  Any use, reproduction, disclosure or
+# distribution of this software and related documentation without an express
+# license agreement from NVIDIA CORPORATION is strictly prohibited.
+
+"""Script to build the node.json OGN file that lists the extension's nodes."""
+
+import json
+import os
+
+
+def gather_nodes_info(
+    ext_path: str,
+    ext_name: str,
+) -> None:
+    # fmt: off
+    ogn_file_paths = tuple(
+        os.path.join(dir_path, file_name)
+        for (dir_path, _, file_names) in os.walk(ext_path)
+        for file_name in file_names if file_name.endswith(".ogn")
+    )
+    # fmt: on
+
+    nodes_info = {}
+    for file_path in ogn_file_paths:
+        with open(file_path) as file:
+            data = json.load(file)
+            node_key = next(iter(data.keys()))
+            node_data = data[node_key]
+            nodes_info[node_key] = {
+                "description": node_data.get("description", ""),
+                "version": node_data.get("version", 1),
+                "uiName": node_data.get("uiName", ""),
+                "extension": ext_name,
+                "language": node_data.get("language", ""),
+            }
+
+    return {"nodes": nodes_info}
+
+
+if __name__ == "__main__":
+    here = os.path.dirname(__file__)
+    root_path = os.path.abspath(os.path.join(here, "..", "..", ".."))
+    ext_path = os.path.join(root_path, "exts", "omni.warp")
+    ogn_path = os.path.join(ext_path, "ogn")
+    nodes_info_path = os.path.join(ogn_path, "nodes.json")
+
+    nodes_info = gather_nodes_info(ext_path, "omni.warp")
+
+    os.makedirs(ogn_path, exist_ok=True)
+    with open(nodes_info_path, "w") as file:
+        json.dump(nodes_info, file, indent=4)

warp/__init__.py

@@ -26,7 +26,9 @@ from warp.types import spatial_matrix, spatial_matrixh, spatial_matrixf, spatial
 
 # geometry types
 from warp.types import Bvh, Mesh, HashGrid, Volume, MarchingCubes
-from warp.types import bvh_query_t, mesh_query_aabb_t, hash_grid_query_t
+from warp.types import bvh_query_t, hash_grid_query_t, mesh_query_aabb_t, mesh_query_point_t, mesh_query_ray_t
+
+
 
 # device-wide gemms
 from warp.types import matmul, adj_matmul, batched_matmul, adj_batched_matmul, from_ptr
@@ -35,7 +37,7 @@ from warp.types import matmul, adj_matmul, batched_matmul, adj_batched_matmul, f
 from warp.types import vector as vec
 from warp.types import matrix as mat
 
-from warp.context import init, func, func_grad, func_replay, kernel, struct, overload
+from warp.context import init, func, func_grad, func_replay, func_native, kernel, struct, overload
 from warp.context import is_cpu_available, is_cuda_available, is_device_available
 from warp.context import get_devices, get_preferred_device
 from warp.context import get_cuda_devices, get_cuda_device_count, get_cuda_device, map_cuda_device, unmap_cuda_device
@@ -57,7 +59,6 @@ from warp.context import (
 )
 from warp.context import set_module_options, get_module_options, get_module
 from warp.context import capture_begin, capture_end, capture_launch
-from warp.context import print_builtins, export_builtins, export_stubs
 from warp.context import Kernel, Function, Launch
 from warp.context import Stream, get_stream, set_stream, synchronize_stream
 from warp.context import Event, record_event, wait_event, wait_stream

warp/__init__.pyi

@@ -0,0 +1 @@
+from .stubs import *

warp/build.py

@@ -26,8 +26,8 @@ def build_cuda(cu_path, arch, output_path, config="release", verify_fp=False, fa
             err = warp.context.runtime.core.cuda_compile_program(
                 src, arch, inc_path, config == "debug", warp.config.verbose, verify_fp, fast_math, output_path
             )
-            if err:
-                raise Exception("CUDA build failed")
+            if err != 0:
+                raise Exception(f"CUDA kernel build failed with error code {err}")
 
 
 # load PTX or CUBIN as a CUDA runtime module (input type determined by input_path extension)
@@ -45,7 +45,9 @@ def build_cpu(obj_path, cpp_path, mode="release", verify_fp=False, fast_math=Fal
         inc_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), "native").encode("utf-8")
         obj_path = obj_path.encode("utf-8")
 
-        warp.context.runtime.llvm.compile_cpp(src, cpp_path, inc_path, obj_path, mode == "debug")
+        err = warp.context.runtime.llvm.compile_cpp(src, cpp_path, inc_path, obj_path, mode == "debug")
+        if err != 0:
+            raise Exception(f"CPU kernel build failed with error code {err}")
 
 
 kernel_bin_dir = None

warp/build_dll.py

@@ -8,11 +8,24 @@
 import sys
 import os
 import subprocess
+import platform
 
 import warp.config
 from warp.utils import ScopedTimer
 
 
+# return a canonical machine architecture string
+# - "x86_64" for x86-64, aka. AMD64, aka. x64
+# - "aarch64" for AArch64, aka. ARM64
+def machine_architecture() -> str:
+    machine = platform.machine()
+    if machine == "x86_64" or machine == "AMD64":
+        return "x86_64"
+    if machine == "aarch64" or machine == "arm64":
+        return "aarch64"
+    raise RuntimeError(f"Unrecognized machine architecture {machine}")
+
+
 def run_cmd(cmd, capture=False):
     if warp.config.verbose:
         print(cmd)
@@ -182,12 +195,15 @@ def build_dll_for_arch(dll_path, cpp_paths, cu_path, libs, mode, arch, verify_fp
                 "-gencode=arch=compute_75,code=sm_75",  # Turing
                 "-gencode=arch=compute_80,code=sm_80",  # Ampere
                 "-gencode=arch=compute_86,code=sm_86",
-                # SASS for supported mobile architectures (e.g. Tegra/Jetson)
-                # "-gencode=arch=compute_53,code=sm_53",
-                # "-gencode=arch=compute_62,code=sm_62",
-                # "-gencode=arch=compute_72,code=sm_72",
-                # "-gencode=arch=compute_87,code=sm_87",
             ]
+            if arch == "aarch64" and sys.platform == "linux":
+                gencode_opts += [
+                    # SASS for supported mobile architectures (e.g. Tegra/Jetson)
+                    "-gencode=arch=compute_53,code=sm_53",  # X1
+                    "-gencode=arch=compute_62,code=sm_62",  # X2
+                    "-gencode=arch=compute_72,code=sm_72",  # Xavier
+                    "-gencode=arch=compute_87,code=sm_87",  # Orin
+                ]
 
             # support for Ada and Hopper is available with CUDA Toolkit 11.8+
             if ctk_version >= (11, 8):
@@ -354,11 +370,15 @@ def build_dll(dll_path, cpp_paths, cu_path, libs=[], mode="release", verify_fp=F
     if sys.platform == "darwin":
         # create a universal binary by combining x86-64 and AArch64 builds
         build_dll_for_arch(dll_path + "-x86_64", cpp_paths, cu_path, libs, mode, "x86_64", verify_fp, fast_math, quick)
-        build_dll_for_arch(dll_path + "-arm64", cpp_paths, cu_path, libs, mode, "arm64", verify_fp, fast_math, quick)
+        build_dll_for_arch(
+            dll_path + "-aarch64", cpp_paths, cu_path, libs, mode, "aarch64", verify_fp, fast_math, quick
+        )
 
-        run_cmd(f"lipo -create -output {dll_path} {dll_path}-x86_64 {dll_path}-arm64")
+        run_cmd(f"lipo -create -output {dll_path} {dll_path}-x86_64 {dll_path}-aarch64")
         os.remove(f"{dll_path}-x86_64")
-        os.remove(f"{dll_path}-arm64")
+        os.remove(f"{dll_path}-aarch64")
 
     else:
-        build_dll_for_arch(dll_path, cpp_paths, cu_path, libs, mode, "x86_64", verify_fp, fast_math, quick)
+        build_dll_for_arch(
+            dll_path, cpp_paths, cu_path, libs, mode, machine_architecture(), verify_fp, fast_math, quick
+        )