warp-lang 1.2.2__py3-none-manylinux2014_aarch64.whl → 1.3.1__py3-none-manylinux2014_aarch64.whl

warp/builtins.py

@@ -5,25 +5,40 @@
 # distribution of this software and related documentation without an express
 # license agreement from NVIDIA CORPORATION is strictly prohibited.
 import builtins
-from typing import Any, Callable, Tuple
+from typing import Any, Callable, Mapping, Sequence
 
-from warp.codegen import Reference
+from warp.codegen import Reference, Var, strip_reference
 from warp.types import *
 
 from .context import add_builtin
 
 
-def sametypes(arg_types):
-    return all(types_equal(arg_types[0], t) for t in arg_types[1:])
+def seq_check_equal(seq_1, seq_2):
+    if not isinstance(seq_1, Sequence) or not isinstance(seq_2, Sequence):
+        return False
 
+    if len(seq_1) != len(seq_2):
+        return False
 
-def sametype_value_func(default):
-    def fn(arg_types, kwds, _):
+    return all(x == y for x, y in zip(seq_1, seq_2))
+
+
+def sametypes(arg_types: Mapping[str, Any]):
+    arg_types_iter = iter(arg_types.values())
+    arg_type_0 = next(arg_types_iter)
+    return all(types_equal(arg_type_0, t) for t in arg_types_iter)
+
+
+def sametypes_create_value_func(default):
+    def fn(arg_types, arg_values):
         if arg_types is None:
             return default
+
         if not sametypes(arg_types):
-            raise RuntimeError(f"Input types must be the same, found: {[type_repr(t) for t in arg_types]}")
-        return arg_types[0]
+            raise RuntimeError(f"Input types must be the same, got {[type_repr(t) for t in arg_types.values()]}")
+
+        arg_type_0 = next(iter(arg_types.values()))
+        return arg_type_0
 
     return fn
 
@@ -33,39 +48,39 @@ def sametype_value_func(default):
 
 add_builtin(
     "min",
-    input_types={"x": Scalar, "y": Scalar},
-    value_func=sametype_value_func(Scalar),
+    input_types={"a": Scalar, "b": Scalar},
+    value_func=sametypes_create_value_func(Scalar),
     doc="Return the minimum of two scalars.",
     group="Scalar Math",
 )
 
 add_builtin(
     "max",
-    input_types={"x": Scalar, "y": Scalar},
-    value_func=sametype_value_func(Scalar),
+    input_types={"a": Scalar, "b": Scalar},
+    value_func=sametypes_create_value_func(Scalar),
     doc="Return the maximum of two scalars.",
     group="Scalar Math",
 )
 
 add_builtin(
     "clamp",
-    input_types={"x": Scalar, "a": Scalar, "b": Scalar},
-    value_func=sametype_value_func(Scalar),
-    doc="Clamp the value of ``x`` to the range [a, b].",
+    input_types={"x": Scalar, "low": Scalar, "high": Scalar},
+    value_func=sametypes_create_value_func(Scalar),
+    doc="Clamp the value of ``x`` to the range [low, high].",
     group="Scalar Math",
 )
 
 add_builtin(
     "abs",
     input_types={"x": Scalar},
-    value_func=sametype_value_func(Scalar),
+    value_func=sametypes_create_value_func(Scalar),
     doc="Return the absolute value of ``x``.",
     group="Scalar Math",
 )
 add_builtin(
     "sign",
     input_types={"x": Scalar},
-    value_func=sametype_value_func(Scalar),
+    value_func=sametypes_create_value_func(Scalar),
     doc="Return -1 if ``x`` < 0, return 1 otherwise.",
     group="Scalar Math",
 )
@@ -73,14 +88,14 @@ add_builtin(
 add_builtin(
     "step",
     input_types={"x": Scalar},
-    value_func=sametype_value_func(Scalar),
+    value_func=sametypes_create_value_func(Scalar),
     doc="Return 1.0 if ``x`` < 0.0, return 0.0 otherwise.",
     group="Scalar Math",
 )
 add_builtin(
     "nonzero",
     input_types={"x": Scalar},
-    value_func=sametype_value_func(Scalar),
+    value_func=sametypes_create_value_func(Scalar),
     doc="Return 1.0 if ``x`` is not equal to zero, return 0.0 otherwise.",
     group="Scalar Math",
 )
@@ -88,35 +103,35 @@ add_builtin(
 add_builtin(
     "sin",
     input_types={"x": Float},
-    value_func=sametype_value_func(Float),
+    value_func=sametypes_create_value_func(Float),
     doc="Return the sine of ``x`` in radians.",
     group="Scalar Math",
 )
 add_builtin(
     "cos",
     input_types={"x": Float},
-    value_func=sametype_value_func(Float),
+    value_func=sametypes_create_value_func(Float),
     doc="Return the cosine of ``x`` in radians.",
     group="Scalar Math",
 )
 add_builtin(
     "acos",
     input_types={"x": Float},
-    value_func=sametype_value_func(Float),
+    value_func=sametypes_create_value_func(Float),
     doc="Return arccos of ``x`` in radians. Inputs are automatically clamped to [-1.0, 1.0].",
     group="Scalar Math",
 )
 add_builtin(
     "asin",
     input_types={"x": Float},
-    value_func=sametype_value_func(Float),
+    value_func=sametypes_create_value_func(Float),
     doc="Return arcsin of ``x`` in radians. Inputs are automatically clamped to [-1.0, 1.0].",
     group="Scalar Math",
 )
 add_builtin(
     "sqrt",
     input_types={"x": Float},
-    value_func=sametype_value_func(Float),
+    value_func=sametypes_create_value_func(Float),
     doc="Return the square root of ``x``, where ``x`` is positive.",
     group="Scalar Math",
     require_original_output_arg=True,
@@ -124,7 +139,7 @@ add_builtin(
 add_builtin(
     "cbrt",
     input_types={"x": Float},
-    value_func=sametype_value_func(Float),
+    value_func=sametypes_create_value_func(Float),
     doc="Return the cube root of ``x``.",
     group="Scalar Math",
     require_original_output_arg=True,
@@ -132,42 +147,42 @@ add_builtin(
 add_builtin(
     "tan",
     input_types={"x": Float},
-    value_func=sametype_value_func(Float),
+    value_func=sametypes_create_value_func(Float),
     doc="Return the tangent of ``x`` in radians.",
     group="Scalar Math",
 )
 add_builtin(
     "atan",
     input_types={"x": Float},
-    value_func=sametype_value_func(Float),
+    value_func=sametypes_create_value_func(Float),
     doc="Return the arctangent of ``x`` in radians.",
     group="Scalar Math",
 )
 add_builtin(
     "atan2",
     input_types={"y": Float, "x": Float},
-    value_func=sametype_value_func(Float),
+    value_func=sametypes_create_value_func(Float),
     doc="Return the 2-argument arctangent, atan2, of the point ``(x, y)`` in radians.",
     group="Scalar Math",
 )
 add_builtin(
     "sinh",
     input_types={"x": Float},
-    value_func=sametype_value_func(Float),
+    value_func=sametypes_create_value_func(Float),
     doc="Return the sinh of ``x``.",
     group="Scalar Math",
 )
 add_builtin(
     "cosh",
     input_types={"x": Float},
-    value_func=sametype_value_func(Float),
+    value_func=sametypes_create_value_func(Float),
     doc="Return the cosh of ``x``.",
     group="Scalar Math",
 )
 add_builtin(
     "tanh",
     input_types={"x": Float},
-    value_func=sametype_value_func(Float),
+    value_func=sametypes_create_value_func(Float),
     doc="Return the tanh of ``x``.",
     group="Scalar Math",
     require_original_output_arg=True,
@@ -175,14 +190,14 @@ add_builtin(
 add_builtin(
     "degrees",
     input_types={"x": Float},
-    value_func=sametype_value_func(Float),
+    value_func=sametypes_create_value_func(Float),
     doc="Convert ``x`` from radians into degrees.",
     group="Scalar Math",
 )
 add_builtin(
     "radians",
     input_types={"x": Float},
-    value_func=sametype_value_func(Float),
+    value_func=sametypes_create_value_func(Float),
     doc="Convert ``x`` from degrees into radians.",
     group="Scalar Math",
 )
@@ -190,28 +205,28 @@ add_builtin(
 add_builtin(
     "log",
     input_types={"x": Float},
-    value_func=sametype_value_func(Float),
+    value_func=sametypes_create_value_func(Float),
     doc="Return the natural logarithm (base-e) of ``x``, where ``x`` is positive.",
     group="Scalar Math",
 )
 add_builtin(
     "log2",
     input_types={"x": Float},
-    value_func=sametype_value_func(Float),
+    value_func=sametypes_create_value_func(Float),
     doc="Return the binary logarithm (base-2) of ``x``, where ``x`` is positive.",
     group="Scalar Math",
 )
 add_builtin(
     "log10",
     input_types={"x": Float},
-    value_func=sametype_value_func(Float),
+    value_func=sametypes_create_value_func(Float),
     doc="Return the common logarithm (base-10) of ``x``, where ``x`` is positive.",
     group="Scalar Math",
 )
 add_builtin(
     "exp",
     input_types={"x": Float},
-    value_func=sametype_value_func(Float),
+    value_func=sametypes_create_value_func(Float),
     doc="Return the value of the exponential function :math:`e^x`.",
     group="Scalar Math",
     require_original_output_arg=True,
@@ -219,7 +234,7 @@ add_builtin(
 add_builtin(
     "pow",
     input_types={"x": Float, "y": Float},
-    value_func=sametype_value_func(Float),
+    value_func=sametypes_create_value_func(Float),
     doc="Return the result of ``x`` raised to power of ``y``.",
     group="Scalar Math",
     require_original_output_arg=True,
@@ -228,7 +243,7 @@ add_builtin(
 add_builtin(
     "round",
     input_types={"x": Float},
-    value_func=sametype_value_func(Float),
+    value_func=sametypes_create_value_func(Float),
     group="Scalar Math",
     doc="""Return the nearest integer value to ``x``, rounding halfway cases away from zero.
 
@@ -239,7 +254,7 @@ add_builtin(
 add_builtin(
     "rint",
     input_types={"x": Float},
-    value_func=sametype_value_func(Float),
+    value_func=sametypes_create_value_func(Float),
     group="Scalar Math",
     doc="""Return the nearest integer value to ``x``, rounding halfway cases to nearest even integer.
 
@@ -249,19 +264,19 @@ add_builtin(
 add_builtin(
     "trunc",
     input_types={"x": Float},
-    value_func=sametype_value_func(Float),
+    value_func=sametypes_create_value_func(Float),
     group="Scalar Math",
     doc="""Return the nearest integer that is closer to zero than ``x``.
 
     In other words, it discards the fractional part of ``x``.
-    It is similar to casting ``float(int(x))``, but preserves the negative sign when x is in the range [-0.0, -1.0).
+    It is similar to casting ``float(int(a))``, but preserves the negative sign when ``x`` is in the range [-0.0, -1.0).
     Equivalent to :func:`numpy.trunc()` and :func:`numpy.fix()`.""",
 )
 
 add_builtin(
     "floor",
     input_types={"x": Float},
-    value_func=sametype_value_func(Float),
+    value_func=sametypes_create_value_func(Float),
     group="Scalar Math",
     doc="""Return the largest integer that is less than or equal to ``x``.""",
 )
@@ -269,7 +284,7 @@ add_builtin(
 add_builtin(
     "ceil",
     input_types={"x": Float},
-    value_func=sametype_value_func(Float),
+    value_func=sametypes_create_value_func(Float),
     group="Scalar Math",
     doc="""Return the smallest integer that is greater than or equal to ``x``.""",
 )
@@ -277,127 +292,145 @@ add_builtin(
 add_builtin(
     "frac",
     input_types={"x": Float},
-    value_func=sametype_value_func(Float),
+    value_func=sametypes_create_value_func(Float),
     group="Scalar Math",
-    doc="""Retrieve the fractional part of x.
+    doc="""Retrieve the fractional part of ``x``.
 
-    In other words, it discards the integer part of x and is equivalent to ``x - trunc(x)``.""",
+    In other words, it discards the integer part of ``x`` and is equivalent to ``x - trunc(x)``.""",
 )
 
 add_builtin(
     "isfinite",
-    input_types={"x": Scalar},
+    input_types={"a": Scalar},
     value_type=builtins.bool,
     group="Scalar Math",
-    doc="""Return ``True`` if x is a finite number, otherwise return ``False``.""",
+    doc="""Return ``True`` if ``a`` is a finite number, otherwise return ``False``.""",
 )
 add_builtin(
     "isfinite",
-    input_types={"x": vector(length=Any, dtype=Scalar)},
+    input_types={"a": vector(length=Any, dtype=Scalar)},
     value_type=builtins.bool,
     group="Vector Math",
-    doc="Return ``True`` if all elements of the vector ``x`` are finite, otherwise return ``False``.",
+    doc="Return ``True`` if all elements of the vector ``a`` are finite, otherwise return ``False``.",
 )
 add_builtin(
     "isfinite",
-    input_types={"x": quaternion(dtype=Scalar)},
+    input_types={"a": quaternion(dtype=Scalar)},
     value_type=builtins.bool,
     group="Vector Math",
-    doc="Return ``True`` if all elements of the quaternion ``x`` are finite, otherwise return ``False``.",
+    doc="Return ``True`` if all elements of the quaternion ``a`` are finite, otherwise return ``False``.",
 )
 add_builtin(
     "isfinite",
-    input_types={"m": matrix(shape=(Any, Any), dtype=Scalar)},
+    input_types={"a": matrix(shape=(Any, Any), dtype=Scalar)},
     value_type=builtins.bool,
     group="Vector Math",
-    doc="Return ``True`` if all elements of the matrix ``m`` are finite, otherwise return ``False``.",
+    doc="Return ``True`` if all elements of the matrix ``a`` are finite, otherwise return ``False``.",
 )
 
 add_builtin(
     "isnan",
-    input_types={"x": Scalar},
+    input_types={"a": Scalar},
     value_type=builtins.bool,
-    doc="Return ``True`` if ``x`` is NaN, otherwise return ``False``.",
+    doc="Return ``True`` if ``a`` is NaN, otherwise return ``False``.",
     group="Scalar Math",
 )
 add_builtin(
     "isnan",
-    input_types={"x": vector(length=Any, dtype=Scalar)},
+    input_types={"a": vector(length=Any, dtype=Scalar)},
     value_type=builtins.bool,
     group="Vector Math",
-    doc="Return ``True`` if any element of the vector ``x`` is NaN, otherwise return ``False``.",
+    doc="Return ``True`` if any element of the vector ``a`` is NaN, otherwise return ``False``.",
 )
 add_builtin(
     "isnan",
-    input_types={"x": quaternion(dtype=Scalar)},
+    input_types={"a": quaternion(dtype=Scalar)},
     value_type=builtins.bool,
     group="Vector Math",
-    doc="Return ``True`` if any element of the quaternion ``x`` is NaN, otherwise return ``False``.",
+    doc="Return ``True`` if any element of the quaternion ``a`` is NaN, otherwise return ``False``.",
 )
 add_builtin(
     "isnan",
-    input_types={"m": matrix(shape=(Any, Any), dtype=Scalar)},
+    input_types={"a": matrix(shape=(Any, Any), dtype=Scalar)},
     value_type=builtins.bool,
     group="Vector Math",
-    doc="Return ``True`` if any element of the matrix ``m`` is NaN, otherwise return ``False``.",
+    doc="Return ``True`` if any element of the matrix ``a`` is NaN, otherwise return ``False``.",
 )
 
 add_builtin(
     "isinf",
-    input_types={"x": Scalar},
+    input_types={"a": Scalar},
     value_type=builtins.bool,
     group="Scalar Math",
-    doc="""Return ``True`` if x is positive or negative infinity, otherwise return ``False``.""",
+    doc="""Return ``True`` if ``a`` is positive or negative infinity, otherwise return ``False``.""",
 )
 add_builtin(
     "isinf",
-    input_types={"x": vector(length=Any, dtype=Scalar)},
+    input_types={"a": vector(length=Any, dtype=Scalar)},
     value_type=builtins.bool,
     group="Vector Math",
-    doc="Return ``True`` if any element of the vector ``x`` is positive or negative infinity, otherwise return ``False``.",
+    doc="Return ``True`` if any element of the vector ``a`` is positive or negative infinity, otherwise return ``False``.",
 )
 add_builtin(
     "isinf",
-    input_types={"x": quaternion(dtype=Scalar)},
+    input_types={"a": quaternion(dtype=Scalar)},
     value_type=builtins.bool,
     group="Vector Math",
-    doc="Return ``True`` if any element of the quaternion ``x`` is positive or negative infinity, otherwise return ``False``.",
+    doc="Return ``True`` if any element of the quaternion ``a`` is positive or negative infinity, otherwise return ``False``.",
 )
 add_builtin(
     "isinf",
-    input_types={"m": matrix(shape=(Any, Any), dtype=Scalar)},
+    input_types={"a": matrix(shape=(Any, Any), dtype=Scalar)},
     value_type=builtins.bool,
     group="Vector Math",
-    doc="Return ``True`` if any element of the matrix ``m`` is positive or negative infinity, otherwise return ``False``.",
+    doc="Return ``True`` if any element of the matrix ``a`` is positive or negative infinity, otherwise return ``False``.",
 )
 
 
-def infer_scalar_type(arg_types):
+def scalar_infer_type(arg_types: Mapping[str, type]):
     if arg_types is None:
         return Scalar
 
-    def iterate_scalar_types(arg_types):
-        for t in arg_types:
-            if hasattr(t, "_wp_scalar_type_"):
-                yield t._wp_scalar_type_
-            elif t in scalar_and_bool_types:
-                yield t
+    if isinstance(arg_types, Mapping):
+        arg_types = tuple(arg_types.values())
 
-    scalarTypes = set(iterate_scalar_types(arg_types))
-    if len(scalarTypes) > 1:
+    scalar_types = set()
+    for t in arg_types:
+        t = strip_reference(t)
+        if hasattr(t, "_wp_scalar_type_"):
+            scalar_types.add(t._wp_scalar_type_)
+        elif t in scalar_and_bool_types:
+            scalar_types.add(t)
+
+    if len(scalar_types) > 1:
         raise RuntimeError(
-            f"Couldn't figure out return type as arguments have multiple precisions: {list(scalarTypes)}"
+            f"Couldn't figure out return type as arguments have multiple precisions: {list(scalar_types)}"
         )
-    return list(scalarTypes)[0]
+    return next(iter(scalar_types))
 
 
-def sametype_scalar_value_func(arg_types, kwds, _):
+def scalar_sametypes_value_func(arg_types: Mapping[str, type], arg_values: Mapping[str, Any]):
     if arg_types is None:
         return Scalar
+
     if not sametypes(arg_types):
-        raise RuntimeError(f"Input types must be exactly the same, {list(arg_types)}")
+        raise RuntimeError(f"Input types must be exactly the same, got {[type_repr(t) for t in arg_types.values()]}")
+
+    return scalar_infer_type(arg_types)
+
 
-    return infer_scalar_type(arg_types)
+def float_infer_type(arg_types: Mapping[str, type]):
+    if arg_types is None:
+        return Float
+
+    return scalar_infer_type(arg_types)
+
+
+def float_sametypes_value_func(arg_types: Mapping[str, type], arg_values: Mapping[str, Any]):
+    if arg_types is None:
+        return Float
+
+    return scalar_sametypes_value_func(arg_types, arg_values)
 
 
 # ---------------------------------
@@ -405,290 +438,312 @@ def sametype_scalar_value_func(arg_types, kwds, _):
 
 add_builtin(
     "dot",
-    input_types={"x": vector(length=Any, dtype=Scalar), "y": vector(length=Any, dtype=Scalar)},
+    input_types={"a": vector(length=Any, dtype=Scalar), "b": vector(length=Any, dtype=Scalar)},
     constraint=sametypes,
-    value_func=sametype_scalar_value_func,
+    value_func=scalar_sametypes_value_func,
     group="Vector Math",
     doc="Compute the dot product between two vectors.",
 )
 add_builtin(
     "ddot",
-    input_types={"x": matrix(shape=(Any, Any), dtype=Scalar), "y": matrix(shape=(Any, Any), dtype=Scalar)},
+    input_types={"a": matrix(shape=(Any, Any), dtype=Scalar), "b": matrix(shape=(Any, Any), dtype=Scalar)},
     constraint=sametypes,
-    value_func=sametype_scalar_value_func,
+    value_func=scalar_sametypes_value_func,
     group="Vector Math",
     doc="Compute the double dot product between two matrices.",
 )
 
 add_builtin(
     "min",
-    input_types={"x": vector(length=Any, dtype=Scalar), "y": vector(length=Any, dtype=Scalar)},
+    input_types={"a": vector(length=Any, dtype=Scalar), "b": vector(length=Any, dtype=Scalar)},
     constraint=sametypes,
-    value_func=sametype_value_func(vector(length=Any, dtype=Scalar)),
+    value_func=sametypes_create_value_func(vector(length=Any, dtype=Scalar)),
     doc="Return the element-wise minimum of two vectors.",
     group="Vector Math",
 )
 add_builtin(
     "max",
-    input_types={"x": vector(length=Any, dtype=Scalar), "y": vector(length=Any, dtype=Scalar)},
+    input_types={"a": vector(length=Any, dtype=Scalar), "b": vector(length=Any, dtype=Scalar)},
     constraint=sametypes,
-    value_func=sametype_value_func(vector(length=Any, dtype=Scalar)),
+    value_func=sametypes_create_value_func(vector(length=Any, dtype=Scalar)),
     doc="Return the element-wise maximum of two vectors.",
     group="Vector Math",
 )
 
 add_builtin(
     "min",
-    input_types={"v": vector(length=Any, dtype=Scalar)},
-    value_func=sametype_scalar_value_func,
-    doc="Return the minimum element of a vector ``v``.",
+    input_types={"a": vector(length=Any, dtype=Scalar)},
+    value_func=scalar_sametypes_value_func,
+    doc="Return the minimum element of a vector ``a``.",
     group="Vector Math",
 )
 add_builtin(
     "max",
-    input_types={"v": vector(length=Any, dtype=Scalar)},
-    value_func=sametype_scalar_value_func,
-    doc="Return the maximum element of a vector ``v``.",
+    input_types={"a": vector(length=Any, dtype=Scalar)},
+    value_func=scalar_sametypes_value_func,
+    doc="Return the maximum element of a vector ``a``.",
     group="Vector Math",
 )
 
 add_builtin(
     "argmin",
-    input_types={"v": vector(length=Any, dtype=Scalar)},
-    value_func=lambda arg_types, kwds, _: warp.uint32,
-    doc="Return the index of the minimum element of a vector ``v``.",
+    input_types={"a": vector(length=Any, dtype=Scalar)},
+    value_func=lambda arg_types, arg_values: warp.uint32,
+    doc="Return the index of the minimum element of a vector ``a``.",
     group="Vector Math",
     missing_grad=True,
 )
 add_builtin(
     "argmax",
-    input_types={"v": vector(length=Any, dtype=Scalar)},
-    value_func=lambda arg_types, kwds, _: warp.uint32,
-    doc="Return the index of the maximum element of a vector ``v``.",
+    input_types={"a": vector(length=Any, dtype=Scalar)},
+    value_func=lambda arg_types, arg_values: warp.uint32,
+    doc="Return the index of the maximum element of a vector ``a``.",
     group="Vector Math",
     missing_grad=True,
 )
 
+add_builtin(
+    "abs",
+    input_types={"x": vector(length=Any, dtype=Scalar)},
+    constraint=sametypes,
+    value_func=sametypes_create_value_func(vector(length=Any, dtype=Scalar)),
+    doc="Return the absolute values of the elements of ``x``.",
+    group="Vector Math",
+)
+
+add_builtin(
+    "sign",
+    input_types={"x": vector(length=Any, dtype=Scalar)},
+    constraint=sametypes,
+    value_func=sametypes_create_value_func(Scalar),
+    doc="Return -1 for the negative elements of ``x``, and 1 otherwise.",
+    group="Vector Math",
+)
 
-def value_func_outer(arg_types, kwds, _):
+
+def outer_value_func(arg_types: Mapping[str, type], arg_values: Mapping[str, Any]):
     if arg_types is None:
         return matrix(shape=(Any, Any), dtype=Scalar)
 
-    scalarType = infer_scalar_type(arg_types)
-    vectorLengths = [t._length_ for t in arg_types]
+    arg_type_values = tuple(arg_types.values())
+    scalarType = scalar_infer_type(arg_type_values)
+    vectorLengths = tuple(t._length_ for t in arg_type_values)
     return matrix(shape=(vectorLengths), dtype=scalarType)
 
 
 add_builtin(
     "outer",
-    input_types={"x": vector(length=Any, dtype=Scalar), "y": vector(length=Any, dtype=Scalar)},
-    value_func=value_func_outer,
+    input_types={"a": vector(length=Any, dtype=Scalar), "b": vector(length=Any, dtype=Scalar)},
+    value_func=outer_value_func,
     group="Vector Math",
-    doc="Compute the outer product ``x*y^T`` for two vectors.",
+    doc="Compute the outer product ``a*b^T`` for two vectors.",
 )
 
 add_builtin(
     "cross",
-    input_types={"x": vector(length=3, dtype=Scalar), "y": vector(length=3, dtype=Scalar)},
-    value_func=sametype_value_func(vector(length=3, dtype=Scalar)),
+    input_types={"a": vector(length=3, dtype=Scalar), "b": vector(length=3, dtype=Scalar)},
+    value_func=sametypes_create_value_func(vector(length=3, dtype=Scalar)),
     group="Vector Math",
     doc="Compute the cross product of two 3D vectors.",
 )
 add_builtin(
     "skew",
-    input_types={"x": vector(length=3, dtype=Scalar)},
-    value_func=lambda arg_types, kwds, _: matrix(shape=(3, 3), dtype=arg_types[0]._wp_scalar_type_),
+    input_types={"vec": vector(length=3, dtype=Scalar)},
+    value_func=lambda arg_types, arg_values: matrix(shape=(3, 3), dtype=arg_types["vec"]._wp_scalar_type_),
     group="Vector Math",
-    doc="Compute the skew-symmetric 3x3 matrix for a 3D vector ``x``.",
+    doc="Compute the skew-symmetric 3x3 matrix for a 3D vector ``vec``.",
 )
 
 add_builtin(
     "length",
-    input_types={"x": vector(length=Any, dtype=Float)},
-    value_func=sametype_scalar_value_func,
+    input_types={"a": vector(length=Any, dtype=Float)},
+    value_func=float_sametypes_value_func,
     group="Vector Math",
-    doc="Compute the length of a floating-point vector ``x``.",
+    doc="Compute the length of a floating-point vector ``a``.",
     require_original_output_arg=True,
 )
 add_builtin(
     "length",
-    input_types={"x": quaternion(dtype=Float)},
-    value_func=sametype_scalar_value_func,
+    input_types={"a": quaternion(dtype=Float)},
+    value_func=float_sametypes_value_func,
     group="Vector Math",
-    doc="Compute the length of a quaternion ``x``.",
+    doc="Compute the length of a quaternion ``a``.",
     require_original_output_arg=True,
 )
 add_builtin(
     "length_sq",
-    input_types={"x": vector(length=Any, dtype=Scalar)},
-    value_func=sametype_scalar_value_func,
+    input_types={"a": vector(length=Any, dtype=Scalar)},
+    value_func=scalar_sametypes_value_func,
     group="Vector Math",
-    doc="Compute the squared length of a vector ``x``.",
+    doc="Compute the squared length of a vector ``a``.",
 )
 add_builtin(
     "length_sq",
-    input_types={"x": quaternion(dtype=Scalar)},
-    value_func=sametype_scalar_value_func,
+    input_types={"a": quaternion(dtype=Scalar)},
+    value_func=scalar_sametypes_value_func,
     group="Vector Math",
-    doc="Compute the squared length of a quaternion ``x``.",
+    doc="Compute the squared length of a quaternion ``a``.",
 )
 add_builtin(
     "normalize",
-    input_types={"x": vector(length=Any, dtype=Float)},
-    value_func=sametype_value_func(vector(length=Any, dtype=Scalar)),
+    input_types={"a": vector(length=Any, dtype=Float)},
+    value_func=sametypes_create_value_func(vector(length=Any, dtype=Float)),
     group="Vector Math",
-    doc="Compute the normalized value of ``x``. If ``length(x)`` is 0 then the zero vector is returned.",
+    doc="Compute the normalized value of ``a``. If ``length(a)`` is 0 then the zero vector is returned.",
     require_original_output_arg=True,
 )
 add_builtin(
     "normalize",
-    input_types={"x": quaternion(dtype=Float)},
-    value_func=sametype_value_func(quaternion(dtype=Scalar)),
+    input_types={"a": quaternion(dtype=Float)},
+    value_func=sametypes_create_value_func(quaternion(dtype=Float)),
     group="Vector Math",
-    doc="Compute the normalized value of ``x``. If ``length(x)`` is 0, then the zero quaternion is returned.",
+    doc="Compute the normalized value of ``a``. If ``length(a)`` is 0, then the zero quaternion is returned.",
 )
 
 add_builtin(
     "transpose",
-    input_types={"m": matrix(shape=(Any, Any), dtype=Scalar)},
-    value_func=lambda arg_types, kwds, _: matrix(
-        shape=(arg_types[0]._shape_[1], arg_types[0]._shape_[0]), dtype=arg_types[0]._wp_scalar_type_
+    input_types={"a": matrix(shape=(Any, Any), dtype=Scalar)},
+    value_func=lambda arg_types, arg_values: matrix(
+        shape=(arg_types["a"]._shape_[1], arg_types["a"]._shape_[0]), dtype=arg_types["a"]._wp_scalar_type_
     ),
     group="Vector Math",
-    doc="Return the transpose of the matrix ``m``.",
+    doc="Return the transpose of the matrix ``a``.",
 )
 
 
-def value_func_mat_inv(arg_types, kwds, _):
+def inverse_value_func(arg_types: Mapping[str, type], arg_values: Mapping[str, Any]):
     if arg_types is None:
         return matrix(shape=(Any, Any), dtype=Float)
-    return arg_types[0]
+
+    return arg_types["a"]
 
 
 add_builtin(
     "inverse",
-    input_types={"m": matrix(shape=(2, 2), dtype=Float)},
-    value_func=value_func_mat_inv,
+    input_types={"a": matrix(shape=(2, 2), dtype=Float)},
+    value_func=inverse_value_func,
     group="Vector Math",
-    doc="Return the inverse of a 2x2 matrix ``m``.",
+    doc="Return the inverse of a 2x2 matrix ``a``.",
     require_original_output_arg=True,
 )
 
 add_builtin(
     "inverse",
-    input_types={"m": matrix(shape=(3, 3), dtype=Float)},
-    value_func=value_func_mat_inv,
+    input_types={"a": matrix(shape=(3, 3), dtype=Float)},
+    value_func=inverse_value_func,
     group="Vector Math",
-    doc="Return the inverse of a 3x3 matrix ``m``.",
+    doc="Return the inverse of a 3x3 matrix ``a``.",
     require_original_output_arg=True,
 )
 
 add_builtin(
     "inverse",
-    input_types={"m": matrix(shape=(4, 4), dtype=Float)},
-    value_func=value_func_mat_inv,
+    input_types={"a": matrix(shape=(4, 4), dtype=Float)},
+    value_func=inverse_value_func,
     group="Vector Math",
-    doc="Return the inverse of a 4x4 matrix ``m``.",
+    doc="Return the inverse of a 4x4 matrix ``a``.",
     require_original_output_arg=True,
 )
 
 
-def value_func_mat_det(arg_types, kwds, _):
+def determinant_value_func(arg_types: Mapping[str, type], arg_values: Mapping[str, Any]):
     if arg_types is None:
-        return Scalar
-    return arg_types[0]._wp_scalar_type_
+        return Float
+
+    return arg_types["a"]._wp_scalar_type_
 
 
 add_builtin(
     "determinant",
-    input_types={"m": matrix(shape=(2, 2), dtype=Float)},
-    value_func=value_func_mat_det,
+    input_types={"a": matrix(shape=(2, 2), dtype=Float)},
+    value_func=determinant_value_func,
     group="Vector Math",
-    doc="Return the determinant of a 2x2 matrix ``m``.",
+    doc="Return the determinant of a 2x2 matrix ``a``.",
 )
 
 add_builtin(
     "determinant",
-    input_types={"m": matrix(shape=(3, 3), dtype=Float)},
-    value_func=value_func_mat_det,
+    input_types={"a": matrix(shape=(3, 3), dtype=Float)},
+    value_func=determinant_value_func,
     group="Vector Math",
-    doc="Return the determinant of a 3x3 matrix ``m``.",
+    doc="Return the determinant of a 3x3 matrix ``a``.",
 )
 
 add_builtin(
     "determinant",
-    input_types={"m": matrix(shape=(4, 4), dtype=Float)},
-    value_func=value_func_mat_det,
+    input_types={"a": matrix(shape=(4, 4), dtype=Float)},
+    value_func=determinant_value_func,
     group="Vector Math",
-    doc="Return the determinant of a 4x4 matrix ``m``.",
+    doc="Return the determinant of a 4x4 matrix ``a``.",
 )
 
 
-def value_func_mat_trace(arg_types, kwds, _):
+def trace_value_func(arg_types: Mapping[str, type], arg_values: Mapping[str, Any]):
     if arg_types is None:
         return Scalar
-    if arg_types[0]._shape_[0] != arg_types[0]._shape_[1]:
-        raise RuntimeError(f"Matrix shape is {arg_types[0]._shape_}. Cannot find the trace of non square matrices")
-    return arg_types[0]._wp_scalar_type_
+
+    if arg_types["a"]._shape_[0] != arg_types["a"]._shape_[1]:
+        raise RuntimeError(f"Matrix shape is {arg_types['a']._shape_}. Cannot find the trace of non square matrices")
+    return arg_types["a"]._wp_scalar_type_
 
 
 add_builtin(
     "trace",
-    input_types={"m": matrix(shape=(Any, Any), dtype=Scalar)},
-    value_func=value_func_mat_trace,
+    input_types={"a": matrix(shape=(Any, Any), dtype=Scalar)},
+    value_func=trace_value_func,
     group="Vector Math",
-    doc="Return the trace of the matrix ``m``.",
+    doc="Return the trace of the matrix ``a``.",
 )
 
 
-def value_func_diag(arg_types, kwds, _):
+def diag_value_func(arg_types: Mapping[str, type], arg_values: Mapping[str, Any]):
     if arg_types is None:
         return matrix(shape=(Any, Any), dtype=Scalar)
-    else:
-        return matrix(shape=(arg_types[0]._length_, arg_types[0]._length_), dtype=arg_types[0]._wp_scalar_type_)
+
+    return matrix(shape=(arg_types["vec"]._length_, arg_types["vec"]._length_), dtype=arg_types["vec"]._wp_scalar_type_)
 
 
 add_builtin(
     "diag",
-    input_types={"d": vector(length=Any, dtype=Scalar)},
-    value_func=value_func_diag,
+    input_types={"vec": vector(length=Any, dtype=Scalar)},
+    value_func=diag_value_func,
     group="Vector Math",
-    doc="Returns a matrix with the components of the vector ``d`` on the diagonal.",
+    doc="Returns a matrix with the components of the vector ``vec`` on the diagonal.",
 )
 
 
-def value_func_get_diag(arg_types, kwds, _):
+def get_diag_value_func(arg_types: Mapping[str, type], arg_values: Mapping[str, Any]):
     if arg_types is None:
         return vector(length=(Any), dtype=Scalar)
-    else:
-        if arg_types[0]._shape_[0] != arg_types[0]._shape_[1]:
-            raise RuntimeError(
-                f"Matrix shape is {arg_types[0]._shape_}; get_diag is only available for square matrices."
-            )
-        return vector(length=arg_types[0]._shape_[0], dtype=arg_types[0]._wp_scalar_type_)
+
+    if arg_types["mat"]._shape_[0] != arg_types["mat"]._shape_[1]:
+        raise RuntimeError(
+            f"Matrix shape is {arg_types['mat']._shape_}; get_diag is only available for square matrices."
+        )
+    return vector(length=arg_types["mat"]._shape_[0], dtype=arg_types["mat"]._wp_scalar_type_)
 
 
 add_builtin(
     "get_diag",
-    input_types={"m": matrix(shape=(Any, Any), dtype=Scalar)},
-    value_func=value_func_get_diag,
+    input_types={"mat": matrix(shape=(Any, Any), dtype=Scalar)},
+    value_func=get_diag_value_func,
     group="Vector Math",
-    doc="Returns a vector containing the diagonal elements of the square matrix ``m``.",
+    doc="Returns a vector containing the diagonal elements of the square matrix ``mat``.",
 )
 
 add_builtin(
     "cw_mul",
-    input_types={"x": vector(length=Any, dtype=Scalar), "y": vector(length=Any, dtype=Scalar)},
+    input_types={"a": vector(length=Any, dtype=Scalar), "b": vector(length=Any, dtype=Scalar)},
     constraint=sametypes,
-    value_func=sametype_value_func(vector(length=Any, dtype=Scalar)),
+    value_func=sametypes_create_value_func(vector(length=Any, dtype=Scalar)),
     group="Vector Math",
     doc="Component-wise multiplication of two vectors.",
 )
 add_builtin(
     "cw_div",
-    input_types={"x": vector(length=Any, dtype=Scalar), "y": vector(length=Any, dtype=Scalar)},
+    input_types={"a": vector(length=Any, dtype=Scalar), "b": vector(length=Any, dtype=Scalar)},
     constraint=sametypes,
-    value_func=sametype_value_func(vector(length=Any, dtype=Scalar)),
+    value_func=sametypes_create_value_func(vector(length=Any, dtype=Scalar)),
     group="Vector Math",
     doc="Component-wise division of two vectors.",
     require_original_output_arg=True,
@@ -696,17 +751,17 @@ add_builtin(
 
 add_builtin(
     "cw_mul",
-    input_types={"x": matrix(shape=(Any, Any), dtype=Scalar), "y": matrix(shape=(Any, Any), dtype=Scalar)},
+    input_types={"a": matrix(shape=(Any, Any), dtype=Scalar), "b": matrix(shape=(Any, Any), dtype=Scalar)},
     constraint=sametypes,
-    value_func=sametype_value_func(matrix(shape=(Any, Any), dtype=Scalar)),
+    value_func=sametypes_create_value_func(matrix(shape=(Any, Any), dtype=Scalar)),
     group="Vector Math",
     doc="Component-wise multiplication of two matrices.",
 )
 add_builtin(
     "cw_div",
-    input_types={"x": matrix(shape=(Any, Any), dtype=Scalar), "y": matrix(shape=(Any, Any), dtype=Scalar)},
+    input_types={"a": matrix(shape=(Any, Any), dtype=Scalar), "b": matrix(shape=(Any, Any), dtype=Scalar)},
     constraint=sametypes,
-    value_func=sametype_value_func(matrix(shape=(Any, Any), dtype=Scalar)),
+    value_func=sametypes_create_value_func(matrix(shape=(Any, Any), dtype=Scalar)),
     group="Vector Math",
     doc="Component-wise division of two matrices.",
     require_original_output_arg=True,
@@ -719,7 +774,7 @@ for t in scalar_types_all:
     for u in scalar_types_all:
         add_builtin(
             t.__name__,
-            input_types={"u": u},
+            input_types={"a": u},
             value_type=t,
             doc="",
             hidden=True,
@@ -729,203 +784,231 @@ for t in scalar_types_all:
         )
 
 
-def vector_constructor_func(arg_types, kwds, templates):
+def vector_value_func(arg_types: Mapping[str, type], arg_values: Mapping[str, Any]):
     if arg_types is None:
         return vector(length=Any, dtype=Scalar)
 
-    if templates is None or len(templates) == 0:
-        # handle construction of anonymous (undeclared) vector types
-
-        if "length" in kwds:
-            if len(arg_types) == 0:
-                if "dtype" not in kwds:
-                    raise RuntimeError(
-                        "vec() must have dtype as a keyword argument if it has no positional arguments, e.g.: wp.vector(length=5, dtype=wp.float32)"
-                    )
-
-                # zero initialization e.g.: wp.vector(length=5, dtype=wp.float32)
-                veclen = kwds["length"]
-                vectype = kwds["dtype"]
-
-            elif len(arg_types) == 1:
-                # value initialization e.g.: wp.vec(1.0, length=5)
-                veclen = kwds["length"]
-                vectype = arg_types[0]
-                if type_is_vector(vectype):
-                    # constructor from another vector
-                    if vectype._length_ != veclen:
-                        raise RuntimeError(
-                            f"Incompatible vector lengths for casting copy constructor, {veclen} vs {vectype._length_}"
-                        )
-                    vectype = vectype._wp_scalar_type_
-            else:
+    length = arg_values.get("length", None)
+    dtype = arg_values.get("dtype", None)
+
+    variadic_arg_types = arg_types.get("args", ())
+    variadic_arg_count = len(variadic_arg_types)
+    if variadic_arg_count == 0:
+        # Zero-initialization, e.g.: `wp.vecXX()`, `wp.vector(length=2, dtype=wp.float16)`.
+        if length is None:
+            raise RuntimeError("the `length` argument must be specified when zero-initializing a vector")
+
+        if dtype is None:
+            dtype = float32
+    elif variadic_arg_count == 1:
+        value_type = strip_reference(variadic_arg_types[0])
+        if type_is_vector(value_type):
+            # Copy constructor, e.g.: `wp.vecXX(other_vec)`, `wp.vector(other_vec)`.
+            if length is None:
+                length = value_type._length_
+            elif value_type._length_ != length:
                 raise RuntimeError(
-                    "vec() must have one scalar argument or the dtype keyword argument if the length keyword argument is specified, e.g.: wp.vec(1.0, length=5)"
+                    f"incompatible vector of length {length} given when copy constructing "
+                    f"a vector of length {value_type._length_}"
                 )
 
+            if dtype is None:
+                dtype = value_type._wp_scalar_type_
         else:
-            if len(arg_types) == 0:
+            # Initialization by filling a value, e.g.: `wp.vecXX(123)`,
+            # `wp.vector(123, length=2)`.
+            if length is None:
+                raise RuntimeError("the `length` argument must be specified when filling a vector with a value")
+
+            if dtype is None:
+                dtype = value_type
+            elif value_type != dtype:
                 raise RuntimeError(
-                    "vec() must have at least one numeric argument, if it's length, dtype is not specified"
+                    f"the value used to fill this vector is expected to be of the type `{dtype.__name__}`"
                 )
+    else:
+        # Initializing by value, e.g.: `wp.vec2(1, 2)`, `wp.vector(1, 2, length=2)`.
+        if length is None:
+            length = variadic_arg_count
+        elif length != variadic_arg_count:
+            raise RuntimeError(
+                f"incompatible number of values given ({variadic_arg_count}) "
+                f"when constructing a vector of length {length}"
+            )
 
-            if "dtype" in kwds:
-                # casting constructor
-                if len(arg_types) == 1 and types_equal(
-                    arg_types[0], vector(length=Any, dtype=Scalar), match_generic=True
-                ):
-                    veclen = arg_types[0]._length_
-                    vectype = kwds["dtype"]
-                    templates.append(veclen)
-                    templates.append(vectype)
-                    return vector(length=veclen, dtype=vectype)
-                raise RuntimeError(
-                    "vec() should not have dtype specified if numeric arguments are given, the dtype will be inferred from the argument types"
-                )
+        try:
+            value_type = scalar_infer_type(variadic_arg_types)
+        except RuntimeError:
+            raise RuntimeError("all values given when constructing a vector must have the same type") from None
 
-            # component wise construction of an anonymous vector, e.g. wp.vec(wp.float16(1.0), wp.float16(2.0), ....)
-            # we infer the length and data type from the number and type of the arg values
-            veclen = len(arg_types)
-            vectype = arg_types[0]
+        if dtype is None:
+            dtype = value_type
+        elif value_type != dtype:
+            raise RuntimeError(
+                f"all values used to initialize this vector matrix are expected to be of the type `{dtype.__name__}`"
+            )
 
-            if len(arg_types) == 1 and type_is_vector(vectype):
-                # constructor from another vector
-                veclen = vectype._length_
-                vectype = vectype._wp_scalar_type_
-            elif not all(vectype == t for t in arg_types):
-                raise RuntimeError(
-                    f"All numeric arguments to vec() constructor should have the same type, expected {veclen} arg_types of type {vectype}, received { ','.join([str(t) for t in arg_types]) }"
-                )
+    if length is None:
+        raise RuntimeError("could not infer the `length` argument when calling the `wp.vector()` function")
 
-        # update the templates list, so we can generate vec<len, type>() correctly in codegen
-        templates.append(veclen)
-        templates.append(vectype)
+    if dtype is None:
+        raise RuntimeError("could not infer the `dtype` argument when calling the `wp.vector()` function")
+
+    return vector(length=length, dtype=dtype)
 
-    else:
-        # construction of a predeclared type, e.g.: vec5d
-        veclen, vectype = templates
-        if len(arg_types) == 1 and type_is_vector(arg_types[0]):
-            # constructor from another vector
-            if arg_types[0]._length_ != veclen:
-                raise RuntimeError(
-                    f"Incompatible matrix sizes for casting copy constructor, {veclen} vs {arg_types[0]._length_}"
-                )
-        elif not all(vectype == t for t in arg_types):
-            raise RuntimeError(
-                f"All numeric arguments to vec() constructor should have the same type, expected {veclen} arg_types of type {vectype}, received { ','.join([str(t) for t in arg_types]) }"
-            )
 
-    retvalue = vector(length=veclen, dtype=vectype)
-    return retvalue
+def vector_dispatch_func(input_types: Mapping[str, type], return_type: Any, args: Mapping[str, Var]):
+    # We're in the codegen stage where we emit the code calling the built-in.
+    # Further validate the given argument values if needed and map them
+    # to the underlying C++ function's runtime and template params.
+
+    length = return_type._length_
+    dtype = return_type._wp_scalar_type_
+
+    variadic_args = args.get("args", ())
+
+    func_args = variadic_args
+    template_args = (length, dtype)
+    return (func_args, template_args)
 
 
 add_builtin(
     "vector",
-    input_types={"*arg_types": Scalar, "length": int, "dtype": Scalar},
+    input_types={"*args": Scalar, "length": int, "dtype": Scalar},
+    defaults={"length": None, "dtype": None},
     variadic=True,
-    initializer_list_func=lambda arg_types, _: len(arg_types) > 4,
-    value_func=vector_constructor_func,
+    initializer_list_func=lambda arg_types, arg_values: len(arg_types.get("args", ())) > 4,
+    value_func=vector_value_func,
+    export_func=lambda input_types: {k: v for k, v in input_types.items() if k not in ("length", "dtype")},
+    dispatch_func=vector_dispatch_func,
     native_func="vec_t",
-    doc="Construct a vector of with given length and dtype.",
+    doc="Construct a vector of given length and dtype.",
     group="Vector Math",
     export=False,
 )
 
 
-def matrix_constructor_func(arg_types, kwds, templates):
+def matrix_value_func(arg_types: Mapping[str, type], arg_values: Mapping[str, Any]):
     if arg_types is None:
         return matrix(shape=(Any, Any), dtype=Scalar)
 
-    if len(templates) == 0:
-        # anonymous construction
-        if "shape" not in kwds:
-            raise RuntimeError("shape keyword must be specified when calling matrix() function")
+    shape = arg_values.get("shape", None)
+    dtype = arg_values.get("dtype", None)
+
+    variadic_arg_types = arg_types.get("args", ())
+    variadic_arg_count = len(variadic_arg_types)
+    if variadic_arg_count == 0:
+        # Zero-initialization, e.g.: `wp.matXX()`, `wp.matrix(shape=(2, 2), dtype=wp.float16)`.
+        if shape is None:
+            raise RuntimeError("the `shape` argument must be specified when zero-initializing a matrix")
+
+        if dtype is None:
+            dtype = float32
+    elif variadic_arg_count == 1:
+        value_type = strip_reference(variadic_arg_types[0])
+        if type_is_matrix(value_type):
+            # Copy constructor, e.g.: `wp.matXX(other_mat)`, `wp.matrix(other_mat)`.
+            if shape is None:
+                shape = value_type._shape_
+            elif not seq_check_equal(value_type._shape_, shape):
+                raise RuntimeError(
+                    f"incompatible matrix of shape {tuple(shape)} given when copy constructing "
+                    f"a matrix of shape {tuple(value_type._shape_)}"
+                )
 
-        if len(arg_types) == 0:
-            if "dtype" not in kwds:
-                raise RuntimeError("matrix() must have dtype as a keyword argument if it has no positional arguments")
+            if dtype is None:
+                dtype = value_type._wp_scalar_type_
+        else:
+            # Initialization by filling a value, e.g.: `wp.matXX(123)`,
+            # `wp.matrix(123, shape=(2, 2))`.
+            if shape is None:
+                raise RuntimeError("the `shape` argument must be specified when filling a matrix with a value")
+
+            if dtype is None:
+                dtype = value_type
+            elif value_type != dtype:
+                raise RuntimeError(
+                    f"the value used to fill this matrix is expected to be of the type `{dtype.__name__}`"
+                )
+    else:
+        # Initializing by value, e.g.: `wp.mat22(1, 2, 3, 4)`, `wp.matrix(1, 2, 3, 4, shape=(2, 2))`.
+        if shape is None:
+            raise RuntimeError("the `shape` argument must be specified when initializing a matrix by value")
 
-            # zero initialization, e.g.: m = matrix(shape=(3,2), dtype=wp.float16)
-            shape = kwds["shape"]
-            dtype = kwds["dtype"]
+        if all(type_is_vector(x) for x in variadic_arg_types):
+            if shape[1] != variadic_arg_count:
+                raise RuntimeError(
+                    f"incompatible number of column vectors given ({variadic_arg_count}) "
+                    f"when constructing a matrix of shape {tuple(shape)}"
+                )
 
-        else:
-            # value initialization, e.g.: m = matrix(1.0, shape=(3,2))
-            shape = kwds["shape"]
-            dtype = arg_types[0]
-
-            if len(arg_types) == 1 and type_is_matrix(dtype):
-                # constructor from another matrix
-                if arg_types[0]._shape_ != shape:
-                    raise RuntimeError(
-                        f"Incompatible matrix sizes for casting copy constructor, {shape} vs {arg_types[0]._shape_}"
-                    )
-                dtype = dtype._wp_scalar_type_
-            elif len(arg_types) > 1 and len(arg_types) != shape[0] * shape[1]:
+            if any(x._length_ != shape[0] for x in variadic_arg_types):
                 raise RuntimeError(
-                    "Wrong number of arguments for matrix() function, must initialize with either a scalar value, or m*n values"
+                    f"incompatible column vector lengths given when constructing a matrix of shape {tuple(shape)}"
                 )
+        elif shape[0] * shape[1] != variadic_arg_count:
+            raise RuntimeError(
+                f"incompatible number of values given ({variadic_arg_count}) "
+                f"when constructing a matrix of shape {tuple(shape)}"
+            )
 
-        templates.append(shape[0])
-        templates.append(shape[1])
-        templates.append(dtype)
+        try:
+            value_type = scalar_infer_type(variadic_arg_types)
+        except RuntimeError:
+            raise RuntimeError("all values given when constructing a matrix must have the same type") from None
 
-    else:
-        # predeclared type, e.g.: mat32d
-        shape = (templates[0], templates[1])
-        dtype = templates[2]
-
-        if len(arg_types) > 0:
-            if len(arg_types) == 1 and type_is_matrix(arg_types[0]):
-                # constructor from another matrix with same dimension but possibly different type
-                if arg_types[0]._shape_ != shape:
-                    raise RuntimeError(
-                        f"Incompatible matrix sizes for casting copy constructor, {shape} vs {arg_types[0]._shape_}"
-                    )
-            else:
-                # check scalar arg type matches declared type
-                if infer_scalar_type(arg_types) != dtype:
-                    raise RuntimeError("Wrong scalar type for mat {} constructor".format(",".join(map(str, templates))))
-
-                # check vector arg type matches declared type
-                if all(type_is_vector(a) for a in arg_types):
-                    cols = len(arg_types)
-                    if shape[1] != cols:
-                        raise RuntimeError(
-                            "Wrong number of vectors when attempting to construct a matrix with column vectors"
-                        )
-
-                    if not all(a._length_ == shape[0] for a in arg_types):
-                        raise RuntimeError(
-                            "Wrong vector row count when attempting to construct a matrix with column vectors"
-                        )
-                else:
-                    # check that we either got 1 arg (scalar construction), or enough values for whole matrix
-                    size = shape[0] * shape[1]
-                    if len(arg_types) > 1 and len(arg_types) != size:
-                        raise RuntimeError(
-                            "Wrong number of scalars when attempting to construct a matrix from a list of components"
-                        )
+        if dtype is None:
+            dtype = value_type
+        elif value_type != dtype:
+            raise RuntimeError(
+                f"all values used to initialize this matrix are expected to be of the type `{dtype.__name__}`"
+            )
+
+    if shape is None:
+        raise RuntimeError("could not infer the `shape` argument when calling the `wp.matrix()` function")
+
+    if dtype is None:
+        raise RuntimeError("could not infer the `dtype` argument when calling the `wp.matrix()` function")
 
     return matrix(shape=shape, dtype=dtype)
 
 
+def matrix_dispatch_func(input_types: Mapping[str, type], return_type: Any, args: Mapping[str, Var]):
+    # We're in the codegen stage where we emit the code calling the built-in.
+    # Further validate the given argument values if needed and map them
+    # to the underlying C++ function's runtime and template params.
+
+    shape = return_type._shape_
+    dtype = return_type._wp_scalar_type_
+
+    variadic_args = args.get("args", ())
+
+    func_args = variadic_args
+    template_args = (*shape, dtype)
+    return (func_args, template_args)
+
+
 # only use initializer list if matrix size < 5x5, or for scalar construction
-def matrix_initlist_func(arg_types, templates):
-    m, n, dtype = templates
+def matrix_initializer_list_func(args, return_type):
+    shape = return_type._shape_
+
+    variadic_args = args.get("args", ())
+    variadic_arg_count = len(variadic_args)
     return not (
-        len(arg_types) == 0
-        or len(arg_types) == 1  # zero construction
-        or (m == n and n < 5)  # scalar construction  # value construction for small matrices
+        variadic_arg_count <= 1  # zero/fill initialization
+        or (shape[0] == shape[1] and shape[1] < 5)  # value construction for small matrices
     )
 
 
 add_builtin(
     "matrix",
-    input_types={"*arg_types": Scalar, "shape": Tuple[int, int], "dtype": Scalar},
+    input_types={"*args": Scalar, "shape": Tuple[int, int], "dtype": Scalar},
+    defaults={"shape": None, "dtype": None},
     variadic=True,
-    initializer_list_func=matrix_initlist_func,
-    value_func=matrix_constructor_func,
+    value_func=matrix_value_func,
+    export_func=lambda input_types: {k: v for k, v in input_types.items() if k not in ("shape", "dtype")},
+    dispatch_func=matrix_dispatch_func,
+    initializer_list_func=matrix_initializer_list_func,
     native_func="mat_t",
     doc="Construct a matrix. If the positional ``arg_types`` are not given, then matrix will be zero-initialized.",
     group="Vector Math",
@@ -933,69 +1016,95 @@ add_builtin(
 )
 
 
-# identity:
-def matrix_identity_value_func(arg_types, kwds, templates):
+def identity_value_func(arg_types: Mapping[str, type], arg_values: Mapping[str, Any]):
     if arg_types is None:
         return matrix(shape=(Any, Any), dtype=Scalar)
 
-    if len(arg_types):
-        raise RuntimeError("identity() function does not accept positional arguments")
+    n = arg_values["n"]
+    dtype = arg_values["dtype"]
 
-    if "n" not in kwds:
-        raise RuntimeError("'n' keyword argument must be specified when calling identity() function")
+    if n is None:
+        raise RuntimeError("'n' must be a constant when calling identity()")
 
-    if "dtype" not in kwds:
-        raise RuntimeError("'dtype' keyword argument must be specified when calling identity() function")
+    return matrix(shape=(n, n), dtype=dtype)
 
-    n, dtype = [kwds["n"], kwds["dtype"]]
 
-    if n is None:
-        raise RuntimeError("'n' must be a constant when calling identity() function")
+def identity_dispatch_func(input_types: Mapping[str, type], return_type: Any, args: Mapping[str, Var]):
+    # We're in the codegen stage where we emit the code calling the built-in.
+    # Further validate the given argument values if needed and map them
+    # to the underlying C++ function's runtime and template params.
 
-    templates.append(n)
-    templates.append(dtype)
+    shape = return_type._shape_
+    dtype = return_type._wp_scalar_type_
 
-    return matrix(shape=(n, n), dtype=dtype)
+    func_args = ()
+    template_args = (shape[0], dtype)
+    return (func_args, template_args)
 
 
 add_builtin(
     "identity",
     input_types={"n": int, "dtype": Scalar},
-    value_func=matrix_identity_value_func,
-    variadic=True,
+    value_func=identity_value_func,
+    export_func=lambda input_types: {k: v for k, v in input_types.items() if k != "dtype"},
+    dispatch_func=identity_dispatch_func,
     doc="Create an identity matrix with shape=(n,n) with the type given by ``dtype``.",
     group="Vector Math",
     export=False,
 )
 
 
-def matrix_transform_value_func(arg_types, kwds, templates):
-    if templates is None:
+def matrix_transform_value_func(arg_types: Mapping[str, type], arg_values: Mapping[str, Any]):
+    if arg_types is None:
         return matrix(shape=(4, 4), dtype=Float)
 
-    if len(templates) == 0:
-        raise RuntimeError("Cannot use a generic type name in a kernel")
+    dtype = arg_values.get("dtype", None)
 
-    m, n, dtype = templates
-    if (m, n) != (4, 4):
-        raise RuntimeError("Can only construct 4x4 matrices with position, rotation and scale")
-    if infer_scalar_type(arg_types) != dtype:
-        raise RuntimeError("Wrong scalar type for mat<{}> constructor".format(",".join(map(str, templates))))
+    value_arg_types = tuple(v for k, v in arg_types.items() if k != "dtype")
+    try:
+        value_type = scalar_infer_type(value_arg_types)
+    except RuntimeError:
+        raise RuntimeError(
+            "all values given when constructing a transformation matrix must have the same type"
+        ) from None
+
+    if dtype is None:
+        dtype = value_type
+    elif value_type != dtype:
+        raise RuntimeError(
+            f"all values used to initialize this transformation matrix are expected to be of the type `{dtype.__name__}`"
+        )
 
     return matrix(shape=(4, 4), dtype=dtype)
 
 
+def matrix_transform_dispatch_func(input_types: Mapping[str, type], return_type: Any, args: Mapping[str, Var]):
+    # We're in the codegen stage where we emit the code calling the built-in.
+    # Further validate the given argument values if needed and map them
+    # to the underlying C++ function's runtime and template params.
+
+    dtype = return_type._wp_scalar_type_
+
+    func_args = tuple(v for k, v in args.items() if k != "dtype")
+    template_args = (4, 4, dtype)
+    return (func_args, template_args)
+
+
 add_builtin(
     "matrix",
     input_types={
         "pos": vector(length=3, dtype=Float),
         "rot": quaternion(dtype=Float),
         "scale": vector(length=3, dtype=Float),
+        "dtype": Float,
     },
+    defaults={"dtype": None},
     value_func=matrix_transform_value_func,
+    export_func=lambda input_types: {k: v for k, v in input_types.items() if k != "dtype"},
+    dispatch_func=matrix_transform_dispatch_func,
     native_func="mat_t",
     doc="""Construct a 4x4 transformation matrix that applies the transformations as
-    Translation(pos)*Rotation(rot)*Scale(scale) when applied to column vectors, i.e.: y = (TRS)*x""",
+    Translation(pos)*Rotation(rot)*Scaling(scale) when applied to column vectors, i.e.: y = (TRS)*x""",
     group="Vector Math",
     export=False,
 )
@@ -1050,42 +1159,69 @@ add_builtin(
 # Quaternion Math
 
 
-def quaternion_value_func(arg_types, kwds, templates):
+def quaternion_value_func(arg_types: Mapping[str, type], arg_values: Mapping[str, Any]):
     if arg_types is None:
         return quaternion(dtype=Float)
 
-    if len(templates) == 0:
-        if "dtype" in kwds:
-            # casting constructor
-            dtype = kwds["dtype"]
-        else:
-            # if constructing anonymous quat type then infer output type from arguments
-            dtype = infer_scalar_type(arg_types)
-        templates.append(dtype)
+    dtype = arg_values.get("dtype", None)
+
+    variadic_arg_types = tuple(v for k, v in arg_types.items() if k != "dtype")
+    variadic_arg_count = len(variadic_arg_types)
+
+    if variadic_arg_count == 0:
+        # Zero-initialization, e.g.: `wp.quat()`, `wp.quaternion(dtype=wp.float16)`.
+        if dtype is None:
+            dtype = float32
+        elif dtype not in float_types:
+            raise RuntimeError(
+                f"a float type is expected when zero-initializing a quaternion but got `{type(dtype).__name__}` instead"
+            )
+    elif variadic_arg_count == 1:
+        if type_is_quaternion(variadic_arg_types[0]):
+            # Copy constructor, e.g.: `wp.quat(other_vec)`, `wp.quaternion(other_vec)`.
+            in_quat = variadic_arg_types[0]
+            if dtype is None:
+                dtype = in_quat._wp_scalar_type_
     else:
-        # if constructing predeclared type then check arg_types match expectation
-        if len(arg_types) > 0 and infer_scalar_type(arg_types) != templates[0]:
-            raise RuntimeError("Wrong scalar type for quat {} constructor".format(",".join(map(str, templates))))
+        try:
+            value_type = scalar_infer_type(variadic_arg_types)
+        except RuntimeError:
+            raise RuntimeError("all values given when constructing a quaternion must have the same type") from None
+
+        if dtype is None:
+            dtype = value_type
+        elif value_type != dtype:
+            raise RuntimeError(
+                f"all values used to initialize this quaternion are expected to be of the type `{dtype.__name__}`"
+            )
 
-    return quaternion(dtype=templates[0])
+    if dtype is None:
+        raise RuntimeError("could not infer the `dtype` argument when calling the `wp.quaternion()` function")
 
+    return quaternion(dtype=dtype)
 
-def quat_cast_value_func(arg_types, kwds, templates):
-    if arg_types is None:
-        raise RuntimeError("Missing quaternion argument.")
-    if "dtype" not in kwds:
-        raise RuntimeError("Missing 'dtype' kwd.")
 
-    dtype = kwds["dtype"]
-    templates.append(dtype)
+def quaternion_dispatch_func(input_types: Mapping[str, type], return_type: Any, args: Mapping[str, Var]):
+    # We're in the codegen stage where we emit the code calling the built-in.
+    # Further validate the given argument values if needed and map them
+    # to the underlying C++ function's runtime and template params.
 
-    return quaternion(dtype=dtype)
+    dtype = return_type._wp_scalar_type_
+
+    variadic_args = tuple(v for k, v in args.items() if k != "dtype")
+
+    func_args = variadic_args
+    template_args = (dtype,)
+    return (func_args, template_args)
 
 
 add_builtin(
     "quaternion",
-    input_types={},
+    input_types={"dtype": Float},
+    defaults={"dtype": None},
     value_func=quaternion_value_func,
+    export_func=lambda input_types: {k: v for k, v in input_types.items() if k != "dtype"},
+    dispatch_func=quaternion_dispatch_func,
     native_func="quat_t",
     group="Quaternion Math",
     doc="""Construct a zero-initialized quaternion. Quaternions are laid out as
@@ -1096,6 +1232,8 @@ add_builtin(
     "quaternion",
     input_types={"x": Float, "y": Float, "z": Float, "w": Float},
     value_func=quaternion_value_func,
+    export_func=lambda input_types: {k: v for k, v in input_types.items() if k != "dtype"},
+    dispatch_func=quaternion_dispatch_func,
     native_func="quat_t",
     group="Quaternion Math",
     doc="Create a quaternion using the supplied components (type inferred from component type).",
@@ -1103,17 +1241,24 @@ add_builtin(
 )
 add_builtin(
     "quaternion",
-    input_types={"i": vector(length=3, dtype=Float), "r": Float},
+    input_types={"ijk": vector(length=3, dtype=Float), "real": Float, "dtype": Float},
+    defaults={"dtype": None},
     value_func=quaternion_value_func,
+    export_func=lambda input_types: {k: v for k, v in input_types.items() if k != "dtype"},
+    dispatch_func=quaternion_dispatch_func,
     native_func="quat_t",
     group="Quaternion Math",
     doc="Create a quaternion using the supplied vector/scalar (type inferred from scalar type).",
     export=False,
 )
+
 add_builtin(
     "quaternion",
-    input_types={"q": quaternion(dtype=Float)},
-    value_func=quat_cast_value_func,
+    input_types={"quat": quaternion(dtype=Float), "dtype": Float},
+    defaults={"dtype": None},
+    value_func=quaternion_value_func,
+    export_func=lambda input_types: {k: v for k, v in input_types.items() if k != "dtype"},
+    dispatch_func=quaternion_dispatch_func,
     native_func="quat_t",
     group="Quaternion Math",
     doc="Construct a quaternion of type dtype from another quaternion of a different dtype.",
@@ -1121,26 +1266,34 @@ add_builtin(
 )
 
 
-def quat_identity_value_func(arg_types, kwds, templates):
-    # if arg_types is None then we are in 'export' mode
+def quat_identity_value_func(arg_types: Mapping[str, type], arg_values: Mapping[str, Any]):
     if arg_types is None:
+        # return quaternion(dtype=Float)
         return quatf
 
-    if "dtype" not in kwds:
-        # defaulting to float32 to preserve current behavior:
-        dtype = float32
-    else:
-        dtype = kwds["dtype"]
+    dtype = arg_types.get("dtype", float32)
+    return quaternion(dtype=dtype)
 
-    templates.append(dtype)
 
-    return quaternion(dtype=dtype)
+def quat_identity_dispatch_func(input_types: Mapping[str, type], return_type: Any, args: Mapping[str, Var]):
+    # We're in the codegen stage where we emit the code calling the built-in.
+    # Further validate the given argument values if needed and map them
+    # to the underlying C++ function's runtime and template params.
+
+    dtype = return_type._wp_scalar_type_
+
+    func_args = ()
+    template_args = (dtype,)
+    return (func_args, template_args)
 
 
 add_builtin(
     "quat_identity",
-    input_types={},
+    input_types={"dtype": Float},
+    defaults={"dtype": None},
     value_func=quat_identity_value_func,
+    export_func=lambda input_types: {},
+    dispatch_func=quat_identity_dispatch_func,
     group="Quaternion Math",
     doc="Construct an identity quaternion with zero imaginary part and real part of 1.0",
     export=True,
@@ -1149,72 +1302,72 @@ add_builtin(
 add_builtin(
     "quat_from_axis_angle",
     input_types={"axis": vector(length=3, dtype=Float), "angle": Float},
-    value_func=lambda arg_types, kwds, _: quaternion(dtype=infer_scalar_type(arg_types)),
+    value_func=lambda arg_types, arg_values: quaternion(dtype=float_infer_type(arg_types)),
     group="Quaternion Math",
     doc="Construct a quaternion representing a rotation of angle radians around the given axis.",
 )
 add_builtin(
     "quat_to_axis_angle",
-    input_types={"q": quaternion(dtype=Float), "axis": vector(length=3, dtype=Float), "angle": Float},
+    input_types={"quat": quaternion(dtype=Float), "axis": vector(length=3, dtype=Float), "angle": Float},
     value_type=None,
     group="Quaternion Math",
     doc="Extract the rotation axis and angle radians a quaternion represents.",
 )
 add_builtin(
     "quat_from_matrix",
-    input_types={"m": matrix(shape=(3, 3), dtype=Float)},
-    value_func=lambda arg_types, kwds, _: quaternion(dtype=infer_scalar_type(arg_types)),
+    input_types={"mat": matrix(shape=(3, 3), dtype=Float)},
+    value_func=lambda arg_types, arg_values: quaternion(dtype=float_infer_type(arg_types)),
     group="Quaternion Math",
     doc="Construct a quaternion from a 3x3 matrix.",
 )
 add_builtin(
     "quat_rpy",
     input_types={"roll": Float, "pitch": Float, "yaw": Float},
-    value_func=lambda arg_types, kwds, _: quaternion(dtype=infer_scalar_type(arg_types)),
+    value_func=lambda arg_types, arg_values: quaternion(dtype=float_infer_type(arg_types)),
     group="Quaternion Math",
     doc="Construct a quaternion representing a combined roll (z), pitch (x), yaw rotations (y) in radians.",
 )
 add_builtin(
     "quat_inverse",
-    input_types={"q": quaternion(dtype=Float)},
-    value_func=lambda arg_types, kwds, _: quaternion(dtype=infer_scalar_type(arg_types)),
+    input_types={"quat": quaternion(dtype=Float)},
+    value_func=lambda arg_types, arg_values: quaternion(dtype=float_infer_type(arg_types)),
     group="Quaternion Math",
     doc="Compute quaternion conjugate.",
 )
 add_builtin(
     "quat_rotate",
-    input_types={"q": quaternion(dtype=Float), "p": vector(length=3, dtype=Float)},
-    value_func=lambda arg_types, kwds, _: vector(length=3, dtype=infer_scalar_type(arg_types)),
+    input_types={"quat": quaternion(dtype=Float), "vec": vector(length=3, dtype=Float)},
+    value_func=lambda arg_types, arg_values: vector(length=3, dtype=float_infer_type(arg_types)),
     group="Quaternion Math",
     doc="Rotate a vector by a quaternion.",
 )
 add_builtin(
     "quat_rotate_inv",
-    input_types={"q": quaternion(dtype=Float), "p": vector(length=3, dtype=Float)},
-    value_func=lambda arg_types, kwds, _: vector(length=3, dtype=infer_scalar_type(arg_types)),
+    input_types={"quat": quaternion(dtype=Float), "vec": vector(length=3, dtype=Float)},
+    value_func=lambda arg_types, arg_values: vector(length=3, dtype=float_infer_type(arg_types)),
     group="Quaternion Math",
     doc="Rotate a vector by the inverse of a quaternion.",
 )
 add_builtin(
     "quat_slerp",
-    input_types={"q0": quaternion(dtype=Float), "q1": quaternion(dtype=Float), "t": Float},
-    value_func=lambda arg_types, kwds, _: quaternion(dtype=infer_scalar_type(arg_types)),
+    input_types={"a": quaternion(dtype=Float), "b": quaternion(dtype=Float), "t": Float},
+    value_func=lambda arg_types, arg_values: quaternion(dtype=float_infer_type(arg_types)),
     group="Quaternion Math",
     doc="Linearly interpolate between two quaternions.",
     require_original_output_arg=True,
 )
 add_builtin(
     "quat_to_matrix",
-    input_types={"q": quaternion(dtype=Float)},
-    value_func=lambda arg_types, kwds, _: matrix(shape=(3, 3), dtype=infer_scalar_type(arg_types)),
+    input_types={"quat": quaternion(dtype=Float)},
+    value_func=lambda arg_types, arg_values: matrix(shape=(3, 3), dtype=float_infer_type(arg_types)),
     group="Quaternion Math",
     doc="Convert a quaternion to a 3x3 rotation matrix.",
 )
 
 add_builtin(
     "dot",
-    input_types={"x": quaternion(dtype=Float), "y": quaternion(dtype=Float)},
-    value_func=sametype_scalar_value_func,
+    input_types={"a": quaternion(dtype=Float), "b": quaternion(dtype=Float)},
+    value_func=float_sametypes_value_func,
     group="Quaternion Math",
     doc="Compute the dot product between two quaternions.",
 )
@@ -1222,55 +1375,85 @@ add_builtin(
 # Transformations
 
 
-def transform_constructor_value_func(arg_types, kwds, templates):
-    if templates is None:
-        return transformation(dtype=Scalar)
+def transformation_value_func(arg_types: Mapping[str, type], arg_values: Mapping[str, Any]):
+    if arg_types is None:
+        return transformation(dtype=Float)
 
-    if len(templates) == 0:
-        # if constructing anonymous transform type then infer output type from arguments
-        dtype = infer_scalar_type(arg_types)
-        templates.append(dtype)
-    else:
-        # if constructing predeclared type then check arg_types match expectation
-        if infer_scalar_type(arg_types) != templates[0]:
-            raise RuntimeError(
-                f"Wrong scalar type for transform constructor expected {templates[0]}, got {','.join([ str(t) for t in arg_types])}"
-            )
+    try:
+        value_type = float_infer_type(arg_types)
+    except RuntimeError:
+        raise RuntimeError(
+            "all values given when constructing a transformation matrix must have the same type"
+        ) from None
+
+    dtype = arg_values.get("dtype", None)
+    if dtype is None:
+        dtype = value_type
+    elif value_type != dtype:
+        raise RuntimeError(
+            f"all values used to initialize this transformation matrix are expected to be of the type `{dtype.__name__}`"
+        )
+
+    return transformation(dtype=dtype)
 
-    return transformation(dtype=templates[0])
+
+def transformation_dispatch_func(input_types: Mapping[str, type], return_type: Any, args: Mapping[str, Var]):
+    # We're in the codegen stage where we emit the code calling the built-in.
+    # Further validate the given argument values if needed and map them
+    # to the underlying C++ function's runtime and template params.
+
+    dtype = return_type._wp_scalar_type_
+
+    variadic_args = tuple(v for k, v in args.items() if k != "dtype")
+
+    func_args = variadic_args
+    template_args = (dtype,)
+    return (func_args, template_args)
 
 
 add_builtin(
     "transformation",
-    input_types={"p": vector(length=3, dtype=Float), "q": quaternion(dtype=Float)},
-    value_func=transform_constructor_value_func,
+    input_types={"pos": vector(length=3, dtype=Float), "rot": quaternion(dtype=Float), "dtype": Float},
+    defaults={"dtype": None},
+    value_func=transformation_value_func,
+    export_func=lambda input_types: {k: v for k, v in input_types.items() if k != "dtype"},
+    dispatch_func=transformation_dispatch_func,
     native_func="transform_t",
     group="Transformations",
-    doc="Construct a rigid-body transformation with translation part ``p`` and rotation ``q``.",
+    doc="Construct a rigid-body transformation with translation part ``pos`` and rotation ``rot``.",
     export=False,
 )
 
 
-def transform_identity_value_func(arg_types, kwds, templates):
+def transform_identity_value_func(arg_types: Mapping[str, type], arg_values: Mapping[str, Any]):
     # if arg_types is None then we are in 'export' mode
     if arg_types is None:
+        # return transformation(dtype=Float)
         return transformf
 
-    if "dtype" not in kwds:
-        # defaulting to float32 to preserve current behavior:
-        dtype = float32
-    else:
-        dtype = kwds["dtype"]
+    dtype = arg_types.get("dtype", float32)
+    return transformation(dtype=dtype)
 
-    templates.append(dtype)
 
-    return transformation(dtype=dtype)
+def transform_identity_dispatch_func(input_types: Mapping[str, type], return_type: Any, args: Mapping[str, Var]):
+    # We're in the codegen stage where we emit the code calling the built-in.
+    # Further validate the given argument values if needed and map them
+    # to the underlying C++ function's runtime and template params.
+
+    dtype = return_type._wp_scalar_type_
+
+    func_args = ()
+    template_args = (dtype,)
+    return (func_args, template_args)
 
 
 add_builtin(
     "transform_identity",
-    input_types={},
+    input_types={"dtype": Float},
+    defaults={"dtype": None},
     value_func=transform_identity_value_func,
+    export_func=lambda input_types: {},
+    dispatch_func=transform_identity_dispatch_func,
     group="Transformations",
     doc="Construct an identity transform with zero translation and identity rotation.",
     export=True,
@@ -1278,103 +1461,168 @@ add_builtin(
 
 add_builtin(
     "transform_get_translation",
-    input_types={"t": transformation(dtype=Float)},
-    value_func=lambda arg_types, kwds, _: vector(length=3, dtype=infer_scalar_type(arg_types)),
+    input_types={"xform": transformation(dtype=Float)},
+    value_func=lambda arg_types, arg_values: vector(length=3, dtype=float_infer_type(arg_types)),
     group="Transformations",
-    doc="Return the translational part of a transform ``t``.",
+    doc="Return the translational part of a transform ``xform``.",
 )
 add_builtin(
     "transform_get_rotation",
-    input_types={"t": transformation(dtype=Float)},
-    value_func=lambda arg_types, kwds, _: quaternion(dtype=infer_scalar_type(arg_types)),
+    input_types={"xform": transformation(dtype=Float)},
+    value_func=lambda arg_types, arg_values: quaternion(dtype=float_infer_type(arg_types)),
     group="Transformations",
-    doc="Return the rotational part of a transform ``t``.",
+    doc="Return the rotational part of a transform ``xform``.",
 )
 add_builtin(
     "transform_multiply",
     input_types={"a": transformation(dtype=Float), "b": transformation(dtype=Float)},
-    value_func=lambda arg_types, kwds, _: transformation(dtype=infer_scalar_type(arg_types)),
+    value_func=lambda arg_types, arg_values: transformation(dtype=float_infer_type(arg_types)),
     group="Transformations",
     doc="Multiply two rigid body transformations together.",
 )
 add_builtin(
     "transform_point",
-    input_types={"t": transformation(dtype=Scalar), "p": vector(length=3, dtype=Scalar)},
-    value_func=lambda arg_types, kwds, _: vector(length=3, dtype=infer_scalar_type(arg_types)),
+    input_types={"xform": transformation(dtype=Float), "point": vector(length=3, dtype=Float)},
+    value_func=lambda arg_types, arg_values: vector(length=3, dtype=float_infer_type(arg_types)),
     group="Transformations",
-    doc="Apply the transform to a point ``p`` treating the homogeneous coordinate as w=1 (translation and rotation).",
+    doc="Apply the transform to a point ``point`` treating the homogeneous coordinate as w=1 (translation and rotation).",
 )
 add_builtin(
     "transform_point",
-    input_types={"m": matrix(shape=(4, 4), dtype=Scalar), "p": vector(length=3, dtype=Scalar)},
-    value_func=lambda arg_types, kwds, _: vector(length=3, dtype=infer_scalar_type(arg_types)),
+    input_types={"mat": matrix(shape=(4, 4), dtype=Float), "point": vector(length=3, dtype=Float)},
+    value_func=lambda arg_types, arg_values: vector(length=3, dtype=float_infer_type(arg_types)),
     group="Vector Math",
-    doc="""Apply the transform to a point ``p`` treating the homogeneous coordinate as w=1.
+    doc="""Apply the transform to a point ``point`` treating the homogeneous coordinate as w=1.
 
-    The transformation is applied treating ``p`` as a column vector, e.g.: ``y = M*p``.
-    Note this is in contrast to some libraries, notably USD, which applies transforms to row vectors, ``y^T = p^T*M^T``.
+    The transformation is applied treating ``point`` as a column vector, e.g.: ``y = mat*point``.
+    Note this is in contrast to some libraries, notably USD, which applies transforms to row vectors, ``y^T = point^T*mat^T``.
     If the transform is coming from a library that uses row-vectors, then users should transpose the transformation
     matrix before calling this method.""",
 )
 add_builtin(
     "transform_vector",
-    input_types={"t": transformation(dtype=Scalar), "v": vector(length=3, dtype=Scalar)},
-    value_func=lambda arg_types, kwds, _: vector(length=3, dtype=infer_scalar_type(arg_types)),
+    input_types={"xform": transformation(dtype=Float), "vec": vector(length=3, dtype=Float)},
+    value_func=lambda arg_types, arg_values: vector(length=3, dtype=float_infer_type(arg_types)),
     group="Transformations",
-    doc="Apply the transform to a vector ``v`` treating the homogeneous coordinate as w=0 (rotation only).",
+    doc="Apply the transform to a vector ``vec`` treating the homogeneous coordinate as w=0 (rotation only).",
 )
 add_builtin(
     "transform_vector",
-    input_types={"m": matrix(shape=(4, 4), dtype=Scalar), "v": vector(length=3, dtype=Scalar)},
-    value_func=lambda arg_types, kwds, _: vector(length=3, dtype=infer_scalar_type(arg_types)),
+    input_types={"mat": matrix(shape=(4, 4), dtype=Float), "vec": vector(length=3, dtype=Float)},
+    value_func=lambda arg_types, arg_values: vector(length=3, dtype=float_infer_type(arg_types)),
     group="Vector Math",
-    doc="""Apply the transform to a vector ``v`` treating the homogeneous coordinate as w=0.
+    doc="""Apply the transform to a vector ``vec`` treating the homogeneous coordinate as w=0.
 
-    The transformation is applied treating ``v`` as a column vector, e.g.: ``y = M*v``
-    note this is in contrast to some libraries, notably USD, which applies transforms to row vectors, ``y^T = v^T*M^T``.
+    The transformation is applied treating ``vec`` as a column vector, e.g.: ``y = mat*vec``
+    note this is in contrast to some libraries, notably USD, which applies transforms to row vectors, ``y^T = vec^T*mat^T``.
     If the transform is coming from a library that uses row-vectors, then users should transpose the transformation
     matrix before calling this method.""",
 )
 add_builtin(
     "transform_inverse",
-    input_types={"t": transformation(dtype=Float)},
-    value_func=sametype_value_func(transformation(dtype=Float)),
+    input_types={"xform": transformation(dtype=Float)},
+    value_func=sametypes_create_value_func(transformation(dtype=Float)),
     group="Transformations",
-    doc="Compute the inverse of the transformation ``t``.",
+    doc="Compute the inverse of the transformation ``xform``.",
 )
 # ---------------------------------
 # Spatial Math
 
 
-def spatial_vector_constructor_value_func(arg_types, kwds, templates):
-    if templates is None:
+def spatial_vector_value_func(arg_types: Mapping[str, type], arg_values: Mapping[str, Any]):
+    if arg_types is None:
         return spatial_vector(dtype=Float)
 
-    if len(templates) == 0:
-        raise RuntimeError("Cannot use a generic type name in a kernel")
+    dtype = arg_values.get("dtype", None)
+
+    variadic_arg_types = tuple(v for k, v in arg_types.items() if k != "dtype")
+    variadic_arg_count = len(variadic_arg_types)
+    if variadic_arg_count == 0:
+        if dtype is None:
+            dtype = float32
+    elif variadic_arg_count == 2:
+        if any(not type_is_vector(x) for x in variadic_arg_types) or any(x._length_ != 3 for x in variadic_arg_types):
+            raise RuntimeError("arguments `w` and `v` are expected to be vectors of length 3")
+    elif variadic_arg_count != 6:
+        raise RuntimeError("2 vectors or 6 scalar values are expected when constructing a spatial vector")
+
+    if variadic_arg_count:
+        try:
+            value_type = float_infer_type(variadic_arg_types)
+        except RuntimeError:
+            raise RuntimeError("all values given when constructing a spatial vector must have the same type") from None
+
+        if dtype is None:
+            dtype = value_type
+        elif value_type != dtype:
+            raise RuntimeError(
+                f"all values used to initialize this spatial vector are expected to be of the type `{dtype.__name__}`"
+            )
+
+    return vector(length=6, dtype=dtype)
+
 
-    vectype = templates[1]
-    if len(arg_types) and infer_scalar_type(arg_types) != vectype:
-        raise RuntimeError("Wrong scalar type for spatial_vector<{}> constructor".format(",".join(map(str, templates))))
+def spatial_vector_dispatch_func(input_types: Mapping[str, type], return_type: Any, args: Mapping[str, Var]):
+    # We're in the codegen stage where we emit the code calling the built-in.
+    # Further validate the given argument values if needed and map them
+    # to the underlying C++ function's runtime and template params.
 
-    return vector(length=6, dtype=vectype)
+    length = return_type._length_
+    dtype = return_type._wp_scalar_type_
+
+    variadic_args = tuple(v for k, v in args.items() if k != "dtype")
+
+    func_args = variadic_args
+    template_args = (length, dtype)
+    return (func_args, template_args)
 
 
 add_builtin(
-    "vector",
-    input_types={"w": vector(length=3, dtype=Float), "v": vector(length=3, dtype=Float)},
-    value_func=spatial_vector_constructor_value_func,
+    "spatial_vector",
+    input_types={"dtype": Float},
+    defaults={"dtype": None},
+    value_func=spatial_vector_value_func,
+    export_func=lambda input_types: {k: v for k, v in input_types.items() if k != "dtype"},
+    dispatch_func=spatial_vector_dispatch_func,
+    native_func="vec_t",
+    group="Spatial Math",
+    doc="Zero-initialize a 6D screw vector.",
+    export=False,
+)
+
+
+add_builtin(
+    "spatial_vector",
+    input_types={"w": vector(length=3, dtype=Float), "v": vector(length=3, dtype=Float), "dtype": Float},
+    defaults={"dtype": None},
+    value_func=spatial_vector_value_func,
+    export_func=lambda input_types: {k: v for k, v in input_types.items() if k != "dtype"},
+    dispatch_func=spatial_vector_dispatch_func,
     native_func="vec_t",
     group="Spatial Math",
     doc="Construct a 6D screw vector from two 3D vectors.",
     export=False,
 )
 
+add_builtin(
+    "spatial_vector",
+    input_types={"wx": Float, "wy": Float, "wz": Float, "vx": Float, "vy": Float, "vz": Float, "dtype": Float},
+    defaults={"dtype": None},
+    initializer_list_func=lambda arg_types, arg_values: True,
+    value_func=spatial_vector_value_func,
+    export_func=lambda input_types: {k: v for k, v in input_types.items() if k != "dtype"},
+    dispatch_func=spatial_vector_dispatch_func,
+    native_func="vec_t",
+    group="Spatial Math",
+    doc="Construct a 6D screw vector from six values.",
+    export=False,
+)
+
 
 add_builtin(
     "spatial_adjoint",
     input_types={"r": matrix(shape=(3, 3), dtype=Float), "s": matrix(shape=(3, 3), dtype=Float)},
-    value_func=lambda arg_types, kwds, _: matrix(shape=(6, 6), dtype=infer_scalar_type(arg_types)),
+    value_func=lambda arg_types, arg_values: matrix(shape=(6, 6), dtype=float_infer_type(arg_types)),
     group="Spatial Math",
     doc="Construct a 6x6 spatial inertial matrix from two 3x3 diagonal blocks.",
     export=False,
@@ -1382,36 +1630,36 @@ add_builtin(
 add_builtin(
     "spatial_dot",
     input_types={"a": vector(length=6, dtype=Float), "b": vector(length=6, dtype=Float)},
-    value_func=sametype_scalar_value_func,
+    value_func=float_sametypes_value_func,
     group="Spatial Math",
     doc="Compute the dot product of two 6D screw vectors.",
 )
 add_builtin(
     "spatial_cross",
     input_types={"a": vector(length=6, dtype=Float), "b": vector(length=6, dtype=Float)},
-    value_func=sametype_value_func(vector(length=6, dtype=Float)),
+    value_func=sametypes_create_value_func(vector(length=6, dtype=Float)),
     group="Spatial Math",
     doc="Compute the cross product of two 6D screw vectors.",
 )
 add_builtin(
     "spatial_cross_dual",
     input_types={"a": vector(length=6, dtype=Float), "b": vector(length=6, dtype=Float)},
-    value_func=sametype_value_func(vector(length=6, dtype=Float)),
+    value_func=sametypes_create_value_func(vector(length=6, dtype=Float)),
     group="Spatial Math",
     doc="Compute the dual cross product of two 6D screw vectors.",
 )
 
 add_builtin(
     "spatial_top",
-    input_types={"a": vector(length=6, dtype=Float)},
-    value_func=lambda arg_types, kwds, _: vector(length=3, dtype=arg_types[0]._wp_scalar_type_),
+    input_types={"svec": vector(length=6, dtype=Float)},
+    value_func=lambda arg_types, arg_values: vector(length=3, dtype=arg_types["svec"]._wp_scalar_type_),
     group="Spatial Math",
     doc="Return the top (first) part of a 6D screw vector.",
 )
 add_builtin(
     "spatial_bottom",
-    input_types={"a": vector(length=6, dtype=Float)},
-    value_func=lambda arg_types, kwds, _: vector(length=3, dtype=arg_types[0]._wp_scalar_type_),
+    input_types={"svec": vector(length=6, dtype=Float)},
+    value_func=lambda arg_types, arg_values: vector(length=3, dtype=arg_types["svec"]._wp_scalar_type_),
     group="Spatial Math",
     doc="Return the bottom (second) part of a 6D screw vector.",
 )
@@ -1588,22 +1836,23 @@ add_builtin(
 
 add_builtin(
     "bvh_query_aabb",
-    input_types={"id": uint64, "lower": vec3, "upper": vec3},
-    value_type=bvh_query_t,
+    input_types={"id": uint64, "low": vec3, "high": vec3},
+    value_func=lambda arg_types, _: BvhQuery if arg_types is None else bvh_query_t,
     group="Geometry",
     doc="""Construct an axis-aligned bounding box query against a BVH object.
 
     This query can be used to iterate over all bounds inside a BVH.
 
     :param id: The BVH identifier
-    :param lower: The lower bound of the bounding box in BVH space
-    :param upper: The upper bound of the bounding box in BVH space""",
+    :param low: The lower bound of the bounding box in BVH space
+    :param high: The upper bound of the bounding box in BVH space""",
+    export=False,
 )
 
 add_builtin(
     "bvh_query_ray",
     input_types={"id": uint64, "start": vec3, "dir": vec3},
-    value_type=bvh_query_t,
+    value_func=lambda arg_types, _: BvhQuery if arg_types is None else bvh_query_t,
     group="Geometry",
     doc="""Construct a ray query against a BVH object.
 
@@ -1612,15 +1861,17 @@ add_builtin(
     :param id: The BVH identifier
     :param start: The start of the ray in BVH space
     :param dir: The direction of the ray in BVH space""",
+    export=False,
 )
 
 add_builtin(
     "bvh_query_next",
-    input_types={"query": bvh_query_t, "index": int},
+    input_types={"query": BvhQuery, "index": int},
     value_type=builtins.bool,
     group="Geometry",
     doc="""Move to the next bound returned by the query.
     The index of the current bound is stored in ``index``, returns ``False`` if there are no more overlapping bound.""",
+    export=False,
 )
 
 add_builtin(
@@ -1650,6 +1901,7 @@ add_builtin(
     :param face: Returns the index of the closest face
     :param bary_u: Returns the barycentric u coordinate of the closest point
     :param bary_v: Returns the barycentric v coordinate of the closest point""",
+    export=False,
     hidden=True,
 )
 
@@ -1660,7 +1912,7 @@ add_builtin(
         "point": vec3,
         "max_dist": float,
     },
-    value_type=mesh_query_point_t,
+    value_func=lambda arg_types, _: MeshQueryPoint if arg_types is None else mesh_query_point_t,
     group="Geometry",
     doc="""Computes the closest point on the :class:`Mesh` with identifier ``id`` to the given ``point`` in space.
 
@@ -1672,6 +1924,7 @@ add_builtin(
     :param point: The point in space to query
     :param max_dist: Mesh faces above this distance will not be considered by the query""",
     require_original_output_arg=True,
+    export=False,
 )
 
 add_builtin(
@@ -1696,6 +1949,7 @@ add_builtin(
     :param face: Returns the index of the closest face
     :param bary_u: Returns the barycentric u coordinate of the closest point
     :param bary_v: Returns the barycentric v coordinate of the closest point""",
+    export=False,
     hidden=True,
 )
 
@@ -1706,7 +1960,7 @@ add_builtin(
         "point": vec3,
         "max_dist": float,
     },
-    value_type=mesh_query_point_t,
+    value_func=lambda arg_types, _: MeshQueryPoint if arg_types is None else mesh_query_point_t,
     group="Geometry",
     doc="""Computes the closest point on the :class:`Mesh` with identifier ``id`` to the given ``point`` in space.
 
@@ -1716,6 +1970,7 @@ add_builtin(
     :param point: The point in space to query
     :param max_dist: Mesh faces above this distance will not be considered by the query""",
     require_original_output_arg=True,
+    export=False,
 )
 
 add_builtin(
@@ -1740,6 +1995,7 @@ add_builtin(
     :param face: Returns the index of the furthest face
     :param bary_u: Returns the barycentric u coordinate of the furthest point
     :param bary_v: Returns the barycentric v coordinate of the furthest point""",
+    export=False,
     hidden=True,
 )
 
@@ -1750,7 +2006,7 @@ add_builtin(
         "point": vec3,
         "min_dist": float,
     },
-    value_type=mesh_query_point_t,
+    value_func=lambda arg_types, _: MeshQueryPoint if arg_types is None else mesh_query_point_t,
     group="Geometry",
     doc="""Computes the furthest point on the mesh with identifier `id` to the given point in space.
 
@@ -1760,6 +2016,7 @@ add_builtin(
     :param point: The point in space to query
     :param min_dist: Mesh faces below this distance will not be considered by the query""",
     require_original_output_arg=True,
+    export=False,
 )
 
 add_builtin(
@@ -1793,6 +2050,7 @@ add_builtin(
     :param bary_v: Returns the barycentric v coordinate of the closest point
     :param epsilon: Epsilon treating distance values as equal, when locating the minimum distance vertex/face/edge, as a
                     fraction of the average edge length, also for treating closest point as being on edge/vertex default 1e-3""",
+    export=False,
     hidden=True,
 )
 
@@ -1805,7 +2063,7 @@ add_builtin(
         "epsilon": float,
     },
     defaults={"epsilon": 1.0e-3},
-    value_type=mesh_query_point_t,
+    value_func=lambda arg_types, _: MeshQueryPoint if arg_types is None else mesh_query_point_t,
     group="Geometry",
     doc="""Computes the closest point on the :class:`Mesh` with identifier ``id`` to the given ``point`` in space.
 
@@ -1819,6 +2077,7 @@ add_builtin(
     :param epsilon: Epsilon treating distance values as equal, when locating the minimum distance vertex/face/edge, as a
                     fraction of the average edge length, also for treating closest point as being on edge/vertex default 1e-3""",
     require_original_output_arg=True,
+    export=False,
 )
 
 add_builtin(
@@ -1855,6 +2114,7 @@ add_builtin(
     :param bary_v: Returns the barycentric v coordinate of the closest point
     :param accuracy: Accuracy for computing the winding number with fast winding number method utilizing second-order dipole approximation, default 2.0
     :param threshold: The threshold of the winding number to be considered inside, default 0.5""",
+    export=False,
     hidden=True,
 )
 
@@ -1868,7 +2128,7 @@ add_builtin(
         "threshold": float,
     },
     defaults={"accuracy": 2.0, "threshold": 0.5},
-    value_type=mesh_query_point_t,
+    value_func=lambda arg_types, _: MeshQueryPoint if arg_types is None else mesh_query_point_t,
     group="Geometry",
     doc="""Computes the closest point on the :class:`Mesh` with identifier ``id`` to the given point in space.
 
@@ -1884,6 +2144,7 @@ add_builtin(
     :param accuracy: Accuracy for computing the winding number with fast winding number method utilizing second-order dipole approximation, default 2.0
     :param threshold: The threshold of the winding number to be considered inside, default 0.5""",
     require_original_output_arg=True,
+    export=False,
 )
 
 add_builtin(
@@ -1914,6 +2175,7 @@ add_builtin(
     :param sign: Returns a value > 0 if the ray hit in front of the face, returns < 0 otherwise
     :param normal: Returns the face normal
     :param face: Returns the index of the hit face""",
+    export=False,
     hidden=True,
 )
 
@@ -1925,7 +2187,7 @@ add_builtin(
         "dir": vec3,
         "max_t": float,
     },
-    value_type=mesh_query_ray_t,
+    value_func=lambda arg_types, _: MeshQueryRay if arg_types is None else mesh_query_ray_t,
     group="Geometry",
     doc="""Computes the closest ray hit on the :class:`Mesh` with identifier ``id``.
 
@@ -1934,30 +2196,33 @@ add_builtin(
     :param dir: The ray direction (should be normalized)
     :param max_t: The maximum distance along the ray to check for intersections""",
     require_original_output_arg=True,
+    export=False,
 )
 
 add_builtin(
     "mesh_query_aabb",
-    input_types={"id": uint64, "lower": vec3, "upper": vec3},
-    value_type=mesh_query_aabb_t,
+    input_types={"id": uint64, "low": vec3, "high": vec3},
+    value_func=lambda arg_types, _: MeshQueryAABB if arg_types is None else mesh_query_aabb_t,
     group="Geometry",
     doc="""Construct an axis-aligned bounding box query against a :class:`Mesh`.
 
     This query can be used to iterate over all triangles inside a volume.
 
     :param id: The mesh identifier
-    :param lower: The lower bound of the bounding box in mesh space
-    :param upper: The upper bound of the bounding box in mesh space""",
+    :param low: The lower bound of the bounding box in mesh space
+    :param high: The upper bound of the bounding box in mesh space""",
+    export=False,
 )
 
 add_builtin(
     "mesh_query_aabb_next",
-    input_types={"query": mesh_query_aabb_t, "index": int},
+    input_types={"query": MeshQueryAABB, "index": int},
     value_type=builtins.bool,
     group="Geometry",
     doc="""Move to the next triangle overlapping the query bounding box.
 
     The index of the current face is stored in ``index``, returns ``False`` if there are no more overlapping triangles.""",
+    export=False,
 )
 
 add_builtin(
@@ -1966,6 +2231,7 @@ add_builtin(
     value_type=vec3,
     group="Geometry",
     doc="""Evaluates the position on the :class:`Mesh` given a face index and barycentric coordinates.""",
+    export=False,
 )
 
 add_builtin(
@@ -1974,26 +2240,29 @@ add_builtin(
     value_type=vec3,
     group="Geometry",
     doc="""Evaluates the velocity on the :class:`Mesh` given a face index and barycentric coordinates.""",
+    export=False,
 )
 
 add_builtin(
     "hash_grid_query",
     input_types={"id": uint64, "point": vec3, "max_dist": float},
-    value_type=hash_grid_query_t,
+    value_func=lambda arg_types, _: HashGridQuery if arg_types is None else hash_grid_query_t,
     group="Geometry",
     doc="""Construct a point query against a :class:`HashGrid`.
 
     This query can be used to iterate over all neighboring point within a fixed radius from the query point.""",
+    export=False,
 )
 
 add_builtin(
     "hash_grid_query_next",
-    input_types={"query": hash_grid_query_t, "index": int},
+    input_types={"query": HashGridQuery, "index": int},
     value_type=builtins.bool,
     group="Geometry",
     doc="""Move to the next point in the hash grid query.
 
     The index of the current neighbor is stored in ``index``, returns ``False`` if there are no more neighbors.""",
+    export=False,
 )
 
 add_builtin(
@@ -2006,6 +2275,7 @@ add_builtin(
     This can be used to reorder threads such that grid traversal occurs in a spatially coherent order.
 
     Returns -1 if the :class:`HashGrid` has not been reserved.""",
+    export=False,
 )
 
 add_builtin(
@@ -2016,6 +2286,7 @@ add_builtin(
     doc="""Tests for intersection between two triangles (v0, v1, v2) and (u0, u1, u2) using Moller's method.
 
     Returns > 0 if triangles intersect.""",
+    export=False,
 )
 
 add_builtin(
@@ -2025,6 +2296,7 @@ add_builtin(
     missing_grad=True,
     group="Geometry",
     doc="""Retrieves the mesh given its index.""",
+    export=False,
 )
 
 add_builtin(
@@ -2033,6 +2305,7 @@ add_builtin(
     value_type=vec3,
     group="Geometry",
     doc="""Evaluates the face normal the mesh given a face index.""",
+    export=False,
 )
 
 add_builtin(
@@ -2041,6 +2314,7 @@ add_builtin(
     value_type=vec3,
     group="Geometry",
     doc="""Returns the point of the mesh given a index.""",
+    export=False,
 )
 
 add_builtin(
@@ -2049,6 +2323,7 @@ add_builtin(
     value_type=vec3,
     group="Geometry",
     doc="""Returns the velocity of the mesh given a index.""",
+    export=False,
 )
 
 add_builtin(
@@ -2057,6 +2332,7 @@ add_builtin(
     value_type=int,
     group="Geometry",
     doc="""Returns the point-index of the mesh given a face-vertex index.""",
+    export=False,
 )
 
 
@@ -2075,6 +2351,7 @@ add_builtin(
     :param q2: Second point of second edge
     :param epsilon: Zero tolerance for determining if points in an edge are degenerate.
     :param out: vec3 output containing (s,t,d), where `s` in [0,1] is the barycentric weight for the first edge, `t` is the barycentric weight for the second edge, and `d` is the distance between the two edges at these two closest points.""",
+    export=False,
 )
 
 # ---------------------------------
@@ -2096,9 +2373,13 @@ add_builtin(
 # ---------------------------------
 # Iterators
 
-add_builtin("iter_next", input_types={"range": range_t}, value_type=int, group="Utility", hidden=True)
-add_builtin("iter_next", input_types={"query": hash_grid_query_t}, value_type=int, group="Utility", hidden=True)
-add_builtin("iter_next", input_types={"query": mesh_query_aabb_t}, value_type=int, group="Utility", hidden=True)
+add_builtin("iter_next", input_types={"range": range_t}, value_type=int, group="Utility", export=False, hidden=True)
+add_builtin(
+    "iter_next", input_types={"query": hash_grid_query_t}, value_type=int, group="Utility", export=False, hidden=True
+)
+add_builtin(
+    "iter_next", input_types={"query": mesh_query_aabb_t}, value_type=int, group="Utility", export=False, hidden=True
+)
 
 # ---------------------------------
 # Volumes
@@ -2116,26 +2397,46 @@ _volume_supported_value_types = {
 }
 
 
-def volume_value_func(arg_types, kwds, templates):
-    try:
-        dtype = kwds["dtype"]
-    except KeyError as err:
-        raise RuntimeError(
-            "'dtype' keyword argument must be specified when calling generic volume lookup or sampling functions"
-        ) from err
+def check_volume_value_grad_compatibility(dtype, grad_dtype):
+    if type_is_vector(dtype):
+        expected = matrix(shape=(type_length(dtype), 3), dtype=type_scalar_type(dtype))
+    else:
+        expected = vector(length=3, dtype=dtype)
 
-    if dtype not in _volume_supported_value_types:
-        raise RuntimeError(f"Unsupported volume type '{type_repr(dtype)}'")
+    if not types_equal(grad_dtype, expected):
+        raise RuntimeError(f"Incompatible gradient type, expected {type_repr(expected)}, got {type_repr(grad_dtype)}")
 
-    templates.append(dtype)
+
+def volume_value_func(arg_types: Mapping[str, type], arg_values: Mapping[str, Any]):
+    if arg_types is None:
+        return Any
+
+    dtype = arg_values["dtype"]
+
+    if dtype not in _volume_supported_value_types:
+        raise RuntimeError(f"unsupported volume type `{dtype.__name__}`")
 
     return dtype
 
 
+def volume_dispatch_func(input_types: Mapping[str, type], return_type: Any, args: Mapping[str, Var]):
+    # We're in the codegen stage where we emit the code calling the built-in.
+    # Further validate the given argument values if needed and map them
+    # to the underlying C++ function's runtime and template params.
+
+    dtype = args["dtype"]
+
+    func_args = tuple(v for k, v in args.items() if k != "dtype")
+    template_args = (dtype,)
+    return (func_args, template_args)
+
+
 add_builtin(
     "volume_sample",
     input_types={"id": uint64, "uvw": vec3, "sampling_mode": int, "dtype": Any},
     value_func=volume_value_func,
+    export_func=lambda input_types: {k: v for k, v in input_types.items() if k != "dtype"},
+    dispatch_func=volume_dispatch_func,
     export=False,
     group="Volumes",
     doc="""Sample the volume of type `dtype` given by ``id`` at the volume local-space point ``uvw``.
@@ -2144,31 +2445,38 @@ add_builtin(
 )
 
 
-def check_volume_value_grad_compatibility(dtype, grad_dtype):
-    if type_is_vector(dtype):
-        expected = matrix(shape=(type_length(dtype), 3), dtype=type_scalar_type(dtype))
-    else:
-        expected = vector(length=3, dtype=dtype)
-
-    if not types_equal(grad_dtype, expected):
-        raise RuntimeError(f"Incompatible gradient type, expected {type_repr(expected)}, got {type_repr(grad_dtype)}")
+def volume_sample_grad_value_func(arg_types: Mapping[str, type], arg_values: Mapping[str, Any]):
+    if arg_types is None:
+        return Any
 
+    dtype = arg_values["dtype"]
 
-def volume_sample_grad_value_func(arg_types, kwds, templates):
-    dtype = volume_value_func(arg_types, kwds, templates)
+    if dtype not in _volume_supported_value_types:
+        raise RuntimeError(f"unsupported volume type `{dtype.__name__}`")
 
-    if len(arg_types) < 4:
-        raise RuntimeError("'volume_sample_grad' requires 4 positional arguments")
+    check_volume_value_grad_compatibility(dtype, arg_types["grad"])
 
-    grad_type = arg_types[3]
-    check_volume_value_grad_compatibility(dtype, grad_type)
     return dtype
 
 
+def volume_sample_grad_dispatch_func(input_types: Mapping[str, type], return_type: Any, args: Mapping[str, Var]):
+    # We're in the codegen stage where we emit the code calling the built-in.
+    # Further validate the given argument values if needed and map them
+    # to the underlying C++ function's runtime and template params.
+
+    dtype = args["dtype"]
+
+    func_args = tuple(v for k, v in args.items() if k != "dtype")
+    template_args = (dtype,)
+    return (func_args, template_args)
+
+
 add_builtin(
     "volume_sample_grad",
     input_types={"id": uint64, "uvw": vec3, "sampling_mode": int, "grad": Any, "dtype": Any},
     value_func=volume_sample_grad_value_func,
+    export_func=lambda input_types: {k: v for k, v in input_types.items() if k != "dtype"},
+    dispatch_func=volume_sample_grad_dispatch_func,
     export=False,
     group="Volumes",
     doc="""Sample the volume given by ``id`` and its gradient at the volume local-space point ``uvw``.
@@ -2176,11 +2484,38 @@ add_builtin(
     Interpolation should be :attr:`warp.Volume.CLOSEST` or :attr:`wp.Volume.LINEAR.`""",
 )
 
+
+def volume_lookup_value_func(arg_types: Mapping[str, type], arg_values: Mapping[str, Any]):
+    if arg_types is None:
+        return Any
+
+    dtype = arg_values["dtype"]
+
+    if dtype not in _volume_supported_value_types:
+        raise RuntimeError(f"unsupported volume type `{dtype.__name__}`")
+
+    return dtype
+
+
+def volume_lookup_dispatch_func(input_types: Mapping[str, type], return_type: Any, args: Mapping[str, Var]):
+    # We're in the codegen stage where we emit the code calling the built-in.
+    # Further validate the given argument values if needed and map them
+    # to the underlying C++ function's runtime and template params.
+
+    dtype = args["dtype"]
+
+    func_args = tuple(v for k, v in args.items() if k != "dtype")
+    template_args = (dtype,)
+    return (func_args, template_args)
+
+
 add_builtin(
     "volume_lookup",
     input_types={"id": uint64, "i": int, "j": int, "k": int, "dtype": Any},
     value_type=int,
-    value_func=volume_value_func,
+    value_func=volume_lookup_value_func,
+    export_func=lambda input_types: {k: v for k, v in input_types.items() if k != "dtype"},
+    dispatch_func=volume_lookup_dispatch_func,
     export=False,
     group="Volumes",
     doc="""Returns the value of voxel with coordinates ``i``, ``j``, ``k`` for a volume of type type `dtype`.
@@ -2189,13 +2524,14 @@ add_builtin(
 )
 
 
-def volume_store_value_func(arg_types, kwds, templates):
-    if len(arg_types) < 4:
-        raise RuntimeError("'volume_store' requires 5 positional arguments")
+def volume_store_value_func(arg_types: Mapping[str, type], arg_values: Mapping[str, Any]):
+    if arg_types is None:
+        return None
+
+    dtype = arg_types["value"]
 
-    dtype = arg_types[4]
     if dtype not in _volume_supported_value_types:
-        raise RuntimeError(f"Unsupported volume type '{type_repr(dtype)}'")
+        raise RuntimeError(f"unsupported volume type `{dtype.__name__}`")
 
     return None
 
@@ -2299,14 +2635,17 @@ add_builtin(
 )
 
 
-def volume_sample_index_value_func(arg_types, kwds, templates):
-    if len(arg_types) != 5:
-        raise RuntimeError("'volume_sample_index' requires 5 positional arguments")
+def volume_sample_index_value_func(arg_types: Mapping[str, type], arg_values: Mapping[str, Any]):
+    if arg_types is None:
+        return Any
+
+    dtype = arg_types["voxel_data"].dtype
 
-    dtype = arg_types[3].dtype
+    if dtype not in _volume_supported_value_types:
+        raise RuntimeError(f"unsupported volume type `{dtype.__name__}`")
 
-    if not types_equal(dtype, arg_types[4]):
-        raise RuntimeError("The 'voxel_data' array and the 'background' value must have the same dtype")
+    if not types_equal(dtype, arg_types["background"]):
+        raise RuntimeError("the `voxel_data` array and the `background` value must have the same dtype")
 
     return dtype
 
@@ -2326,17 +2665,20 @@ add_builtin(
 )
 
 
-def volume_sample_grad_index_value_func(arg_types, kwds, templates):
-    if len(arg_types) != 6:
-        raise RuntimeError("'volume_sample_grad_index' requires 6 positional arguments")
+def volume_sample_grad_index_value_func(arg_types: Mapping[str, type], arg_values: Mapping[str, Any]):
+    if arg_types is None:
+        return Any
+
+    dtype = arg_types["voxel_data"].dtype
 
-    dtype = arg_types[3].dtype
+    if dtype not in _volume_supported_value_types:
+        raise RuntimeError(f"unsupported volume type `{dtype.__name__}`")
 
-    if not types_equal(dtype, arg_types[4]):
-        raise RuntimeError("The 'voxel_data' array and the 'background' value must have the same dtype")
+    if not types_equal(dtype, arg_types["background"]):
+        raise RuntimeError("the `voxel_data` array and the `background` value must have the same dtype")
+
+    check_volume_value_grad_compatibility(dtype, arg_types["grad"])
 
-    grad_type = arg_types[5]
-    check_volume_value_grad_compatibility(dtype, grad_type)
     return dtype
 
 
@@ -2434,10 +2776,10 @@ add_builtin(
 )
 add_builtin(
     "randi",
-    input_types={"state": uint32, "min": int, "max": int},
+    input_types={"state": uint32, "low": int, "high": int},
     value_type=int,
     group="Random",
-    doc="Return a random integer between [min, max).",
+    doc="Return a random integer between [low, high).",
 )
 add_builtin(
     "randf",
@@ -2448,10 +2790,10 @@ add_builtin(
 )
 add_builtin(
     "randf",
-    input_types={"state": uint32, "min": float, "max": float},
+    input_types={"state": uint32, "low": float, "high": float},
     value_type=float,
     group="Random",
-    doc="Return a random float between [min, max).",
+    doc="Return a random float between [low, high).",
 )
 add_builtin(
     "randn", input_types={"state": uint32}, value_type=float, group="Random", doc="Sample a normal distribution."
@@ -2600,7 +2942,7 @@ add_builtin(
 add_builtin(
     "curlnoise",
     input_types={"state": uint32, "xy": vec2, "octaves": uint32, "lacunarity": float, "gain": float},
-    defaults={"octaves": 1, "lacunarity": 2.0, "gain": 0.5},
+    defaults={"octaves": uint32(1), "lacunarity": 2.0, "gain": 0.5},
     value_type=vec2,
     group="Random",
     doc="Divergence-free vector field based on the gradient of a Perlin noise function.",
@@ -2609,7 +2951,7 @@ add_builtin(
 add_builtin(
     "curlnoise",
     input_types={"state": uint32, "xyz": vec3, "octaves": uint32, "lacunarity": float, "gain": float},
-    defaults={"octaves": 1, "lacunarity": 2.0, "gain": 0.5},
+    defaults={"octaves": uint32(1), "lacunarity": 2.0, "gain": 0.5},
     value_type=vec3,
     group="Random",
     doc="Divergence-free vector field based on the curl of three Perlin noise functions.",
@@ -2618,19 +2960,31 @@ add_builtin(
 add_builtin(
     "curlnoise",
     input_types={"state": uint32, "xyzt": vec4, "octaves": uint32, "lacunarity": float, "gain": float},
-    defaults={"octaves": 1, "lacunarity": 2.0, "gain": 0.5},
+    defaults={"octaves": uint32(1), "lacunarity": 2.0, "gain": 0.5},
     value_type=vec3,
     group="Random",
     doc="Divergence-free vector field based on the curl of three Perlin noise functions.",
     missing_grad=True,
 )
 
+
+def printf_dispatch_func(input_types: Mapping[str, type], return_type: Any, args: Mapping[str, Var]):
+    # We're in the codegen stage where we emit the code calling the built-in.
+    # Further validate the given argument values if needed and map them
+    # to the underlying C++ function's runtime and template params.
+
+    func_args = (args["fmt"], *args["args"])
+    template_args = ()
+    return (func_args, template_args)
+
+
 # note printf calls directly to global CRT printf (no wp:: namespace prefix)
 add_builtin(
     "printf",
-    input_types={},
+    input_types={"fmt": str, "*args": Any},
     namespace="",
     variadic=True,
+    dispatch_func=printf_dispatch_func,
     group="Utility",
     doc="Allows printing formatted strings using C-style format specifiers.",
 )
@@ -2709,189 +3063,309 @@ add_builtin(
 
 add_builtin(
     "copy",
-    input_types={"value": Any},
-    value_func=lambda arg_types, kwds, _: arg_types[0],
+    input_types={"a": Any},
+    value_func=lambda arg_types, arg_values: arg_types["a"],
+    hidden=True,
+    export=False,
+    group="Utility",
+)
+add_builtin(
+    "assign",
+    input_types={"dest": Any, "src": Any},
     hidden=True,
     export=False,
     group="Utility",
 )
-add_builtin("assign", variadic=True, hidden=True, export=False, group="Utility")
 add_builtin(
     "select",
-    input_types={"cond": builtins.bool, "arg1": Any, "arg2": Any},
-    value_func=lambda arg_types, kwds, _: arg_types[1],
-    doc="Select between two arguments, if ``cond`` is ``False`` then return ``arg1``, otherwise return ``arg2``",
+    input_types={"cond": builtins.bool, "value_if_false": Any, "value_if_true": Any},
+    value_func=lambda arg_types, arg_values: arg_types["value_if_false"],
+    doc="Select between two arguments, if ``cond`` is ``False`` then return ``value_if_false``, otherwise return ``value_if_true``",
     group="Utility",
 )
 for t in int_types:
     add_builtin(
         "select",
-        input_types={"cond": t, "arg1": Any, "arg2": Any},
-        value_func=lambda arg_types, kwds, _: arg_types[1],
-        doc="Select between two arguments, if ``cond`` is ``False`` then return ``arg1``, otherwise return ``arg2``",
+        input_types={"cond": t, "value_if_false": Any, "value_if_true": Any},
+        value_func=lambda arg_types, arg_values: arg_types["value_if_false"],
+        doc="Select between two arguments, if ``cond`` is ``False`` then return ``value_if_false``, otherwise return ``value_if_true``",
         group="Utility",
     )
 add_builtin(
     "select",
-    input_types={"arr": array(dtype=Any), "arg1": Any, "arg2": Any},
-    value_func=lambda arg_types, kwds, _: arg_types[1],
-    doc="Select between two arguments, if ``arr`` is null then return ``arg1``, otherwise return ``arg2``",
+    input_types={"arr": array(dtype=Any), "value_if_false": Any, "value_if_true": Any},
+    value_func=lambda arg_types, arg_values: arg_types["value_if_false"],
+    doc="Select between two arguments, if ``arr`` is null then return ``value_if_false``, otherwise return ``value_if_true``",
+    group="Utility",
+)
+
+
+def array_value_func(arg_types: Mapping[str, type], arg_values: Mapping[str, Any]):
+    if arg_types is None:
+        return array(dtype=Scalar)
+
+    dtype = arg_values["dtype"]
+    shape = arg_values["shape"]
+    return array(dtype=dtype, ndim=len(shape))
+
+
+def array_dispatch_func(input_types: Mapping[str, type], return_type: Any, args: Mapping[str, Var]):
+    # We're in the codegen stage where we emit the code calling the built-in.
+    # Further validate the given argument values if needed and map them
+    # to the underlying C++ function's runtime and template params.
+
+    dtype = return_type.dtype
+
+    func_args = (args["ptr"], *args["shape"])
+    template_args = (dtype,)
+    return (func_args, template_args)
+
+
+add_builtin(
+    "array",
+    input_types={"ptr": warp.uint64, "shape": Tuple[int, ...], "dtype": Scalar},
+    value_func=array_value_func,
+    export_func=lambda input_types: {k: v for k, v in input_types.items() if k != "dtype"},
+    dispatch_func=array_dispatch_func,
+    native_func="array_t",
     group="Utility",
+    hidden=True,
+    export=False,
+    missing_grad=True,
 )
 
 
 # does argument checking and type propagation for address()
-def address_value_func(arg_types, kwds, _):
-    if not is_array(arg_types[0]):
-        raise RuntimeError("load() argument 0 must be an array")
+def address_value_func(arg_types: Mapping[str, type], arg_values: Mapping[str, Any]):
+    arr_type = arg_types["arr"]
+    idx_types = tuple(arg_types[x] for x in "ijkl" if arg_types.get(x, None) is not None)
+
+    if not is_array(arr_type):
+        raise RuntimeError("address() first argument must be an array")
 
-    num_indices = len(arg_types) - 1
-    num_dims = arg_types[0].ndim
+    idx_count = len(idx_types)
 
-    if num_indices < num_dims:
+    if idx_count < arr_type.ndim:
         raise RuntimeError(
             "Num indices < num dimensions for array load, this is a codegen error, should have generated a view instead"
         )
 
-    if num_indices > num_dims:
+    if idx_count > arr_type.ndim:
         raise RuntimeError(
-            f"Num indices > num dimensions for array load, received {num_indices}, but array only has {num_dims}"
+            f"Num indices > num dimensions for array load, received {idx_count}, but array only has {arr_type.ndim}"
         )
 
     # check index types
-    for t in arg_types[1:]:
+    for t in idx_types:
         if not type_is_int(t):
-            raise RuntimeError(f"address() index arguments must be of integer type, got index of type {t}")
+            raise RuntimeError(f"address() index arguments must be of integer type, got index of type {type_repr(t)}")
 
-    return Reference(arg_types[0].dtype)
+    return Reference(arr_type.dtype)
+
+
+for array_type in array_types:
+    add_builtin(
+        "address",
+        input_types={"arr": array_type(dtype=Any), "i": int, "j": int, "k": int, "l": int},
+        defaults={"j": None, "k": None, "l": None},
+        hidden=True,
+        value_func=address_value_func,
+        group="Utility",
+    )
 
 
 # does argument checking and type propagation for view()
-def view_value_func(arg_types, kwds, _):
-    if not is_array(arg_types[0]):
-        raise RuntimeError("view() argument 0 must be an array")
+def view_value_func(arg_types: Mapping[str, type], arg_values: Mapping[str, Any]):
+    arr_type = arg_types["arr"]
+    idx_types = tuple(arg_types[x] for x in "ijk" if arg_types.get(x, None) is not None)
+
+    if not is_array(arr_type):
+        raise RuntimeError("view() first argument must be an array")
 
-    # check array dim big enough to support view
-    num_indices = len(arg_types) - 1
-    num_dims = arg_types[0].ndim
+    idx_count = len(idx_types)
 
-    if num_indices >= num_dims:
+    if idx_count >= arr_type.ndim:
         raise RuntimeError(
-            f"Trying to create an array view with {num_indices} indices, but the array only has {num_dims} dimension(s). Ensure that the argument type on the function or kernel specifies the expected number of dimensions, e.g.: def func(param: wp.array3d(dtype=float):"
+            f"Trying to create an array view with {idx_count} indices, "
+            f"but the array only has {arr_type.ndim} dimension(s). "
+            f"Ensure that the argument type on the function or kernel specifies "
+            f"the expected number of dimensions, e.g.: def func(param: wp.array3d(dtype=float): ..."
         )
 
     # check index types
-    for t in arg_types[1:]:
+    for t in idx_types:
         if not type_is_int(t):
-            raise RuntimeError(f"view() index arguments must be of integer type, got index of type {t}")
+            raise RuntimeError(f"view() index arguments must be of integer type, got index of type {type_repr(t)}")
 
     # create an array view with leading dimensions removed
-    dtype = arg_types[0].dtype
-    ndim = num_dims - num_indices
-    if isinstance(arg_types[0], (fabricarray, indexedfabricarray)):
+    dtype = arr_type.dtype
+    ndim = arr_type.ndim - idx_count
+    if isinstance(arr_type, (fabricarray, indexedfabricarray)):
         # fabric array of arrays: return array attribute as a regular array
         return array(dtype=dtype, ndim=ndim)
-    else:
-        return type(arg_types[0])(dtype=dtype, ndim=ndim)
+
+    return type(arr_type)(dtype=dtype, ndim=ndim)
+
+
+for array_type in array_types:
+    add_builtin(
+        "view",
+        input_types={"arr": array_type(dtype=Any), "i": int, "j": int, "k": int},
+        defaults={"j": None, "k": None},
+        hidden=True,
+        value_func=view_value_func,
+        group="Utility",
+    )
 
 
 # does argument checking and type propagation for array_store()
-def array_store_value_func(arg_types, kwds, _):
-    # check target type
-    if not is_array(arg_types[0]):
-        raise RuntimeError("array_store() argument 0 must be an array")
+def array_store_value_func(arg_types: Mapping[str, type], arg_values: Mapping[str, Any]):
+    arr_type = arg_types["arr"]
+    value_type = arg_types["value"]
+    idx_types = tuple(arg_types[x] for x in "ijkl" if arg_types.get(x, None) is not None)
 
-    num_indices = len(arg_types[1:-1])
-    num_dims = arg_types[0].ndim
+    if not is_array(arr_type):
+        raise RuntimeError("array_store() first argument must be an array")
 
-    # if this happens we should have generated a view instead of a load during code gen
-    if num_indices < num_dims:
-        raise RuntimeError("Num indices < num dimensions for array store")
+    idx_count = len(idx_types)
 
-    if num_indices > num_dims:
+    if idx_count < arr_type.ndim:
         raise RuntimeError(
-            f"Num indices > num dimensions for array store, received {num_indices}, but array only has {num_dims}"
+            "Num indices < num dimensions for array store, this is a codegen error, should have generated a view instead"
+        )
+
+    if idx_count > arr_type.ndim:
+        raise RuntimeError(
+            f"Num indices > num dimensions for array store, received {idx_count}, but array only has {arr_type.ndim}"
         )
 
     # check index types
-    for t in arg_types[1:-1]:
+    for t in idx_types:
         if not type_is_int(t):
-            raise RuntimeError(f"array_store() index arguments must be of integer type, got index of type {t}")
+            raise RuntimeError(
+                f"array_store() index arguments must be of integer type, got index of type {type_repr(t)}"
+            )
 
     # check value type
-    if not types_equal(arg_types[-1], arg_types[0].dtype):
+    if not types_equal(arr_type.dtype, value_type):
         raise RuntimeError(
-            f"array_store() value argument type ({arg_types[2]}) must be of the same type as the array ({arg_types[0].dtype})"
+            f"array_store() value argument type ({type_repr(value_type)}) must be of the same type as the array ({type_repr(arr_type.dtype)})"
         )
 
     return None
 
 
+for array_type in array_types:
+    add_builtin(
+        "array_store",
+        input_types={"arr": array_type(dtype=Any), "i": int, "value": Any},
+        hidden=True,
+        value_func=array_store_value_func,
+        skip_replay=True,
+        group="Utility",
+    )
+    add_builtin(
+        "array_store",
+        input_types={"arr": array_type(dtype=Any), "i": int, "j": int, "value": Any},
+        hidden=True,
+        value_func=array_store_value_func,
+        skip_replay=True,
+        group="Utility",
+    )
+    add_builtin(
+        "array_store",
+        input_types={"arr": array_type(dtype=Any), "i": int, "j": int, "k": int, "value": Any},
+        hidden=True,
+        value_func=array_store_value_func,
+        skip_replay=True,
+        group="Utility",
+    )
+    add_builtin(
+        "array_store",
+        input_types={"arr": array_type(dtype=Any), "i": int, "j": int, "k": int, "l": int, "value": Any},
+        hidden=True,
+        value_func=array_store_value_func,
+        skip_replay=True,
+        group="Utility",
+    )
+
+
 # does argument checking for store()
-def store_value_func(arg_types, kwds, _):
+def store_value_func(arg_types: Mapping[str, type], arg_values: Mapping[str, Any]):
     # we already stripped the Reference from the argument type prior to this call
-    if not types_equal(arg_types[0], arg_types[1]):
-        raise RuntimeError(f"store() value argument type ({arg_types[1]}) must be of the same type as the reference")
+    if not types_equal(arg_types["address"], arg_types["value"]):
+        raise RuntimeError(
+            f"store() value argument type ({arg_types['value']}) must be of the same type as the reference"
+        )
 
     return None
 
 
-# does type propagation for load()
-def load_value_func(arg_types, kwds, _):
-    # we already stripped the Reference from the argument type prior to this call
-    return arg_types[0]
+def store_dispatch_func(input_types: Mapping[str, type], return_type: Any, args: Mapping[str, Var]):
+    func_args = (Reference(args["address"]), args["value"])
+    template_args = ()
+    return (func_args, template_args)
 
 
-add_builtin("address", variadic=True, hidden=True, value_func=address_value_func, group="Utility")
-add_builtin("view", variadic=True, hidden=True, value_func=view_value_func, group="Utility")
-add_builtin(
-    "array_store", variadic=True, hidden=True, value_func=array_store_value_func, skip_replay=True, group="Utility"
-)
 add_builtin(
     "store",
-    input_types={"address": Reference, "value": Any},
-    hidden=True,
+    input_types={"address": Any, "value": Any},
     value_func=store_value_func,
+    dispatch_func=store_dispatch_func,
+    hidden=True,
     skip_replay=True,
     group="Utility",
 )
+
+
+def load_dispatch_func(input_types: Mapping[str, type], return_type: Any, args: Mapping[str, Var]):
+    func_args = (Reference(args["address"]),)
+    template_args = ()
+    return (func_args, template_args)
+
+
 add_builtin(
     "load",
-    input_types={"address": Reference},
+    input_types={"address": Any},
+    value_func=lambda arg_types, arg_values: arg_types["address"],
+    dispatch_func=load_dispatch_func,
     hidden=True,
-    value_func=load_value_func,
     group="Utility",
 )
 
 
-def atomic_op_value_func(arg_types, kwds, _):
-    # check target type
-    if not is_array(arg_types[0]):
-        raise RuntimeError("atomic() operation argument 0 must be an array")
+def atomic_op_value_func(arg_types: Mapping[str, type], arg_values: Mapping[str, Any]):
+    arr_type = arg_types["arr"]
+    value_type = arg_types["value"]
+    idx_types = tuple(arg_types[x] for x in "ijkl" if arg_types.get(x, None) is not None)
 
-    num_indices = len(arg_types[1:-1])
-    num_dims = arg_types[0].ndim
+    if not is_array(arr_type):
+        raise RuntimeError("atomic() first argument must be an array")
 
-    # if this happens we should have generated a view instead of a load during code gen
-    if num_indices < num_dims:
-        raise RuntimeError("Num indices < num dimensions for atomic array operation")
+    idx_count = len(idx_types)
 
-    if num_indices > num_dims:
+    if idx_count < arr_type.ndim:
         raise RuntimeError(
-            f"Num indices > num dimensions for atomic array operation, received {num_indices}, but array only has {num_dims}"
+            "Num indices < num dimensions for atomic, this is a codegen error, should have generated a view instead"
+        )
+
+    if idx_count > arr_type.ndim:
+        raise RuntimeError(
+            f"Num indices > num dimensions for atomic, received {idx_count}, but array only has {arr_type.ndim}"
         )
 
     # check index types
-    for t in arg_types[1:-1]:
+    for t in idx_types:
         if not type_is_int(t):
-            raise RuntimeError(f"atomic() operation index arguments must be of integer type, got index of type {t}")
+            raise RuntimeError(f"atomic() index arguments must be of integer type, got index of type {type_repr(t)}")
 
-    if not types_equal(arg_types[-1], arg_types[0].dtype):
+    # check value type
+    if not types_equal(arr_type.dtype, value_type):
         raise RuntimeError(
-            f"atomic() value argument ({arg_types[-1]}) must be of the same type as the array ({arg_types[0].dtype})"
+            f"atomic() value argument type ({type_repr(value_type)}) must be of the same type as the array ({type_repr(arr_type.dtype)})"
         )
 
-    return arg_types[0].dtype
+    return arr_type.dtype
 
 
 for array_type in array_types:
@@ -2901,36 +3375,36 @@ for array_type in array_types:
     add_builtin(
         "atomic_add",
         hidden=hidden,
-        input_types={"a": array_type(dtype=Any), "i": int, "value": Any},
+        input_types={"arr": array_type(dtype=Any), "i": int, "value": Any},
         value_func=atomic_op_value_func,
-        doc="Atomically add ``value`` onto ``a[i]``.",
+        doc="Atomically add ``value`` onto ``arr[i]``.",
         group="Utility",
         skip_replay=True,
     )
     add_builtin(
         "atomic_add",
         hidden=hidden,
-        input_types={"a": array_type(dtype=Any), "i": int, "j": int, "value": Any},
+        input_types={"arr": array_type(dtype=Any), "i": int, "j": int, "value": Any},
         value_func=atomic_op_value_func,
-        doc="Atomically add ``value`` onto ``a[i,j]``.",
+        doc="Atomically add ``value`` onto ``arr[i,j]``.",
         group="Utility",
         skip_replay=True,
     )
     add_builtin(
         "atomic_add",
         hidden=hidden,
-        input_types={"a": array_type(dtype=Any), "i": int, "j": int, "k": int, "value": Any},
+        input_types={"arr": array_type(dtype=Any), "i": int, "j": int, "k": int, "value": Any},
         value_func=atomic_op_value_func,
-        doc="Atomically add ``value`` onto ``a[i,j,k]``.",
+        doc="Atomically add ``value`` onto ``arr[i,j,k]``.",
         group="Utility",
         skip_replay=True,
     )
     add_builtin(
         "atomic_add",
         hidden=hidden,
-        input_types={"a": array_type(dtype=Any), "i": int, "j": int, "k": int, "l": int, "value": Any},
+        input_types={"arr": array_type(dtype=Any), "i": int, "j": int, "k": int, "l": int, "value": Any},
         value_func=atomic_op_value_func,
-        doc="Atomically add ``value`` onto ``a[i,j,k,l]``.",
+        doc="Atomically add ``value`` onto ``arr[i,j,k,l]``.",
         group="Utility",
         skip_replay=True,
     )
@@ -2938,36 +3412,36 @@ for array_type in array_types:
     add_builtin(
         "atomic_sub",
         hidden=hidden,
-        input_types={"a": array_type(dtype=Any), "i": int, "value": Any},
+        input_types={"arr": array_type(dtype=Any), "i": int, "value": Any},
         value_func=atomic_op_value_func,
-        doc="Atomically subtract ``value`` onto ``a[i]``.",
+        doc="Atomically subtract ``value`` onto ``arr[i]``.",
         group="Utility",
         skip_replay=True,
     )
     add_builtin(
         "atomic_sub",
         hidden=hidden,
-        input_types={"a": array_type(dtype=Any), "i": int, "j": int, "value": Any},
+        input_types={"arr": array_type(dtype=Any), "i": int, "j": int, "value": Any},
         value_func=atomic_op_value_func,
-        doc="Atomically subtract ``value`` onto ``a[i,j]``.",
+        doc="Atomically subtract ``value`` onto ``arr[i,j]``.",
         group="Utility",
         skip_replay=True,
     )
     add_builtin(
         "atomic_sub",
         hidden=hidden,
-        input_types={"a": array_type(dtype=Any), "i": int, "j": int, "k": int, "value": Any},
+        input_types={"arr": array_type(dtype=Any), "i": int, "j": int, "k": int, "value": Any},
         value_func=atomic_op_value_func,
-        doc="Atomically subtract ``value`` onto ``a[i,j,k]``.",
+        doc="Atomically subtract ``value`` onto ``arr[i,j,k]``.",
         group="Utility",
         skip_replay=True,
     )
     add_builtin(
         "atomic_sub",
         hidden=hidden,
-        input_types={"a": array_type(dtype=Any), "i": int, "j": int, "k": int, "l": int, "value": Any},
+        input_types={"arr": array_type(dtype=Any), "i": int, "j": int, "k": int, "l": int, "value": Any},
         value_func=atomic_op_value_func,
-        doc="Atomically subtract ``value`` onto ``a[i,j,k,l]``.",
+        doc="Atomically subtract ``value`` onto ``arr[i,j,k,l]``.",
         group="Utility",
         skip_replay=True,
     )
@@ -2975,9 +3449,9 @@ for array_type in array_types:
     add_builtin(
         "atomic_min",
         hidden=hidden,
-        input_types={"a": array_type(dtype=Any), "i": int, "value": Any},
+        input_types={"arr": array_type(dtype=Any), "i": int, "value": Any},
         value_func=atomic_op_value_func,
-        doc="""Compute the minimum of ``value`` and ``a[i]`` and atomically update the array.
+        doc="""Compute the minimum of ``value`` and ``arr[i]`` and atomically update the array.
 
     .. note:: The operation is only atomic on a per-component basis for vectors and matrices.""",
         group="Utility",
@@ -2986,9 +3460,9 @@ for array_type in array_types:
     add_builtin(
         "atomic_min",
         hidden=hidden,
-        input_types={"a": array_type(dtype=Any), "i": int, "j": int, "value": Any},
+        input_types={"arr": array_type(dtype=Any), "i": int, "j": int, "value": Any},
         value_func=atomic_op_value_func,
-        doc="""Compute the minimum of ``value`` and ``a[i,j]`` and atomically update the array.
+        doc="""Compute the minimum of ``value`` and ``arr[i,j]`` and atomically update the array.
 
     .. note:: The operation is only atomic on a per-component basis for vectors and matrices.""",
         group="Utility",
@@ -2997,9 +3471,9 @@ for array_type in array_types:
     add_builtin(
         "atomic_min",
         hidden=hidden,
-        input_types={"a": array_type(dtype=Any), "i": int, "j": int, "k": int, "value": Any},
+        input_types={"arr": array_type(dtype=Any), "i": int, "j": int, "k": int, "value": Any},
         value_func=atomic_op_value_func,
-        doc="""Compute the minimum of ``value`` and ``a[i,j,k]`` and atomically update the array.
+        doc="""Compute the minimum of ``value`` and ``arr[i,j,k]`` and atomically update the array.
 
     .. note:: The operation is only atomic on a per-component basis for vectors and matrices.""",
         group="Utility",
@@ -3008,9 +3482,9 @@ for array_type in array_types:
     add_builtin(
         "atomic_min",
         hidden=hidden,
-        input_types={"a": array_type(dtype=Any), "i": int, "j": int, "k": int, "l": int, "value": Any},
+        input_types={"arr": array_type(dtype=Any), "i": int, "j": int, "k": int, "l": int, "value": Any},
         value_func=atomic_op_value_func,
-        doc="""Compute the minimum of ``value`` and ``a[i,j,k,l]`` and atomically update the array.
+        doc="""Compute the minimum of ``value`` and ``arr[i,j,k,l]`` and atomically update the array.
 
     .. note:: The operation is only atomic on a per-component basis for vectors and matrices.""",
         group="Utility",
@@ -3020,9 +3494,9 @@ for array_type in array_types:
     add_builtin(
         "atomic_max",
         hidden=hidden,
-        input_types={"a": array_type(dtype=Any), "i": int, "value": Any},
+        input_types={"arr": array_type(dtype=Any), "i": int, "value": Any},
         value_func=atomic_op_value_func,
-        doc="""Compute the maximum of ``value`` and ``a[i]`` and atomically update the array.
+        doc="""Compute the maximum of ``value`` and ``arr[i]`` and atomically update the array.
 
     .. note:: The operation is only atomic on a per-component basis for vectors and matrices.""",
         group="Utility",
@@ -3031,9 +3505,9 @@ for array_type in array_types:
     add_builtin(
         "atomic_max",
         hidden=hidden,
-        input_types={"a": array_type(dtype=Any), "i": int, "j": int, "value": Any},
+        input_types={"arr": array_type(dtype=Any), "i": int, "j": int, "value": Any},
         value_func=atomic_op_value_func,
-        doc="""Compute the maximum of ``value`` and ``a[i,j]`` and atomically update the array.
+        doc="""Compute the maximum of ``value`` and ``arr[i,j]`` and atomically update the array.
 
     .. note:: The operation is only atomic on a per-component basis for vectors and matrices.""",
         group="Utility",
@@ -3042,9 +3516,9 @@ for array_type in array_types:
     add_builtin(
         "atomic_max",
         hidden=hidden,
-        input_types={"a": array_type(dtype=Any), "i": int, "j": int, "k": int, "value": Any},
+        input_types={"arr": array_type(dtype=Any), "i": int, "j": int, "k": int, "value": Any},
         value_func=atomic_op_value_func,
-        doc="""Compute the maximum of ``value`` and ``a[i,j,k]`` and atomically update the array.
+        doc="""Compute the maximum of ``value`` and ``arr[i,j,k]`` and atomically update the array.
 
     .. note:: The operation is only atomic on a per-component basis for vectors and matrices.""",
         group="Utility",
@@ -3053,9 +3527,9 @@ for array_type in array_types:
     add_builtin(
         "atomic_max",
         hidden=hidden,
-        input_types={"a": array_type(dtype=Any), "i": int, "j": int, "k": int, "l": int, "value": Any},
+        input_types={"arr": array_type(dtype=Any), "i": int, "j": int, "k": int, "l": int, "value": Any},
         value_func=atomic_op_value_func,
-        doc="""Compute the maximum of ``value`` and ``a[i,j,k,l]`` and atomically update the array.
+        doc="""Compute the maximum of ``value`` and ``arr[i,j,k,l]`` and atomically update the array.
 
     .. note:: The operation is only atomic on a per-component basis for vectors and matrices.""",
         group="Utility",
@@ -3064,21 +3538,21 @@ for array_type in array_types:
 
 
 # used to index into builtin types, i.e.: y = vec3[1]
-def index_value_func(arg_types, kwds, _):
-    return arg_types[0]._wp_scalar_type_
+def extract_value_func(arg_types: Mapping[str, type], arg_values: Mapping[str, Any]):
+    return arg_types["a"]._wp_scalar_type_
 
 
 add_builtin(
     "extract",
     input_types={"a": vector(length=Any, dtype=Scalar), "i": int},
-    value_func=index_value_func,
+    value_func=extract_value_func,
     hidden=True,
     group="Utility",
 )
 add_builtin(
     "extract",
     input_types={"a": quaternion(dtype=Scalar), "i": int},
-    value_func=index_value_func,
+    value_func=extract_value_func,
     hidden=True,
     group="Utility",
 )
@@ -3086,14 +3560,16 @@ add_builtin(
 add_builtin(
     "extract",
     input_types={"a": matrix(shape=(Any, Any), dtype=Scalar), "i": int},
-    value_func=lambda arg_types, kwds, _: vector(length=arg_types[0]._shape_[1], dtype=arg_types[0]._wp_scalar_type_),
+    value_func=lambda arg_types, arg_values: vector(
+        length=arg_types["a"]._shape_[1], dtype=arg_types["a"]._wp_scalar_type_
+    ),
     hidden=True,
     group="Utility",
 )
 add_builtin(
     "extract",
     input_types={"a": matrix(shape=(Any, Any), dtype=Scalar), "i": int, "j": int},
-    value_func=index_value_func,
+    value_func=extract_value_func,
     hidden=True,
     group="Utility",
 )
@@ -3101,7 +3577,7 @@ add_builtin(
 add_builtin(
     "extract",
     input_types={"a": transformation(dtype=Scalar), "i": int},
-    value_func=index_value_func,
+    value_func=extract_value_func,
     hidden=True,
     group="Utility",
 )
@@ -3109,19 +3585,35 @@ add_builtin(
 add_builtin("extract", input_types={"s": shape_t, "i": int}, value_type=int, hidden=True, group="Utility")
 
 
-def vector_indexref_element_value_func(arg_types, kwds, _):
-    vec_type = arg_types[0]
-    # index_type = arg_types[1]
+def vector_index_value_func(arg_types: Mapping[str, type], arg_values: Mapping[str, Any]):
+    vec_type = arg_types["a"]
     value_type = vec_type._wp_scalar_type_
 
     return Reference(value_type)
 
 
+def vector_index_dispatch_func(input_types: Mapping[str, type], return_type: Any, args: Mapping[str, Var]):
+    func_args = (Reference(args["a"]), args["i"])
+    template_args = ()
+    return (func_args, template_args)
+
+
 # implements &vector[index]
 add_builtin(
     "index",
     input_types={"a": vector(length=Any, dtype=Scalar), "i": int},
-    value_func=vector_indexref_element_value_func,
+    value_func=vector_index_value_func,
+    dispatch_func=vector_index_dispatch_func,
+    hidden=True,
+    group="Utility",
+    skip_replay=True,
+)
+# implements &quaternion[index]
+add_builtin(
+    "index",
+    input_types={"a": quaternion(dtype=Float), "i": int},
+    value_func=vector_index_value_func,
+    dispatch_func=vector_index_dispatch_func,
     hidden=True,
     group="Utility",
     skip_replay=True,
@@ -3129,27 +3621,28 @@ add_builtin(
 # implements &(*vector)[index]
 add_builtin(
     "indexref",
-    input_types={"a": Reference, "i": int},
-    value_func=vector_indexref_element_value_func,
+    input_types={"a": vector(length=Any, dtype=Scalar), "i": int},
+    value_func=vector_index_value_func,
+    dispatch_func=vector_index_dispatch_func,
+    hidden=True,
+    group="Utility",
+    skip_replay=True,
+)
+# implements &(*quaternion)[index]
+add_builtin(
+    "indexref",
+    input_types={"a": quaternion(dtype=Float), "i": int},
+    value_func=vector_index_value_func,
+    dispatch_func=vector_index_dispatch_func,
     hidden=True,
     group="Utility",
     skip_replay=True,
 )
 
 
-def matrix_indexref_element_value_func(arg_types, kwds, _):
-    mat_type = arg_types[0]
-    # row_type = arg_types[1]
-    # col_type = arg_types[2]
-    value_type = mat_type._wp_scalar_type_
-
-    return Reference(value_type)
-
-
-def matrix_indexref_row_value_func(arg_types, kwds, _):
-    mat_type = arg_types[0]
+def matrix_index_row_value_func(arg_types: Mapping[str, type], arg_values: Mapping[str, Any]):
+    mat_type = arg_types["a"]
     row_type = mat_type._wp_row_type_
-    # value_type = arg_types[2]
 
     return Reference(row_type)
 
@@ -3158,17 +3651,25 @@ def matrix_indexref_row_value_func(arg_types, kwds, _):
 add_builtin(
     "index",
     input_types={"a": matrix(shape=(Any, Any), dtype=Scalar), "i": int},
-    value_func=matrix_indexref_row_value_func,
+    value_func=matrix_index_row_value_func,
     hidden=True,
     group="Utility",
     skip_replay=True,
 )
 
+
+def matrix_index_value_func(arg_types: Mapping[str, type], arg_values: Mapping[str, Any]):
+    mat_type = arg_types["a"]
+    value_type = mat_type._wp_scalar_type_
+
+    return Reference(value_type)
+
+
 # implements matrix[i,j] = scalar
 add_builtin(
     "index",
     input_types={"a": matrix(shape=(Any, Any), dtype=Scalar), "i": int, "j": int},
-    value_func=matrix_indexref_element_value_func,
+    value_func=matrix_index_value_func,
     hidden=True,
     group="Utility",
     skip_replay=True,
@@ -3177,56 +3678,58 @@ add_builtin(
 for t in scalar_types + vector_types + (bool,):
     if "vec" in t.__name__ or "mat" in t.__name__:
         continue
+
     add_builtin(
         "expect_eq",
-        input_types={"arg1": t, "arg2": t},
+        input_types={"a": t, "b": t},
         value_type=None,
-        doc="Prints an error to stdout if ``arg1`` and ``arg2`` are not equal",
+        doc="Prints an error to stdout if ``a`` and ``b`` are not equal",
         group="Utility",
         hidden=True,
     )
 
 
-def expect_eq_val_func(arg_types, kwds, _):
-    if not types_equal(arg_types[0], arg_types[1]):
+def expect_eq_value_func(arg_types: Mapping[str, type], arg_values: Mapping[str, Any]):
+    if not types_equal(arg_types["a"], arg_types["b"]):
         raise RuntimeError("Can't test equality for objects with different types")
+
     return None
 
 
 add_builtin(
     "expect_eq",
-    input_types={"arg1": vector(length=Any, dtype=Scalar), "arg2": vector(length=Any, dtype=Scalar)},
+    input_types={"a": vector(length=Any, dtype=Scalar), "b": vector(length=Any, dtype=Scalar)},
     constraint=sametypes,
-    value_func=expect_eq_val_func,
-    doc="Prints an error to stdout if ``arg1`` and ``arg2`` are not equal",
+    value_func=expect_eq_value_func,
+    doc="Prints an error to stdout if ``a`` and ``b`` are not equal",
     group="Utility",
     hidden=True,
 )
 add_builtin(
     "expect_neq",
-    input_types={"arg1": vector(length=Any, dtype=Scalar), "arg2": vector(length=Any, dtype=Scalar)},
+    input_types={"a": vector(length=Any, dtype=Scalar), "b": vector(length=Any, dtype=Scalar)},
     constraint=sametypes,
-    value_func=expect_eq_val_func,
-    doc="Prints an error to stdout if ``arg1`` and ``arg2`` are equal",
+    value_func=expect_eq_value_func,
+    doc="Prints an error to stdout if ``a`` and ``b`` are equal",
     group="Utility",
     hidden=True,
 )
 
 add_builtin(
     "expect_eq",
-    input_types={"arg1": matrix(shape=(Any, Any), dtype=Scalar), "arg2": matrix(shape=(Any, Any), dtype=Scalar)},
+    input_types={"a": matrix(shape=(Any, Any), dtype=Scalar), "b": matrix(shape=(Any, Any), dtype=Scalar)},
     constraint=sametypes,
-    value_func=expect_eq_val_func,
-    doc="Prints an error to stdout if ``arg1`` and ``arg2`` are not equal",
+    value_func=expect_eq_value_func,
+    doc="Prints an error to stdout if ``a`` and ``b`` are not equal",
     group="Utility",
     hidden=True,
 )
 add_builtin(
     "expect_neq",
-    input_types={"arg1": matrix(shape=(Any, Any), dtype=Scalar), "arg2": matrix(shape=(Any, Any), dtype=Scalar)},
+    input_types={"a": matrix(shape=(Any, Any), dtype=Scalar), "b": matrix(shape=(Any, Any), dtype=Scalar)},
     constraint=sametypes,
-    value_func=expect_eq_val_func,
-    doc="Prints an error to stdout if ``arg1`` and ``arg2`` are equal",
+    value_func=expect_eq_value_func,
+    doc="Prints an error to stdout if ``a`` and ``b`` are equal",
     group="Utility",
     hidden=True,
 )
@@ -3234,35 +3737,36 @@ add_builtin(
 add_builtin(
     "lerp",
     input_types={"a": Float, "b": Float, "t": Float},
-    value_func=sametype_value_func(Float),
+    value_func=sametypes_create_value_func(Float),
     doc="Linearly interpolate two values ``a`` and ``b`` using factor ``t``, computed as ``a*(1-t) + b*t``",
     group="Utility",
 )
 add_builtin(
     "smoothstep",
-    input_types={"edge0": Float, "edge1": Float, "x": Float},
-    value_func=sametype_value_func(Float),
-    doc="""Smoothly interpolate between two values ``edge0`` and ``edge1`` using a factor ``x``,
+    input_types={"a": Float, "b": Float, "x": Float},
+    value_func=sametypes_create_value_func(Float),
+    doc="""Smoothly interpolate between two values ``a`` and ``b`` using a factor ``x``,
     and return a result between 0 and 1 using a cubic Hermite interpolation after clamping.""",
     group="Utility",
 )
 
 
-def lerp_constraint(arg_types):
-    return types_equal(arg_types[0], arg_types[1])
+def lerp_constraint(arg_types: Mapping[str, type]):
+    return types_equal(arg_types["a"], arg_types["b"])
 
 
-def lerp_value_func(default):
-    def fn(arg_types, kwds, _):
+def lerp_create_value_func(default):
+    def fn(arg_types, arg_values):
         if arg_types is None:
             return default
-        scalar_type = arg_types[-1]
+
         if not lerp_constraint(arg_types):
             raise RuntimeError("Can't lerp between objects with different types")
-        if arg_types[0]._wp_scalar_type_ != scalar_type:
+
+        if arg_types["a"]._wp_scalar_type_ != arg_types["t"]:
             raise RuntimeError("'t' parameter must have the same scalar type as objects you're lerping between")
 
-        return arg_types[0]
+        return arg_types["a"]
 
     return fn
 
@@ -3271,7 +3775,7 @@ add_builtin(
     "lerp",
     input_types={"a": vector(length=Any, dtype=Float), "b": vector(length=Any, dtype=Float), "t": Float},
     constraint=lerp_constraint,
-    value_func=lerp_value_func(vector(length=Any, dtype=Float)),
+    value_func=lerp_create_value_func(vector(length=Any, dtype=Float)),
     doc="Linearly interpolate two values ``a`` and ``b`` using factor ``t``, computed as ``a*(1-t) + b*t``",
     group="Utility",
 )
@@ -3279,21 +3783,21 @@ add_builtin(
     "lerp",
     input_types={"a": matrix(shape=(Any, Any), dtype=Float), "b": matrix(shape=(Any, Any), dtype=Float), "t": Float},
     constraint=lerp_constraint,
-    value_func=lerp_value_func(matrix(shape=(Any, Any), dtype=Float)),
+    value_func=lerp_create_value_func(matrix(shape=(Any, Any), dtype=Float)),
     doc="Linearly interpolate two values ``a`` and ``b`` using factor ``t``, computed as ``a*(1-t) + b*t``",
     group="Utility",
 )
 add_builtin(
     "lerp",
     input_types={"a": quaternion(dtype=Float), "b": quaternion(dtype=Float), "t": Float},
-    value_func=lerp_value_func(quaternion(dtype=Float)),
+    value_func=lerp_create_value_func(quaternion(dtype=Float)),
     doc="Linearly interpolate two values ``a`` and ``b`` using factor ``t``, computed as ``a*(1-t) + b*t``",
     group="Utility",
 )
 add_builtin(
     "lerp",
     input_types={"a": transformation(dtype=Float), "b": transformation(dtype=Float), "t": Float},
-    value_func=lerp_value_func(transformation(dtype=Float)),
+    value_func=lerp_create_value_func(transformation(dtype=Float)),
     doc="Linearly interpolate two values ``a`` and ``b`` using factor ``t``, computed as ``a*(1-t) + b*t``",
     group="Utility",
 )
@@ -3301,17 +3805,18 @@ add_builtin(
 # fuzzy compare for float values
 add_builtin(
     "expect_near",
-    input_types={"arg1": Float, "arg2": Float, "tolerance": Float},
+    input_types={"a": Float, "b": Float, "tolerance": Float},
     defaults={"tolerance": 1.0e-6},
     value_type=None,
-    doc="Prints an error to stdout if ``arg1`` and ``arg2`` are not closer than tolerance in magnitude",
+    doc="Prints an error to stdout if ``a`` and ``b`` are not closer than tolerance in magnitude",
     group="Utility",
 )
 add_builtin(
     "expect_near",
-    input_types={"arg1": vec3, "arg2": vec3, "tolerance": float},
+    input_types={"a": vec3, "b": vec3, "tolerance": float},
+    defaults={"tolerance": 1.0e-6},
     value_type=None,
-    doc="Prints an error to stdout if any element of ``arg1`` and ``arg2`` are not closer than tolerance in magnitude",
+    doc="Prints an error to stdout if any element of ``a`` and ``b`` are not closer than tolerance in magnitude",
     group="Utility",
 )
 
@@ -3335,359 +3840,378 @@ add_builtin(
 # ---------------------------------
 # Operators
 
-add_builtin("add", input_types={"x": Scalar, "y": Scalar}, value_func=sametype_value_func(Scalar), group="Operators")
+add_builtin(
+    "add", input_types={"a": Scalar, "b": Scalar}, value_func=sametypes_create_value_func(Scalar), group="Operators"
+)
 add_builtin(
     "add",
-    input_types={"x": vector(length=Any, dtype=Scalar), "y": vector(length=Any, dtype=Scalar)},
+    input_types={"a": vector(length=Any, dtype=Scalar), "b": vector(length=Any, dtype=Scalar)},
     constraint=sametypes,
-    value_func=sametype_value_func(vector(length=Any, dtype=Scalar)),
+    value_func=sametypes_create_value_func(vector(length=Any, dtype=Scalar)),
     doc="",
     group="Operators",
 )
 add_builtin(
     "add",
-    input_types={"x": quaternion(dtype=Scalar), "y": quaternion(dtype=Scalar)},
-    value_func=sametype_value_func(quaternion(dtype=Scalar)),
+    input_types={"a": quaternion(dtype=Scalar), "b": quaternion(dtype=Scalar)},
+    value_func=sametypes_create_value_func(quaternion(dtype=Scalar)),
     doc="",
     group="Operators",
 )
 add_builtin(
     "add",
-    input_types={"x": matrix(shape=(Any, Any), dtype=Scalar), "y": matrix(shape=(Any, Any), dtype=Scalar)},
+    input_types={"a": matrix(shape=(Any, Any), dtype=Scalar), "b": matrix(shape=(Any, Any), dtype=Scalar)},
     constraint=sametypes,
-    value_func=sametype_value_func(matrix(shape=(Any, Any), dtype=Scalar)),
+    value_func=sametypes_create_value_func(matrix(shape=(Any, Any), dtype=Scalar)),
     doc="",
     group="Operators",
 )
 add_builtin(
     "add",
-    input_types={"x": transformation(dtype=Scalar), "y": transformation(dtype=Scalar)},
-    value_func=sametype_value_func(transformation(dtype=Scalar)),
+    input_types={"a": transformation(dtype=Scalar), "b": transformation(dtype=Scalar)},
+    value_func=sametypes_create_value_func(transformation(dtype=Scalar)),
     doc="",
     group="Operators",
 )
 
-add_builtin("sub", input_types={"x": Scalar, "y": Scalar}, value_func=sametype_value_func(Scalar), group="Operators")
+add_builtin(
+    "sub", input_types={"a": Scalar, "b": Scalar}, value_func=sametypes_create_value_func(Scalar), group="Operators"
+)
 add_builtin(
     "sub",
-    input_types={"x": vector(length=Any, dtype=Scalar), "y": vector(length=Any, dtype=Scalar)},
+    input_types={"a": vector(length=Any, dtype=Scalar), "b": vector(length=Any, dtype=Scalar)},
     constraint=sametypes,
-    value_func=sametype_value_func(vector(length=Any, dtype=Scalar)),
+    value_func=sametypes_create_value_func(vector(length=Any, dtype=Scalar)),
     doc="",
     group="Operators",
 )
 add_builtin(
     "sub",
-    input_types={"x": matrix(shape=(Any, Any), dtype=Scalar), "y": matrix(shape=(Any, Any), dtype=Scalar)},
+    input_types={"a": matrix(shape=(Any, Any), dtype=Scalar), "b": matrix(shape=(Any, Any), dtype=Scalar)},
     constraint=sametypes,
-    value_func=sametype_value_func(matrix(shape=(Any, Any), dtype=Scalar)),
+    value_func=sametypes_create_value_func(matrix(shape=(Any, Any), dtype=Scalar)),
     doc="",
     group="Operators",
 )
 add_builtin(
     "sub",
-    input_types={"x": quaternion(dtype=Scalar), "y": quaternion(dtype=Scalar)},
-    value_func=sametype_value_func(quaternion(dtype=Scalar)),
+    input_types={"a": quaternion(dtype=Scalar), "b": quaternion(dtype=Scalar)},
+    value_func=sametypes_create_value_func(quaternion(dtype=Scalar)),
     doc="",
     group="Operators",
 )
 add_builtin(
     "sub",
-    input_types={"x": transformation(dtype=Scalar), "y": transformation(dtype=Scalar)},
-    value_func=sametype_value_func(transformation(dtype=Scalar)),
+    input_types={"a": transformation(dtype=Scalar), "b": transformation(dtype=Scalar)},
+    value_func=sametypes_create_value_func(transformation(dtype=Scalar)),
     doc="",
     group="Operators",
 )
 
 # bitwise operators
-add_builtin("bit_and", input_types={"x": Int, "y": Int}, value_func=sametype_value_func(Int))
-add_builtin("bit_or", input_types={"x": Int, "y": Int}, value_func=sametype_value_func(Int))
-add_builtin("bit_xor", input_types={"x": Int, "y": Int}, value_func=sametype_value_func(Int))
-add_builtin("lshift", input_types={"x": Int, "y": Int}, value_func=sametype_value_func(Int))
-add_builtin("rshift", input_types={"x": Int, "y": Int}, value_func=sametype_value_func(Int))
-add_builtin("invert", input_types={"x": Int}, value_func=sametype_value_func(Int))
+add_builtin("bit_and", input_types={"a": Int, "b": Int}, value_func=sametypes_create_value_func(Int))
+add_builtin("bit_or", input_types={"a": Int, "b": Int}, value_func=sametypes_create_value_func(Int))
+add_builtin("bit_xor", input_types={"a": Int, "b": Int}, value_func=sametypes_create_value_func(Int))
+add_builtin("lshift", input_types={"a": Int, "b": Int}, value_func=sametypes_create_value_func(Int))
+add_builtin("rshift", input_types={"a": Int, "b": Int}, value_func=sametypes_create_value_func(Int))
+add_builtin("invert", input_types={"a": Int}, value_func=sametypes_create_value_func(Int))
+
+
+add_builtin(
+    "mul", input_types={"a": Scalar, "b": Scalar}, value_func=sametypes_create_value_func(Scalar), group="Operators"
+)
 
 
-def scalar_mul_value_func(default):
-    def fn(arg_types, kwds, _):
+def scalar_mul_create_value_func(default):
+    def fn(arg_types, arg_values):
         if arg_types is None:
             return default
-        scalar = [t for t in arg_types if t in scalar_types][0]
-        compound = [t for t in arg_types if t not in scalar_types][0]
+
+        scalar = next(t for t in arg_types.values() if t in scalar_types)
+        compound = next(t for t in arg_types.values() if t not in scalar_types)
         if scalar != compound._wp_scalar_type_:
             raise RuntimeError("Object and coefficient must have the same scalar type when multiplying by scalar")
+
         return compound
 
     return fn
 
 
-def mul_matvec_constraint(arg_types):
-    return arg_types[0]._shape_[1] == arg_types[1]._length_
-
-
-def mul_matvec_value_func(arg_types, kwds, _):
-    if arg_types is None:
-        return vector(length=Any, dtype=Scalar)
-
-    if arg_types[0]._wp_scalar_type_ != arg_types[1]._wp_scalar_type_:
-        raise RuntimeError(
-            f"Can't multiply matrix and vector with different types {arg_types[0]._wp_scalar_type_}, {arg_types[1]._wp_scalar_type_}"
-        )
-
-    if not mul_matmat_constraint(arg_types):
-        raise RuntimeError(
-            f"Can't multiply matrix of shape {arg_types[0]._shape_} and vector with length {arg_types[1]._length_}"
-        )
-
-    return vector(length=arg_types[0]._shape_[0], dtype=arg_types[0]._wp_scalar_type_)
-
-
-def mul_vecmat_constraint(arg_types):
-    return arg_types[1]._shape_[0] == arg_types[0]._length_
-
-
-def mul_vecmat_value_func(arg_types, kwds, _):
-    if arg_types is None:
-        return vector(length=Any, dtype=Scalar)
-
-    if arg_types[1]._wp_scalar_type_ != arg_types[0]._wp_scalar_type_:
-        raise RuntimeError(
-            f"Can't multiply vector and matrix with different types {arg_types[1]._wp_scalar_type_}, {arg_types[0]._wp_scalar_type_}"
-        )
-
-    if not mul_vecmat_constraint(arg_types):
-        raise RuntimeError(
-            f"Can't multiply vector with length {arg_types[0]._length_} and matrix of shape {arg_types[1]._shape_}"
-        )
-
-    return vector(length=arg_types[1]._shape_[1], dtype=arg_types[1]._wp_scalar_type_)
-
-
-def mul_matmat_constraint(arg_types):
-    return arg_types[0]._shape_[1] == arg_types[1]._shape_[0]
-
-
-def mul_matmat_value_func(arg_types, kwds, _):
-    if arg_types is None:
-        return matrix(length=Any, dtype=Scalar)
-
-    if arg_types[0]._wp_scalar_type_ != arg_types[1]._wp_scalar_type_:
-        raise RuntimeError(
-            f"Can't multiply matrices with different types {arg_types[0]._wp_scalar_type_}, {arg_types[1]._wp_scalar_type_}"
-        )
-
-    if not mul_matmat_constraint(arg_types):
-        raise RuntimeError(f"Can't multiply matrix of shapes {arg_types[0]._shape_} and {arg_types[1]._shape_}")
-
-    return matrix(shape=(arg_types[0]._shape_[0], arg_types[1]._shape_[1]), dtype=arg_types[0]._wp_scalar_type_)
-
-
-add_builtin("mul", input_types={"x": Scalar, "y": Scalar}, value_func=sametype_value_func(Scalar), group="Operators")
 add_builtin(
     "mul",
-    input_types={"x": vector(length=Any, dtype=Scalar), "y": Scalar},
-    value_func=scalar_mul_value_func(vector(length=Any, dtype=Scalar)),
+    input_types={"a": vector(length=Any, dtype=Scalar), "b": Scalar},
+    value_func=scalar_mul_create_value_func(vector(length=Any, dtype=Scalar)),
     doc="",
     group="Operators",
 )
 add_builtin(
     "mul",
-    input_types={"x": Scalar, "y": vector(length=Any, dtype=Scalar)},
-    value_func=scalar_mul_value_func(vector(length=Any, dtype=Scalar)),
+    input_types={"a": Scalar, "b": vector(length=Any, dtype=Scalar)},
+    value_func=scalar_mul_create_value_func(vector(length=Any, dtype=Scalar)),
     doc="",
     group="Operators",
 )
 add_builtin(
     "mul",
-    input_types={"x": quaternion(dtype=Scalar), "y": Scalar},
-    value_func=scalar_mul_value_func(quaternion(dtype=Scalar)),
+    input_types={"a": quaternion(dtype=Scalar), "b": Scalar},
+    value_func=scalar_mul_create_value_func(quaternion(dtype=Scalar)),
     doc="",
     group="Operators",
 )
 add_builtin(
     "mul",
-    input_types={"x": Scalar, "y": quaternion(dtype=Scalar)},
-    value_func=scalar_mul_value_func(quaternion(dtype=Scalar)),
+    input_types={"a": Scalar, "b": quaternion(dtype=Scalar)},
+    value_func=scalar_mul_create_value_func(quaternion(dtype=Scalar)),
     doc="",
     group="Operators",
 )
 add_builtin(
     "mul",
-    input_types={"x": quaternion(dtype=Scalar), "y": quaternion(dtype=Scalar)},
-    value_func=sametype_value_func(quaternion(dtype=Scalar)),
+    input_types={"a": quaternion(dtype=Scalar), "b": quaternion(dtype=Scalar)},
+    value_func=sametypes_create_value_func(quaternion(dtype=Scalar)),
     doc="",
     group="Operators",
 )
 add_builtin(
     "mul",
-    input_types={"x": Scalar, "y": matrix(shape=(Any, Any), dtype=Scalar)},
-    value_func=scalar_mul_value_func(matrix(shape=(Any, Any), dtype=Scalar)),
+    input_types={"a": Scalar, "b": matrix(shape=(Any, Any), dtype=Scalar)},
+    value_func=scalar_mul_create_value_func(matrix(shape=(Any, Any), dtype=Scalar)),
     doc="",
     group="Operators",
 )
 add_builtin(
     "mul",
-    input_types={"x": matrix(shape=(Any, Any), dtype=Scalar), "y": Scalar},
-    value_func=scalar_mul_value_func(matrix(shape=(Any, Any), dtype=Scalar)),
+    input_types={"a": matrix(shape=(Any, Any), dtype=Scalar), "b": Scalar},
+    value_func=scalar_mul_create_value_func(matrix(shape=(Any, Any), dtype=Scalar)),
     doc="",
     group="Operators",
 )
+
+
+def matvec_mul_constraint(arg_types: Mapping[str, type]):
+    return arg_types["a"]._shape_[1] == arg_types["b"]._length_
+
+
+def matvec_mul_value_func(arg_types: Mapping[str, type], arg_values: Mapping[str, Any]):
+    if arg_types is None:
+        return vector(length=Any, dtype=Scalar)
+
+    if arg_types["a"]._wp_scalar_type_ != arg_types["b"]._wp_scalar_type_:
+        raise RuntimeError(
+            f"Can't multiply matrix and vector with different types {arg_types['a']._wp_scalar_type_}, {arg_types['b']._wp_scalar_type_}"
+        )
+
+    if not matvec_mul_constraint(arg_types):
+        raise RuntimeError(
+            f"Can't multiply matrix of shape {arg_types['a']._shape_} and vector with length {arg_types['b']._length_}"
+        )
+
+    return vector(length=arg_types["a"]._shape_[0], dtype=arg_types["a"]._wp_scalar_type_)
+
+
 add_builtin(
     "mul",
-    input_types={"x": matrix(shape=(Any, Any), dtype=Scalar), "y": vector(length=Any, dtype=Scalar)},
-    constraint=mul_matvec_constraint,
-    value_func=mul_matvec_value_func,
+    input_types={"a": matrix(shape=(Any, Any), dtype=Scalar), "b": vector(length=Any, dtype=Scalar)},
+    constraint=matvec_mul_constraint,
+    value_func=matvec_mul_value_func,
     doc="",
     group="Operators",
 )
+
+
+def mul_vecmat_constraint(arg_types: Mapping[str, type]):
+    return arg_types["b"]._shape_[0] == arg_types["a"]._length_
+
+
+def mul_vecmat_value_func(arg_types: Mapping[str, type], arg_values: Mapping[str, Any]):
+    if arg_types is None:
+        return vector(length=Any, dtype=Scalar)
+
+    if arg_types["b"]._wp_scalar_type_ != arg_types["a"]._wp_scalar_type_:
+        raise RuntimeError(
+            f"Can't multiply vector and matrix with different types {arg_types['b']._wp_scalar_type_}, {arg_types['a']._wp_scalar_type_}"
+        )
+
+    if not mul_vecmat_constraint(arg_types):
+        raise RuntimeError(
+            f"Can't multiply vector with length {arg_types['a']._length_} and matrix of shape {arg_types['b']._shape_}"
+        )
+
+    return vector(length=arg_types["b"]._shape_[1], dtype=arg_types["b"]._wp_scalar_type_)
+
+
 add_builtin(
     "mul",
-    input_types={"x": vector(length=Any, dtype=Scalar), "y": matrix(shape=(Any, Any), dtype=Scalar)},
+    input_types={"a": vector(length=Any, dtype=Scalar), "b": matrix(shape=(Any, Any), dtype=Scalar)},
     constraint=mul_vecmat_constraint,
     value_func=mul_vecmat_value_func,
     doc="",
     group="Operators",
 )
+
+
+def matmat_mul_constraint(arg_types: Mapping[str, type]):
+    return arg_types["a"]._shape_[1] == arg_types["b"]._shape_[0]
+
+
+def matmat_mul_value_func(arg_types: Mapping[str, type], arg_values: Mapping[str, Any]):
+    if arg_types is None:
+        return matrix(length=Any, dtype=Scalar)
+
+    if arg_types["a"]._wp_scalar_type_ != arg_types["b"]._wp_scalar_type_:
+        raise RuntimeError(
+            f"Can't multiply matrices with different types {arg_types['a']._wp_scalar_type_}, {arg_types['b']._wp_scalar_type_}"
+        )
+
+    if not matmat_mul_constraint(arg_types):
+        raise RuntimeError(f"Can't multiply matrix of shapes {arg_types['a']._shape_} and {arg_types['b']._shape_}")
+
+    return matrix(shape=(arg_types["a"]._shape_[0], arg_types["b"]._shape_[1]), dtype=arg_types["a"]._wp_scalar_type_)
+
+
 add_builtin(
     "mul",
-    input_types={"x": matrix(shape=(Any, Any), dtype=Scalar), "y": matrix(shape=(Any, Any), dtype=Scalar)},
-    constraint=mul_matmat_constraint,
-    value_func=mul_matmat_value_func,
+    input_types={"a": matrix(shape=(Any, Any), dtype=Scalar), "b": matrix(shape=(Any, Any), dtype=Scalar)},
+    constraint=matmat_mul_constraint,
+    value_func=matmat_mul_value_func,
     doc="",
     group="Operators",
 )
 
+
 add_builtin(
     "mul",
-    input_types={"x": transformation(dtype=Scalar), "y": transformation(dtype=Scalar)},
-    value_func=sametype_value_func(transformation(dtype=Scalar)),
+    input_types={"a": transformation(dtype=Scalar), "b": transformation(dtype=Scalar)},
+    value_func=sametypes_create_value_func(transformation(dtype=Scalar)),
     doc="",
     group="Operators",
 )
 add_builtin(
     "mul",
-    input_types={"x": Scalar, "y": transformation(dtype=Scalar)},
-    value_func=scalar_mul_value_func(transformation(dtype=Scalar)),
+    input_types={"a": Scalar, "b": transformation(dtype=Scalar)},
+    value_func=scalar_mul_create_value_func(transformation(dtype=Scalar)),
     doc="",
     group="Operators",
 )
 add_builtin(
     "mul",
-    input_types={"x": transformation(dtype=Scalar), "y": Scalar},
-    value_func=scalar_mul_value_func(transformation(dtype=Scalar)),
+    input_types={"a": transformation(dtype=Scalar), "b": Scalar},
+    value_func=scalar_mul_create_value_func(transformation(dtype=Scalar)),
     doc="",
     group="Operators",
 )
 
-add_builtin("mod", input_types={"x": Scalar, "y": Scalar}, value_func=sametype_value_func(Scalar), group="Operators")
+add_builtin(
+    "mod", input_types={"a": Scalar, "b": Scalar}, value_func=sametypes_create_value_func(Scalar), group="Operators"
+)
 
 add_builtin(
     "div",
-    input_types={"x": Scalar, "y": Scalar},
-    value_func=sametype_value_func(Scalar),
+    input_types={"a": Scalar, "b": Scalar},
+    value_func=sametypes_create_value_func(Scalar),
     doc="",
     group="Operators",
     require_original_output_arg=True,
 )
 add_builtin(
     "div",
-    input_types={"x": vector(length=Any, dtype=Scalar), "y": Scalar},
-    value_func=scalar_mul_value_func(vector(length=Any, dtype=Scalar)),
+    input_types={"a": vector(length=Any, dtype=Scalar), "b": Scalar},
+    value_func=scalar_mul_create_value_func(vector(length=Any, dtype=Scalar)),
     doc="",
     group="Operators",
 )
 add_builtin(
     "div",
-    input_types={"x": Scalar, "y": vector(length=Any, dtype=Scalar)},
-    value_func=scalar_mul_value_func(vector(length=Any, dtype=Scalar)),
+    input_types={"a": Scalar, "b": vector(length=Any, dtype=Scalar)},
+    value_func=scalar_mul_create_value_func(vector(length=Any, dtype=Scalar)),
     doc="",
     group="Operators",
 )
 add_builtin(
     "div",
-    input_types={"x": matrix(shape=(Any, Any), dtype=Scalar), "y": Scalar},
-    value_func=scalar_mul_value_func(matrix(shape=(Any, Any), dtype=Scalar)),
+    input_types={"a": matrix(shape=(Any, Any), dtype=Scalar), "b": Scalar},
+    value_func=scalar_mul_create_value_func(matrix(shape=(Any, Any), dtype=Scalar)),
     doc="",
     group="Operators",
 )
 add_builtin(
     "div",
-    input_types={"x": Scalar, "y": matrix(shape=(Any, Any), dtype=Scalar)},
-    value_func=scalar_mul_value_func(matrix(shape=(Any, Any), dtype=Scalar)),
+    input_types={"a": Scalar, "b": matrix(shape=(Any, Any), dtype=Scalar)},
+    value_func=scalar_mul_create_value_func(matrix(shape=(Any, Any), dtype=Scalar)),
     doc="",
     group="Operators",
 )
 add_builtin(
     "div",
-    input_types={"x": quaternion(dtype=Scalar), "y": Scalar},
-    value_func=scalar_mul_value_func(quaternion(dtype=Scalar)),
+    input_types={"a": quaternion(dtype=Scalar), "b": Scalar},
+    value_func=scalar_mul_create_value_func(quaternion(dtype=Scalar)),
     doc="",
     group="Operators",
 )
 add_builtin(
     "div",
-    input_types={"x": Scalar, "y": quaternion(dtype=Scalar)},
-    value_func=scalar_mul_value_func(quaternion(dtype=Scalar)),
+    input_types={"a": Scalar, "b": quaternion(dtype=Scalar)},
+    value_func=scalar_mul_create_value_func(quaternion(dtype=Scalar)),
     doc="",
     group="Operators",
 )
 
 add_builtin(
     "floordiv",
-    input_types={"x": Scalar, "y": Scalar},
-    value_func=sametype_value_func(Scalar),
+    input_types={"a": Scalar, "b": Scalar},
+    value_func=sametypes_create_value_func(Scalar),
     doc="",
     group="Operators",
 )
 
-add_builtin("pos", input_types={"x": Scalar}, value_func=sametype_value_func(Scalar), group="Operators")
+add_builtin("pos", input_types={"x": Scalar}, value_func=sametypes_create_value_func(Scalar), group="Operators")
 add_builtin(
     "pos",
     input_types={"x": vector(length=Any, dtype=Scalar)},
-    value_func=sametype_value_func(vector(length=Any, dtype=Scalar)),
+    value_func=sametypes_create_value_func(vector(length=Any, dtype=Scalar)),
     doc="",
     group="Operators",
 )
 add_builtin(
     "pos",
     input_types={"x": quaternion(dtype=Scalar)},
-    value_func=sametype_value_func(quaternion(dtype=Scalar)),
+    value_func=sametypes_create_value_func(quaternion(dtype=Scalar)),
     doc="",
     group="Operators",
 )
 add_builtin(
     "pos",
     input_types={"x": matrix(shape=(Any, Any), dtype=Scalar)},
-    value_func=sametype_value_func(matrix(shape=(Any, Any), dtype=Scalar)),
+    value_func=sametypes_create_value_func(matrix(shape=(Any, Any), dtype=Scalar)),
     doc="",
     group="Operators",
 )
-add_builtin("neg", input_types={"x": Scalar}, value_func=sametype_value_func(Scalar), group="Operators")
+add_builtin("neg", input_types={"x": Scalar}, value_func=sametypes_create_value_func(Scalar), group="Operators")
 add_builtin(
     "neg",
     input_types={"x": vector(length=Any, dtype=Scalar)},
-    value_func=sametype_value_func(vector(length=Any, dtype=Scalar)),
+    value_func=sametypes_create_value_func(vector(length=Any, dtype=Scalar)),
     doc="",
     group="Operators",
 )
 add_builtin(
     "neg",
     input_types={"x": quaternion(dtype=Scalar)},
-    value_func=sametype_value_func(quaternion(dtype=Scalar)),
+    value_func=sametypes_create_value_func(quaternion(dtype=Scalar)),
     doc="",
     group="Operators",
 )
 add_builtin(
     "neg",
     input_types={"x": matrix(shape=(Any, Any), dtype=Scalar)},
-    value_func=sametype_value_func(matrix(shape=(Any, Any), dtype=Scalar)),
+    value_func=sametypes_create_value_func(matrix(shape=(Any, Any), dtype=Scalar)),
     doc="",
     group="Operators",
 )
 
-add_builtin("unot", input_types={"b": builtins.bool}, value_type=builtins.bool, doc="", group="Operators")
+add_builtin("unot", input_types={"a": builtins.bool}, value_type=builtins.bool, doc="", group="Operators")
 for t in int_types:
-    add_builtin("unot", input_types={"b": t}, value_type=builtins.bool, doc="", group="Operators")
+    add_builtin("unot", input_types={"a": t}, value_type=builtins.bool, doc="", group="Operators")
 
 
 add_builtin("unot", input_types={"a": array(dtype=Any)}, value_type=builtins.bool, doc="", group="Operators")