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

warp/codegen.py

@@ -20,6 +20,27 @@ from typing import Any, Callable, Mapping
 import warp.config
 from warp.types import *
 
+
+class WarpCodegenError(RuntimeError):
+    def __init__(self, message):
+        super().__init__(message)
+
+
+class WarpCodegenTypeError(TypeError):
+    def __init__(self, message):
+        super().__init__(message)
+
+
+class WarpCodegenAttributeError(AttributeError):
+    def __init__(self, message):
+        super().__init__(message)
+
+
+class WarpCodegenKeyError(KeyError):
+    def __init__(self, message):
+        super().__init__(message)
+
+
 # map operator to function name
 builtin_operators = {}
 
@@ -52,6 +73,19 @@ builtin_operators[ast.Invert] = "invert"
 builtin_operators[ast.LShift] = "lshift"
 builtin_operators[ast.RShift] = "rshift"
 
+comparison_chain_strings = [
+    builtin_operators[ast.Gt],
+    builtin_operators[ast.Lt],
+    builtin_operators[ast.LtE],
+    builtin_operators[ast.GtE],
+    builtin_operators[ast.Eq],
+    builtin_operators[ast.NotEq],
+]
+
+
+def op_str_is_chainable(op: str) -> builtins.bool:
+    return op in comparison_chain_strings
+
 
 def get_annotations(obj: Any) -> Mapping[str, Any]:
     """Alternative to `inspect.get_annotations()` for Python 3.9 and older."""
@@ -65,16 +99,14 @@ def get_annotations(obj: Any) -> Mapping[str, Any]:
 def struct_instance_repr_recursive(inst: StructInstance, depth: int) -> str:
     indent = "\t"
 
-    if inst._cls.ctype._fields_ == [("_dummy_", ctypes.c_int)]:
+    # handle empty structs
+    if len(inst._cls.vars) == 0:
         return f"{inst._cls.key}()"
 
     lines = []
     lines.append(f"{inst._cls.key}(")
 
     for field_name, _ in inst._cls.ctype._fields_:
-        if field_name == "_dummy_":
-            continue
-
         field_value = getattr(inst, field_name, None)
 
         if isinstance(field_value, StructInstance):
@@ -121,9 +153,7 @@ class StructInstance:
                 assert isinstance(value, array)
                 assert types_equal(
                     value.dtype, var.type.dtype
-                ), "assign to struct member variable {} failed, expected type {}, got type {}".format(
-                    name, type_repr(var.type.dtype), type_repr(value.dtype)
-                )
+                ), f"assign to struct member variable {name} failed, expected type {type_repr(var.type.dtype)}, got type {type_repr(value.dtype)}"
                 setattr(self._ctype, name, value.__ctype__())
 
         elif isinstance(var.type, Struct):
@@ -242,7 +272,7 @@ class Struct:
 
         class StructType(ctypes.Structure):
             # if struct is empty, add a dummy field to avoid launch errors on CPU device ("ffi_prep_cif failed")
-            _fields_ = fields or [("_dummy_", ctypes.c_int)]
+            _fields_ = fields or [("_dummy_", ctypes.c_byte)]
 
         self.ctype = StructType
 
@@ -363,21 +393,38 @@ class Struct:
         return instance
 
 
+class Reference:
+    def __init__(self, value_type):
+        self.value_type = value_type
+
+
+def is_reference(type):
+    return isinstance(type, Reference)
+
+
+def strip_reference(arg):
+    if is_reference(arg):
+        return arg.value_type
+    else:
+        return arg
+
+
 def compute_type_str(base_name, template_params):
-    if template_params is None or len(template_params) == 0:
+    if not template_params:
         return base_name
-    else:
 
-        def param2str(p):
-            if isinstance(p, int):
-                return str(p)
-            return p.__name__
+    def param2str(p):
+        if isinstance(p, int):
+            return str(p)
+        elif hasattr(p, "_type_"):
+            return f"wp::{p.__name__}"
+        return p.__name__
 
-        return f"{base_name}<{','.join(map(param2str, template_params))}>"
+    return f"{base_name}<{','.join(map(param2str, template_params))}>"
 
 
 class Var:
-    def __init__(self, label, type, requires_grad=False, constant=None, prefix=True, is_adjoint=False):
+    def __init__(self, label, type, requires_grad=False, constant=None, prefix=True):
         # convert built-in types to wp types
         if type == float:
             type = float32
@@ -389,27 +436,39 @@ class Var:
         self.requires_grad = requires_grad
         self.constant = constant
         self.prefix = prefix
-        self.is_adjoint = is_adjoint
 
     def __str__(self):
         return self.label
 
-    def ctype(self):
-        if is_array(self.type):
-            if hasattr(self.type.dtype, "_wp_generic_type_str_"):
-                dtypestr = compute_type_str(self.type.dtype._wp_generic_type_str_, self.type.dtype._wp_type_params_)
-            elif isinstance(self.type.dtype, Struct):
-                dtypestr = make_full_qualified_name(self.type.dtype.cls)
+    @staticmethod
+    def type_to_ctype(t, value_type=False):
+        if is_array(t):
+            if hasattr(t.dtype, "_wp_generic_type_str_"):
+                dtypestr = compute_type_str(f"wp::{t.dtype._wp_generic_type_str_}", t.dtype._wp_type_params_)
+            elif isinstance(t.dtype, Struct):
+                dtypestr = make_full_qualified_name(t.dtype.cls)
+            elif t.dtype.__name__ in ("bool", "int", "float"):
+                dtypestr = t.dtype.__name__
             else:
-                dtypestr = str(self.type.dtype.__name__)
-            classstr = type(self.type).__name__
+                dtypestr = f"wp::{t.dtype.__name__}"
+            classstr = f"wp::{type(t).__name__}"
             return f"{classstr}_t<{dtypestr}>"
-        elif isinstance(self.type, Struct):
-            return make_full_qualified_name(self.type.cls)
-        elif hasattr(self.type, "_wp_generic_type_str_"):
-            return compute_type_str(self.type._wp_generic_type_str_, self.type._wp_type_params_)
+        elif isinstance(t, Struct):
+            return make_full_qualified_name(t.cls)
+        elif is_reference(t):
+            if not value_type:
+                return Var.type_to_ctype(t.value_type) + "*"
+            else:
+                return Var.type_to_ctype(t.value_type)
+        elif hasattr(t, "_wp_generic_type_str_"):
+            return compute_type_str(f"wp::{t._wp_generic_type_str_}", t._wp_type_params_)
+        elif t.__name__ in ("bool", "int", "float"):
+            return t.__name__
         else:
-            return str(self.type.__name__)
+            return f"wp::{t.__name__}"
+
+    def ctype(self, value_type=False):
+        return Var.type_to_ctype(self.type, value_type)
 
     def emit(self, prefix: str = "var"):
         if self.prefix:
@@ -417,6 +476,9 @@ class Var:
         else:
             return self.label
 
+    def emit_adj(self):
+        return self.emit("adj")
+
 
 class Block:
     # Represents a basic block of instructions, e.g.: list
@@ -456,20 +518,17 @@ class Adjoint:
         # whether the generation of the adjoint code is skipped for this function
         adj.skip_reverse_codegen = skip_reverse_codegen
 
-        # build AST from function object
-        adj.source = inspect.getsource(func)
-
-        # get source code lines and line number where function starts
-        adj.raw_source, adj.fun_lineno = inspect.getsourcelines(func)
-
-        # keep track of line number in function code
-        adj.lineno = None
+        # extract name of source file
+        adj.filename = inspect.getsourcefile(func) or "unknown source file"
+        # get source file line number where function starts
+        _, adj.fun_lineno = inspect.getsourcelines(func)
 
+        # get function source code
+        adj.source = inspect.getsource(func)
         # ensures that indented class methods can be parsed as kernels
         adj.source = textwrap.dedent(adj.source)
 
-        # extract name of source file
-        adj.filename = inspect.getsourcefile(func) or "unknown source file"
+        adj.source_lines = adj.source.splitlines()
 
         # build AST and apply node transformers
         adj.tree = ast.parse(adj.source)
@@ -479,6 +538,9 @@ class Adjoint:
 
         adj.fun_name = adj.tree.body[0].name
 
+        # for keeping track of line number in function code
+        adj.lineno = None
+
         # whether the forward code shall be used for the reverse pass and a custom
         # function signature is applied to the reverse version of the function
         adj.custom_reverse_mode = custom_reverse_mode
@@ -493,16 +555,17 @@ class Adjoint:
         if overload_annotations is None:
             # use source-level argument annotations
             if len(argspec.annotations) < len(argspec.args):
-                raise RuntimeError(f"Incomplete argument annotations on function {adj.fun_name}")
+                raise WarpCodegenError(f"Incomplete argument annotations on function {adj.fun_name}")
             adj.arg_types = argspec.annotations
         else:
             # use overload argument annotations
             for arg_name in argspec.args:
                 if arg_name not in overload_annotations:
-                    raise RuntimeError(f"Incomplete overload annotations for function {adj.fun_name}")
+                    raise WarpCodegenError(f"Incomplete overload annotations for function {adj.fun_name}")
             adj.arg_types = overload_annotations.copy()
 
         adj.args = []
+        adj.symbols = {}
 
         for name, type in adj.arg_types.items():
             # skip return hint
@@ -513,8 +576,23 @@ class Adjoint:
             arg = Var(name, type, False)
             adj.args.append(arg)
 
+            # pre-populate symbol dictionary with function argument names
+            # this is to avoid registering false references to overshadowed modules
+            adj.symbols[name] = arg
+
+        # There are cases where a same module might be rebuilt multiple times,
+        # for example when kernels are nested inside of functions, or when
+        # a kernel's launch raises an exception. Ideally we'd always want to
+        # avoid rebuilding kernels but some corner cases seem to depend on it,
+        # so we only avoid rebuilding kernels that errored out to give a chance
+        # for unit testing errors being spit out from kernels.
+        adj.skip_build = False
+
     # generate function ssa form and adjoint
     def build(adj, builder):
+        if adj.skip_build:
+            return
+
         adj.builder = builder
 
         adj.symbols = {}  # map from symbols to adjoint variables
@@ -528,7 +606,7 @@ class Adjoint:
         adj.loop_blocks = []
 
         # holds current indent level
-        adj.prefix = ""
+        adj.indentation = ""
 
         # used to generate new label indices
         adj.label_count = 0
@@ -542,12 +620,17 @@ class Adjoint:
             adj.eval(adj.tree.body[0])
         except Exception as e:
             try:
+                if isinstance(e, KeyError) and getattr(e.args[0], "__module__", None) == "ast":
+                    msg = f'Syntax error: unsupported construct "ast.{e.args[0].__name__}"'
+                else:
+                    msg = "Error"
                 lineno = adj.lineno + adj.fun_lineno
-                line = adj.source.splitlines()[adj.lineno]
-                msg = f'Error while parsing function "{adj.fun_name}" at {adj.filename}:{lineno}:\n{line}\n'
+                line = adj.source_lines[adj.lineno]
+                msg += f' while parsing function "{adj.fun_name}" at {adj.filename}:{lineno}:\n{line}\n'
                 ex, data, traceback = sys.exc_info()
-                e = ex("".join([msg] + list(data.args))).with_traceback(traceback)
+                e = ex(";".join([msg] + [str(a) for a in data.args])).with_traceback(traceback)
             finally:
+                adj.skip_build = True
                 raise e
 
         if builder is not None:
@@ -570,16 +653,18 @@ class Adjoint:
         arg_strs = []
 
         for a in args:
-            if type(a) == warp.context.Function:
+            if isinstance(a, warp.context.Function):
                 # functions don't have a var_ prefix so strip it off here
                 if prefix == "var":
                     arg_strs.append(a.key)
                 else:
                     arg_strs.append(f"{prefix}_{a.key}")
+            elif is_reference(a.type):
+                arg_strs.append(f"{prefix}_{a}")
             elif isinstance(a, Var):
                 arg_strs.append(a.emit(prefix))
             else:
-                arg_strs.append(f"{prefix}_{a}")
+                raise WarpCodegenTypeError(f"Arguments must be variables or functions, got {type(a)}")
 
         return arg_strs
 
@@ -587,30 +672,37 @@ class Adjoint:
     def format_forward_call_args(adj, args, use_initializer_list):
         arg_str = ", ".join(adj.format_args("var", args))
         if use_initializer_list:
-            return "{{{}}}".format(arg_str)
+            return f"{{{arg_str}}}"
         return arg_str
 
     # generates argument string for a reverse function call
     def format_reverse_call_args(
-        adj, args, args_out, non_adjoint_args, non_adjoint_outputs, use_initializer_list, has_output_args=True
+        adj,
+        args_var,
+        args,
+        args_out,
+        use_initializer_list,
+        has_output_args=True,
+        require_original_output_arg=False,
     ):
-        formatted_var = adj.format_args("var", args)
+        formatted_var = adj.format_args("var", args_var)
         formatted_out = []
-        if has_output_args and len(args_out) > 1:
+        if has_output_args and (require_original_output_arg or len(args_out) > 1):
             formatted_out = adj.format_args("var", args_out)
         formatted_var_adj = adj.format_args(
-            "&adj" if use_initializer_list else "adj", [a for i, a in enumerate(args) if i not in non_adjoint_args]
+            "&adj" if use_initializer_list else "adj",
+            args,
         )
-        formatted_out_adj = adj.format_args("adj", [a for i, a in enumerate(args_out) if i not in non_adjoint_outputs])
+        formatted_out_adj = adj.format_args("adj", args_out)
 
         if len(formatted_var_adj) == 0 and len(formatted_out_adj) == 0:
             # there are no adjoint arguments, so we don't need to call the reverse function
             return None
 
         if use_initializer_list:
-            var_str = "{{{}}}".format(", ".join(formatted_var))
-            out_str = "{{{}}}".format(", ".join(formatted_out))
-            adj_str = "{{{}}}".format(", ".join(formatted_var_adj))
+            var_str = f"{{{', '.join(formatted_var)}}}"
+            out_str = f"{{{', '.join(formatted_out)}}}"
+            adj_str = f"{{{', '.join(formatted_var_adj)}}}"
             out_adj_str = ", ".join(formatted_out_adj)
             if len(args_out) > 1:
                 arg_str = ", ".join([var_str, out_str, adj_str, out_adj_str])
@@ -621,10 +713,10 @@ class Adjoint:
         return arg_str
 
     def indent(adj):
-        adj.prefix = adj.prefix + "    "
+        adj.indentation = adj.indentation + "    "
 
     def dedent(adj):
-        adj.prefix = adj.prefix[:-4]
+        adj.indentation = adj.indentation[:-4]
 
     def begin_block(adj):
         b = Block()
@@ -639,10 +731,9 @@ class Adjoint:
     def end_block(adj):
         return adj.blocks.pop()
 
-    def add_var(adj, type=None, constant=None, name=None):
-        if name is None:
-            index = len(adj.variables)
-            name = str(index)
+    def add_var(adj, type=None, constant=None):
+        index = len(adj.variables)
+        name = str(index)
 
         # allocate new variable
         v = Var(name, type=type, constant=constant)
@@ -655,30 +746,54 @@ class Adjoint:
 
     # append a statement to the forward pass
     def add_forward(adj, statement, replay=None, skip_replay=False):
-        adj.blocks[-1].body_forward.append(adj.prefix + statement)
+        adj.blocks[-1].body_forward.append(adj.indentation + statement)
 
         if not skip_replay:
             if replay:
                 # if custom replay specified then output it
-                adj.blocks[-1].body_replay.append(adj.prefix + replay)
+                adj.blocks[-1].body_replay.append(adj.indentation + replay)
             else:
                 # by default just replay the original statement
-                adj.blocks[-1].body_replay.append(adj.prefix + statement)
+                adj.blocks[-1].body_replay.append(adj.indentation + statement)
 
     # append a statement to the reverse pass
     def add_reverse(adj, statement):
-        adj.blocks[-1].body_reverse.append(adj.prefix + statement)
+        adj.blocks[-1].body_reverse.append(adj.indentation + statement)
 
     def add_constant(adj, n):
         output = adj.add_var(type=type(n), constant=n)
         return output
 
+    def load(adj, var):
+        if is_reference(var.type):
+            var = adj.add_builtin_call("load", [var])
+        return var
+
     def add_comp(adj, op_strings, left, comps):
         output = adj.add_var(builtins.bool)
 
-        s = "var_" + str(output) + " = " + ("(" * len(comps)) + "var_" + str(left) + " "
+        left = adj.load(left)
+        s = output.emit() + " = " + ("(" * len(comps)) + left.emit() + " "
+
+        prev_comp = None
+
         for op, comp in zip(op_strings, comps):
-            s += op + " var_" + str(comp) + ") "
+            comp_chainable = op_str_is_chainable(op)
+            if comp_chainable and prev_comp:
+                # We  restrict chaining to operands of the same type
+                if prev_comp.type is comp.type:
+                    prev_comp = adj.load(prev_comp)
+                    comp = adj.load(comp)
+                    s += "&& (" + prev_comp.emit() + " " + op + " " + comp.emit() + ")) "
+                else:
+                    raise WarpCodegenTypeError(
+                        f"Cannot chain comparisons of unequal types: {prev_comp.type} {op} {comp.type}."
+                    )
+            else:
+                comp = adj.load(comp)
+                s += op + " " + comp.emit() + ") "
+
+            prev_comp = comp
 
         s = s.rstrip() + ";"
 
@@ -687,110 +802,106 @@ class Adjoint:
         return output
 
     def add_bool_op(adj, op_string, exprs):
+        exprs = [adj.load(expr) for expr in exprs]
         output = adj.add_var(builtins.bool)
-        command = (
-            "var_" + str(output) + " = " + (" " + op_string + " ").join(["var_" + str(expr) for expr in exprs]) + ";"
-        )
+        command = output.emit() + " = " + (" " + op_string + " ").join([expr.emit() for expr in exprs]) + ";"
         adj.add_forward(command)
 
         return output
 
-    def add_call(adj, func, args, min_outputs=None, templates=[], kwds=None):
-        # if func is overloaded then perform overload resolution here
-        # we validate argument types before they go to generated native code
-        resolved_func = None
+    def resolve_func(adj, func, args, min_outputs, templates, kwds):
+        arg_types = [strip_reference(a.type) for a in args if not isinstance(a, warp.context.Function)]
 
-        if func.is_builtin():
+        if not func.is_builtin():
+            # user-defined function
+            overload = func.get_overload(arg_types)
+            if overload is not None:
+                return overload
+        else:
+            # if func is overloaded then perform overload resolution here
+            # we validate argument types before they go to generated native code
             for f in func.overloads:
-                match = True
-
                 # skip type checking for variadic functions
                 if not f.variadic:
                     # check argument counts match are compatible (may be some default args)
                     if len(f.input_types) < len(args):
-                        match = False
                         continue
 
-                    # check argument types equal
-                    for i, (arg_name, arg_type) in enumerate(f.input_types.items()):
-                        # if arg type registered as Any, treat as
-                        # template allowing any type to match
-                        if arg_type == Any:
-                            continue
-
-                        # handle function refs as a special case
-                        if arg_type == Callable and type(args[i]) is warp.context.Function:
-                            continue
-
-                        # look for default values for missing args
-                        if i >= len(args):
-                            if arg_name not in f.defaults:
-                                match = False
-                                break
-                        else:
-                            # otherwise check arg type matches input variable type
-                            if not types_equal(arg_type, args[i].type, match_generic=True):
-                                match = False
-                                break
+                    def match_args(args, f):
+                        # check argument types equal
+                        for i, (arg_name, arg_type) in enumerate(f.input_types.items()):
+                            # if arg type registered as Any, treat as
+                            # template allowing any type to match
+                            if arg_type == Any:
+                                continue
+
+                            # handle function refs as a special case
+                            if arg_type == Callable and type(args[i]) is warp.context.Function:
+                                continue
+
+                            if arg_type == Reference and is_reference(args[i].type):
+                                continue
+
+                            # look for default values for missing args
+                            if i >= len(args):
+                                if arg_name not in f.defaults:
+                                    return False
+                            else:
+                                # otherwise check arg type matches input variable type
+                                if not types_equal(arg_type, strip_reference(args[i].type), match_generic=True):
+                                    return False
+
+                        return True
+
+                    if not match_args(args, f):
+                        continue
 
                 # check output dimensions match expectations
                 if min_outputs:
                     try:
                         value_type = f.value_func(args, kwds, templates)
-                        if len(value_type) != min_outputs:
-                            match = False
+                        if not hasattr(value_type, "__len__") or len(value_type) != min_outputs:
                             continue
                     except Exception:
                         # value func may fail if the user has given
                         # incorrect args, so we need to catch this
-                        match = False
                         continue
 
                 # found a match, use it
-                if match:
-                    resolved_func = f
-                    break
-        else:
-            # user-defined function
-            arg_types = [a.type for a in args]
-
-            resolved_func = func.get_overload(arg_types)
-
-        if resolved_func is None:
-            arg_types = []
-
-            for x in args:
-                if isinstance(x, Var):
-                    # shorten Warp primitive type names
-                    if isinstance(x.type, list):
-                        if len(x.type) != 1:
-                            raise Exception("Argument must not be the result from a multi-valued function")
-                        arg_type = x.type[0]
-                    else:
-                        arg_type = x.type
-                    if arg_type.__module__ == "warp.types":
-                        arg_types.append(arg_type.__name__)
-                    else:
-                        arg_types.append(arg_type.__module__ + "." + arg_type.__name__)
-
-                if isinstance(x, warp.context.Function):
-                    arg_types.append("function")
-
-            raise Exception(
-                f"Couldn't find function overload for '{func.key}' that matched inputs with types: [{', '.join(arg_types)}]"
-            )
+                return f
+
+        # unresolved function, report error
+        arg_types = []
+
+        for x in args:
+            if isinstance(x, Var):
+                # shorten Warp primitive type names
+                if isinstance(x.type, list):
+                    if len(x.type) != 1:
+                        raise WarpCodegenError("Argument must not be the result from a multi-valued function")
+                    arg_type = x.type[0]
+                else:
+                    arg_type = x.type
 
-        else:
-            func = resolved_func
+                arg_types.append(type_repr(arg_type))
+
+            if isinstance(x, warp.context.Function):
+                arg_types.append("function")
+
+        raise WarpCodegenError(
+            f"Couldn't find function overload for '{func.key}' that matched inputs with types: [{', '.join(arg_types)}]"
+        )
+
+    def add_call(adj, func, args, min_outputs=None, templates=[], kwds=None):
+        func = adj.resolve_func(func, args, min_outputs, templates, kwds)
 
         # push any default values onto args
         for i, (arg_name, arg_type) in enumerate(func.input_types.items()):
             if i >= len(args):
-                if arg_name in f.defaults:
+                if arg_name in func.defaults:
                     const = adj.add_constant(func.defaults[arg_name])
                     args.append(const)
                 else:
-                    match = False
                     break
 
         # if it is a user-function then build it recursively
@@ -798,105 +909,105 @@ class Adjoint:
             adj.builder.build_function(func)
 
         # evaluate the function type based on inputs
-        value_type = func.value_func(args, kwds, templates)
+        arg_types = [strip_reference(a.type) for a in args if not isinstance(a, warp.context.Function)]
+        return_type = func.value_func(arg_types, kwds, templates)
 
         func_name = compute_type_str(func.native_func, templates)
+        param_types = list(func.input_types.values())
 
         use_initializer_list = func.initializer_list_func(args, templates)
 
-        if value_type is None:
+        args_var = [
+            adj.load(a)
+            if not ((param_types[i] == Reference or param_types[i] == Callable) if i < len(param_types) else False)
+            else a
+            for i, a in enumerate(args)
+        ]
+
+        if return_type is None:
             # handles expression (zero output) functions, e.g.: void do_something();
 
-            forward_call = "{}{}({});".format(
-                func.namespace, func_name, adj.format_forward_call_args(args, use_initializer_list)
+            output = None
+            output_list = []
+
+            forward_call = (
+                f"{func.namespace}{func_name}({adj.format_forward_call_args(args_var, use_initializer_list)});"
             )
             replay_call = forward_call
             if func.custom_replay_func is not None:
-                replay_call = "{}replay_{}({});".format(
-                    func.namespace, func_name, adj.format_forward_call_args(args, use_initializer_list)
-                )
-            if func.skip_replay:
-                adj.add_forward(forward_call, replay="// " + replay_call)
-            else:
-                adj.add_forward(forward_call, replay=replay_call)
-
-            if not func.missing_grad and len(args):
-                arg_str = adj.format_reverse_call_args(args, [], {}, {}, use_initializer_list)
-                if arg_str is not None:
-                    reverse_call = "{}adj_{}({});".format(func.namespace, func.native_func, arg_str)
-                    adj.add_reverse(reverse_call)
-
-            return None
+                replay_call = f"{func.namespace}replay_{func_name}({adj.format_forward_call_args(args_var, use_initializer_list)});"
 
-        elif not isinstance(value_type, list) or len(value_type) == 1:
+        elif not isinstance(return_type, list) or len(return_type) == 1:
             # handle simple function (one output)
 
-            if isinstance(value_type, list):
-                value_type = value_type[0]
-            output = adj.add_var(value_type)
-            forward_call = "var_{} = {}{}({});".format(
-                output, func.namespace, func_name, adj.format_forward_call_args(args, use_initializer_list)
-            )
+            if isinstance(return_type, list):
+                return_type = return_type[0]
+            output = adj.add_var(return_type)
+            output_list = [output]
+
+            forward_call = f"var_{output} = {func.namespace}{func_name}({adj.format_forward_call_args(args_var, use_initializer_list)});"
             replay_call = forward_call
             if func.custom_replay_func is not None:
-                replay_call = "var_{} = {}replay_{}({});".format(
-                    output, func.namespace, func_name, adj.format_forward_call_args(args, use_initializer_list)
-                )
-
-            if func.skip_replay:
-                adj.add_forward(forward_call, replay="// " + replay_call)
-            else:
-                adj.add_forward(forward_call, replay=replay_call)
-
-            if not func.missing_grad and len(args):
-                arg_str = adj.format_reverse_call_args(args, [output], {}, {}, use_initializer_list)
-                if arg_str is not None:
-                    reverse_call = "{}adj_{}({});".format(func.namespace, func.native_func, arg_str)
-                    adj.add_reverse(reverse_call)
-
-            return output
+                replay_call = f"var_{output} = {func.namespace}replay_{func_name}({adj.format_forward_call_args(args_var, use_initializer_list)});"
 
         else:
             # handle multiple value functions
 
-            output = [adj.add_var(v) for v in value_type]
-            forward_call = "{}{}({});".format(
-                func.namespace, func_name, adj.format_forward_call_args(args + output, use_initializer_list)
+            output = [adj.add_var(v) for v in return_type]
+            output_list = output
+
+            forward_call = (
+                f"{func.namespace}{func_name}({adj.format_forward_call_args(args_var + output, use_initializer_list)});"
             )
-            adj.add_forward(forward_call)
+            replay_call = forward_call
 
-            if not func.missing_grad and len(args):
-                arg_str = adj.format_reverse_call_args(
-                    args, output, {}, {}, use_initializer_list, has_output_args=func.custom_grad_func is None
-                )
-                if arg_str is not None:
-                    reverse_call = "{}adj_{}({});".format(func.namespace, func.native_func, arg_str)
-                    adj.add_reverse(reverse_call)
+        if func.skip_replay:
+            adj.add_forward(forward_call, replay="// " + replay_call)
+        else:
+            adj.add_forward(forward_call, replay=replay_call)
+
+        if not func.missing_grad and len(args):
+            reverse_has_output_args = (
+                func.require_original_output_arg or len(output_list) > 1
+            ) and func.custom_grad_func is None
+            arg_str = adj.format_reverse_call_args(
+                args_var,
+                args,
+                output_list,
+                use_initializer_list,
+                has_output_args=reverse_has_output_args,
+                require_original_output_arg=func.require_original_output_arg,
+            )
+            if arg_str is not None:
+                reverse_call = f"{func.namespace}adj_{func.native_func}({arg_str});"
+                adj.add_reverse(reverse_call)
 
-            if len(output) == 1:
-                return output[0]
+        return output
 
-            return output
+    def add_builtin_call(adj, func_name, args, min_outputs=None, templates=[], kwds=None):
+        func = warp.context.builtin_functions[func_name]
+        return adj.add_call(func, args, min_outputs, templates, kwds)
 
     def add_return(adj, var):
         if var is None or len(var) == 0:
-            adj.add_forward("return;", "goto label{};".format(adj.label_count))
+            adj.add_forward("return;", f"goto label{adj.label_count};")
         elif len(var) == 1:
-            adj.add_forward("return var_{};".format(var[0]), "goto label{};".format(adj.label_count))
+            adj.add_forward(f"return {var[0].emit()};", f"goto label{adj.label_count};")
             adj.add_reverse("adj_" + str(var[0]) + " += adj_ret;")
         else:
             for i, v in enumerate(var):
-                adj.add_forward("ret_{} = var_{};".format(i, v))
-                adj.add_reverse("adj_{} += adj_ret_{};".format(v, i))
-            adj.add_forward("return;", "goto label{};".format(adj.label_count))
+                adj.add_forward(f"ret_{i} = {v.emit()};")
+                adj.add_reverse(f"adj_{v} += adj_ret_{i};")
+            adj.add_forward("return;", f"goto label{adj.label_count};")
 
-        adj.add_reverse("label{}:;".format(adj.label_count))
+        adj.add_reverse(f"label{adj.label_count}:;")
 
         adj.label_count += 1
 
     # define an if statement
     def begin_if(adj, cond):
-        adj.add_forward("if (var_{}) {{".format(cond))
+        cond = adj.load(cond)
+        adj.add_forward(f"if ({cond.emit()}) {{")
         adj.add_reverse("}")
 
         adj.indent()
@@ -905,10 +1016,12 @@ class Adjoint:
         adj.dedent()
 
         adj.add_forward("}")
-        adj.add_reverse(f"if (var_{cond}) {{")
+        cond = adj.load(cond)
+        adj.add_reverse(f"if ({cond.emit()}) {{")
 
     def begin_else(adj, cond):
-        adj.add_forward(f"if (!var_{cond}) {{")
+        cond = adj.load(cond)
+        adj.add_forward(f"if (!{cond.emit()}) {{")
         adj.add_reverse("}")
 
         adj.indent()
@@ -917,7 +1030,8 @@ class Adjoint:
         adj.dedent()
 
         adj.add_forward("}")
-        adj.add_reverse(f"if (!var_{cond}) {{")
+        cond = adj.load(cond)
+        adj.add_reverse(f"if (!{cond.emit()}) {{")
 
     # define a for-loop
     def begin_for(adj, iter):
@@ -927,10 +1041,10 @@ class Adjoint:
         adj.indent()
 
         # evaluate cond
-        adj.add_forward(f"if (iter_cmp(var_{iter}) == 0) goto for_end_{cond_block.label};")
+        adj.add_forward(f"if (iter_cmp({iter.emit()}) == 0) goto for_end_{cond_block.label};")
 
         # evaluate iter
-        val = adj.add_call(warp.context.builtin_functions["iter_next"], [iter])
+        val = adj.add_builtin_call("iter_next", [iter])
 
         adj.begin_block()
 
@@ -961,17 +1075,14 @@ class Adjoint:
         reverse = []
 
         # reverse iterator
-        reverse.append(adj.prefix + f"var_{iter} = wp::iter_reverse(var_{iter});")
+        reverse.append(adj.indentation + f"{iter.emit()} = wp::iter_reverse({iter.emit()});")
 
         for i in cond_block.body_forward:
             reverse.append(i)
 
         # zero adjoints
         for i in body_block.vars:
-            if isinstance(i.type, Struct):
-                reverse.append(adj.prefix + f"\tadj_{i} = {i.ctype()}{{}};")
-            else:
-                reverse.append(adj.prefix + f"\tadj_{i} = {i.ctype()}(0);")
+            reverse.append(adj.indentation + f"\t{i.emit_adj()} = {{}};")
 
         # replay
         for i in body_block.body_replay:
@@ -981,14 +1092,14 @@ class Adjoint:
         for i in reversed(body_block.body_reverse):
             reverse.append(i)
 
-        reverse.append(adj.prefix + f"\tgoto for_start_{cond_block.label};")
-        reverse.append(adj.prefix + f"for_end_{cond_block.label}:;")
+        reverse.append(adj.indentation + f"\tgoto for_start_{cond_block.label};")
+        reverse.append(adj.indentation + f"for_end_{cond_block.label}:;")
 
         adj.blocks[-1].body_reverse.extend(reversed(reverse))
 
     # define a while loop
     def begin_while(adj, cond):
-        # evaulate condition in its own block
+        # evaluate condition in its own block
         # so we can control replay
         cond_block = adj.begin_block()
         adj.loop_blocks.append(cond_block)
@@ -996,7 +1107,7 @@ class Adjoint:
 
         c = adj.eval(cond)
 
-        cond_block.body_forward.append(f"if ((var_{c}) == false) goto while_end_{cond_block.label};")
+        cond_block.body_forward.append(f"if (({c.emit()}) == false) goto while_end_{cond_block.label};")
 
         # being block around loop
         adj.begin_block()
@@ -1030,10 +1141,7 @@ class Adjoint:
 
         # zero adjoints of local vars
         for i in body_block.vars:
-            if isinstance(i.type, Struct):
-                reverse.append(f"adj_{i} = {i.ctype()}{{}};")
-            else:
-                reverse.append(f"adj_{i} = {i.ctype()}(0);")
+            reverse.append(f"{i.emit_adj()} = {{}};")
 
         # replay
         for i in body_block.body_replay:
@@ -1053,6 +1161,10 @@ class Adjoint:
         for f in node.body:
             adj.eval(f)
 
+        if adj.return_var is not None and len(adj.return_var) == 1:
+            if not isinstance(node.body[-1], ast.Return):
+                adj.add_forward("return {};", skip_replay=True)
+
     def emit_If(adj, node):
         if len(node.body) == 0:
             return None
@@ -1080,7 +1192,7 @@ class Adjoint:
 
             if var1 != var2:
                 # insert a phi function that selects var1, var2 based on cond
-                out = adj.add_call(warp.context.builtin_functions["select"], [cond, var1, var2])
+                out = adj.add_builtin_call("select", [cond, var1, var2])
                 adj.symbols[sym] = out
 
         symbols_prev = adj.symbols.copy()
@@ -1104,7 +1216,7 @@ class Adjoint:
             if var1 != var2:
                 # insert a phi function that selects var1, var2 based on cond
                 # note the reversed order of vars since we want to use !cond as our select
-                out = adj.add_call(warp.context.builtin_functions["select"], [cond, var2, var1])
+                out = adj.add_builtin_call("select", [cond, var2, var1])
                 adj.symbols[sym] = out
 
     def emit_Compare(adj, node):
@@ -1126,7 +1238,7 @@ class Adjoint:
         elif isinstance(op, ast.Or):
             func = "||"
         else:
-            raise KeyError("Op {} is not supported".format(op))
+            raise WarpCodegenKeyError(f"Op {op} is not supported")
 
         return adj.add_bool_op(func, [adj.eval(expr) for expr in node.values])
 
@@ -1146,7 +1258,7 @@ class Adjoint:
             obj = capturedvars.get(str(node.id), None)
 
         if obj is None:
-            raise KeyError("Referencing undefined symbol: " + str(node.id))
+            raise WarpCodegenKeyError("Referencing undefined symbol: " + str(node.id))
 
         if warp.types.is_value(obj):
             # evaluate constant
@@ -1158,26 +1270,96 @@ class Adjoint:
         # pass it back to the caller for processing
         return obj
 
+    @staticmethod
+    def resolve_type_attribute(var_type: type, attr: str):
+        if isinstance(var_type, type) and type_is_value(var_type):
+            if attr == "dtype":
+                return type_scalar_type(var_type)
+            elif attr == "length":
+                return type_length(var_type)
+
+        return getattr(var_type, attr, None)
+
+    def vector_component_index(adj, component, vector_type):
+        if len(component) != 1:
+            raise WarpCodegenAttributeError(f"Vector swizzle must be single character, got .{component}")
+
+        dim = vector_type._shape_[0]
+        swizzles = "xyzw"[0:dim]
+        if component not in swizzles:
+            raise WarpCodegenAttributeError(
+                f"Vector swizzle for {vector_type} must be one of {swizzles}, got {component}"
+            )
+
+        index = swizzles.index(component)
+        index = adj.add_constant(index)
+        return index
+
+    @staticmethod
+    def is_differentiable_value_type(var_type):
+        # checks that the argument type is a value type (i.e, not an array)
+        # possibly holding differentiable values (for which gradients must be accumulated)
+        return type_scalar_type(var_type) in float_types or isinstance(var_type, Struct)
+
     def emit_Attribute(adj, node):
-        try:
-            val = adj.eval(node.value)
+        if hasattr(node, "is_adjoint"):
+            node.value.is_adjoint = True
+
+        aggregate = adj.eval(node.value)
 
-            if isinstance(val, types.ModuleType) or isinstance(val, type):
-                out = getattr(val, node.attr)
+        try:
+            if isinstance(aggregate, types.ModuleType) or isinstance(aggregate, type):
+                out = getattr(aggregate, node.attr)
 
                 if warp.types.is_value(out):
                     return adj.add_constant(out)
 
                 return out
 
-            # create a Var that points to the struct attribute, i.e.: directly generates `struct.attr` when used
-            attr_name = val.label + "." + node.attr
-            attr_type = val.type.vars[node.attr].type
+            if hasattr(node, "is_adjoint"):
+                # create a Var that points to the struct attribute, i.e.: directly generates `struct.attr` when used
+                attr_name = aggregate.label + "." + node.attr
+                attr_type = aggregate.type.vars[node.attr].type
+
+                return Var(attr_name, attr_type)
+
+            aggregate_type = strip_reference(aggregate.type)
 
-            return Var(attr_name, attr_type)
+            # reading a vector component
+            if type_is_vector(aggregate_type):
+                index = adj.vector_component_index(node.attr, aggregate_type)
 
-        except KeyError:
-            raise RuntimeError(f"Error, `{node.attr}` is not an attribute of '{val.label}' ({val.type})")
+                return adj.add_builtin_call("extract", [aggregate, index])
+
+            else:
+                attr_type = Reference(aggregate_type.vars[node.attr].type)
+                attr = adj.add_var(attr_type)
+
+                if is_reference(aggregate.type):
+                    adj.add_forward(f"{attr.emit()} = &({aggregate.emit()}->{node.attr});")
+                else:
+                    adj.add_forward(f"{attr.emit()} = &({aggregate.emit()}.{node.attr});")
+
+                if adj.is_differentiable_value_type(strip_reference(attr_type)):
+                    adj.add_reverse(f"{aggregate.emit_adj()}.{node.attr} += {attr.emit_adj()};")
+                else:
+                    adj.add_reverse(f"{aggregate.emit_adj()}.{node.attr} = {attr.emit_adj()};")
+
+                return attr
+
+        except (KeyError, AttributeError):
+            # Try resolving as type attribute
+            aggregate_type = strip_reference(aggregate.type) if isinstance(aggregate, Var) else aggregate
+
+            type_attribute = adj.resolve_type_attribute(aggregate_type, node.attr)
+            if type_attribute is not None:
+                return type_attribute
+
+            if isinstance(aggregate, Var):
+                raise WarpCodegenAttributeError(
+                    f"Error, `{node.attr}` is not an attribute of '{node.value.id}' ({type_repr(aggregate.type)})"
+                )
+            raise WarpCodegenAttributeError(f"Error, `{node.attr}` is not an attribute of '{aggregate}'")
 
     def emit_String(adj, node):
         # string constant
@@ -1194,19 +1376,25 @@ class Adjoint:
             adj.symbols[key] = out
             return out
 
+    def emit_Ellipsis(adj, node):
+        # stubbed @wp.native_func
+        return
+
     def emit_NameConstant(adj, node):
-        if node.value is True:
+        if node.value:
             return adj.add_constant(True)
-        elif node.value is False:
-            return adj.add_constant(False)
         elif node.value is None:
-            raise TypeError("None type unsupported")
+            raise WarpCodegenTypeError("None type unsupported")
+        else:
+            return adj.add_constant(False)
 
     def emit_Constant(adj, node):
         if isinstance(node, ast.Str):
             return adj.emit_String(node)
         elif isinstance(node, ast.Num):
             return adj.emit_Num(node)
+        elif isinstance(node, ast.Ellipsis):
+            return adj.emit_Ellipsis(node)
         else:
             assert isinstance(node, ast.NameConstant)
             return adj.emit_NameConstant(node)
@@ -1217,18 +1405,16 @@ class Adjoint:
         right = adj.eval(node.right)
 
         name = builtin_operators[type(node.op)]
-        func = warp.context.builtin_functions[name]
 
-        return adj.add_call(func, [left, right])
+        return adj.add_builtin_call(name, [left, right])
 
     def emit_UnaryOp(adj, node):
         # evaluate unary op arguments
         arg = adj.eval(node.operand)
 
         name = builtin_operators[type(node.op)]
-        func = warp.context.builtin_functions[name]
 
-        return adj.add_call(func, [arg])
+        return adj.add_builtin_call(name, [arg])
 
     def materialize_redefinitions(adj, symbols):
         # detect symbols with conflicting definitions (assigned inside the for loop)
@@ -1240,19 +1426,17 @@ class Adjoint:
             if var1 != var2:
                 if warp.config.verbose and not adj.custom_reverse_mode:
                     lineno = adj.lineno + adj.fun_lineno
-                    line = adj.source.splitlines()[adj.lineno]
-                    msg = f'Warning: detected mutated variable {sym} during a dynamic for-loop in function "{adj.fun_name}" at {adj.filename}:{lineno}: this is a non-differentiable operation.\n{line}\n'
+                    line = adj.source_lines[adj.lineno]
+                    msg = f'Warning: detected mutated variable {sym} during a dynamic for-loop in function "{adj.fun_name}" at {adj.filename}:{lineno}: this may not be a differentiable operation.\n{line}\n'
                     print(msg)
 
                 if var1.constant is not None:
-                    raise Exception(
-                        "Error mutating a constant {} inside a dynamic loop, use the following syntax: pi = float(3.141) to declare a dynamic variable".format(
-                            sym
-                        )
+                    raise WarpCodegenError(
+                        f"Error mutating a constant {sym} inside a dynamic loop, use the following syntax: pi = float(3.141) to declare a dynamic variable"
                     )
 
                 # overwrite the old variable value (violates SSA)
-                adj.add_call(warp.context.builtin_functions["copy"], [var1, var2])
+                adj.add_builtin_call("assign", [var1, var2])
 
                 # reset the symbol to point to the original variable
                 adj.symbols[sym] = var1
@@ -1271,35 +1455,20 @@ class Adjoint:
 
         adj.end_while()
 
-    def is_num(adj, a):
-        # simple constant
-        if isinstance(a, ast.Num):
-            return True
-        # expression of form -constant
-        elif isinstance(a, ast.UnaryOp) and isinstance(a.op, ast.USub) and isinstance(a.operand, ast.Num):
-            return True
-        else:
-            # try and resolve the expression to an object
-            # e.g.: wp.constant in the globals scope
-            obj, path = adj.resolve_path(a)
-            if warp.types.is_int(obj):
-                return True
-            else:
-                return False
-
     def eval_num(adj, a):
         if isinstance(a, ast.Num):
-            return a.n
-        elif isinstance(a, ast.UnaryOp) and isinstance(a.op, ast.USub) and isinstance(a.operand, ast.Num):
-            return -a.operand.n
-        else:
-            # try and resolve the expression to an object
-            # e.g.: wp.constant in the globals scope
-            obj, path = adj.resolve_path(a)
-            if warp.types.is_int(obj):
-                return obj
-            else:
-                return False
+            return True, a.n
+        if isinstance(a, ast.UnaryOp) and isinstance(a.op, ast.USub) and isinstance(a.operand, ast.Num):
+            return True, -a.operand.n
+
+        # try and resolve the expression to an object
+        # e.g.: wp.constant in the globals scope
+        obj, _ = adj.resolve_static_expression(a)
+
+        if isinstance(obj, Var) and obj.constant is not None:
+            obj = obj.constant
+
+        return warp.types.is_int(obj), obj
 
     # detects whether a loop contains a break (or continue) statement
     def contains_break(adj, body):
@@ -1322,61 +1491,82 @@ class Adjoint:
 
     # returns a constant range() if unrollable, otherwise None
     def get_unroll_range(adj, loop):
-        if not isinstance(loop.iter, ast.Call) or not isinstance(loop.iter.func, ast.Name) or loop.iter.func.id != "range":
+        if (
+            not isinstance(loop.iter, ast.Call)
+            or not isinstance(loop.iter.func, ast.Name)
+            or loop.iter.func.id != "range"
+            or len(loop.iter.args) == 0
+            or len(loop.iter.args) > 3
+        ):
             return None
 
-        for a in loop.iter.args:
-            # if all range() arguments are numeric constants we will unroll
-            # note that this only handles trivial constants, it will not unroll
-            # constant compile-time expressions e.g.: range(0, 3*2)
-            if not adj.is_num(a):
-                return None
-
-        # range(end)
-        if len(loop.iter.args) == 1:
-            start = 0
-            end = adj.eval_num(loop.iter.args[0])
-            step = 1
-
-        # range(start, end)
-        elif len(loop.iter.args) == 2:
-            start = adj.eval_num(loop.iter.args[0])
-            end = adj.eval_num(loop.iter.args[1])
-            step = 1
-
-        # range(start, end, step)
-        elif len(loop.iter.args) == 3:
-            start = adj.eval_num(loop.iter.args[0])
-            end = adj.eval_num(loop.iter.args[1])
-            step = adj.eval_num(loop.iter.args[2])
-
-        # test if we're above max unroll count
-        max_iters = abs(end - start) // abs(step)
-        max_unroll = adj.builder.options["max_unroll"]
-
-        if max_iters > max_unroll:
-            if warp.config.verbose:
-                print(
-                    f"Warning: fixed-size loop count of {max_iters} is larger than the module 'max_unroll' limit of {max_unroll}, will generate dynamic loop."
-                )
-            return None
+        # if all range() arguments are numeric constants we will unroll
+        # note that this only handles trivial constants, it will not unroll
+        # constant compile-time expressions e.g.: range(0, 3*2)
+
+        # Evaluate the arguments and check that they are numeric constants
+        # It is important to do that in one pass, so that if evaluating these arguments have side effects
+        # the code does not get generated more than once
+        range_args = [adj.eval_num(arg) for arg in loop.iter.args]
+        arg_is_numeric, arg_values = zip(*range_args)
+
+        if all(arg_is_numeric):
+            # All argument are numeric constants
+
+            # range(end)
+            if len(loop.iter.args) == 1:
+                start = 0
+                end = arg_values[0]
+                step = 1
+
+            # range(start, end)
+            elif len(loop.iter.args) == 2:
+                start = arg_values[0]
+                end = arg_values[1]
+                step = 1
+
+            # range(start, end, step)
+            elif len(loop.iter.args) == 3:
+                start = arg_values[0]
+                end = arg_values[1]
+                step = arg_values[2]
+
+            # test if we're above max unroll count
+            max_iters = abs(end - start) // abs(step)
+            max_unroll = adj.builder.options["max_unroll"]
+
+            ok_to_unroll = True
+
+            if max_iters > max_unroll:
+                if warp.config.verbose:
+                    print(
+                        f"Warning: fixed-size loop count of {max_iters} is larger than the module 'max_unroll' limit of {max_unroll}, will generate dynamic loop."
+                    )
+                ok_to_unroll = False
 
-        if adj.contains_break(loop.body):
-            if warp.config.verbose:
-                print("Warning: 'break' or 'continue' found in loop body, will generate dynamic loop.")
-            return None
+            elif adj.contains_break(loop.body):
+                if warp.config.verbose:
+                    print("Warning: 'break' or 'continue' found in loop body, will generate dynamic loop.")
+                ok_to_unroll = False
 
-        # unroll
-        return range(start, end, step)
+            if ok_to_unroll:
+                return range(start, end, step)
+
+        # Unroll is not possible, range needs to be valuated dynamically
+        range_call = adj.add_builtin_call(
+            "range",
+            [adj.add_constant(val) if is_numeric else val for is_numeric, val in range_args],
+        )
+        return range_call
 
     def emit_For(adj, node):
         # try and unroll simple range() statements that use constant args
         unroll_range = adj.get_unroll_range(node)
 
-        if unroll_range:
+        if isinstance(unroll_range, range):
             for i in unroll_range:
                 const_iter = adj.add_constant(i)
-                var_iter = adj.add_call(warp.context.builtin_functions["int"], [const_iter])
+                var_iter = adj.add_builtin_call("int", [const_iter])
                 adj.symbols[node.target.id] = var_iter
 
                 # eval body
@@ -1385,8 +1575,12 @@ class Adjoint:
 
         # otherwise generate a dynamic loop
         else:
-            # evaluate the Iterable
-            iter = adj.eval(node.iter)
+            # evaluate the Iterable -- only if not previously evaluated when trying to unroll
+            if unroll_range is not None:
+                # Range has already been evaluated when trying to unroll, do not re-evaluate
+                iter = unroll_range
+            else:
+                iter = adj.eval(node.iter)
 
             adj.symbols[node.target.id] = adj.begin_for(iter)
 
@@ -1415,15 +1609,28 @@ class Adjoint:
     def emit_Expr(adj, node):
         return adj.eval(node.value)
 
+    def check_tid_in_func_error(adj, node):
+        if adj.is_user_function:
+            if hasattr(node.func, "attr") and node.func.attr == "tid":
+                lineno = adj.lineno + adj.fun_lineno
+                line = adj.source_lines[adj.lineno]
+                raise WarpCodegenError(
+                    "tid() may only be called from a Warp kernel, not a Warp function. "
+                    "Instead, obtain the indices from a @wp.kernel and pass them as "
+                    f"arguments to the function {adj.fun_name}, {adj.filename}:{lineno}:\n{line}\n"
+                )
+
     def emit_Call(adj, node):
+        adj.check_tid_in_func_error(node)
+
         # try and lookup function in globals by
         # resolving path (e.g.: module.submodule.attr)
-        func, path = adj.resolve_path(node.func)
+        func, path = adj.resolve_static_expression(node.func)
         templates = []
 
-        if isinstance(func, warp.context.Function) is False:
+        if not isinstance(func, warp.context.Function):
             if len(path) == 0:
-                raise RuntimeError(f"Unrecognized syntax for function call, path not valid: '{node.func}'")
+                raise WarpCodegenError(f"Unknown function or operator: '{node.func.func.id}'")
 
             attr = path[-1]
             caller = func
@@ -1448,7 +1655,7 @@ class Adjoint:
                 func = caller.initializer()
 
             if func is None:
-                raise RuntimeError(
+                raise WarpCodegenError(
                     f"Could not find function {'.'.join(path)} as a built-in or user-defined function. Note that user functions must be annotated with a @wp.func decorator to be called from a kernel."
                 )
 
@@ -1464,9 +1671,14 @@ class Adjoint:
             if isinstance(kw.value, ast.Num):
                 return kw.value.n
             elif isinstance(kw.value, ast.Tuple):
-                return tuple(adj.eval_num(e) for e in kw.value.elts)
+                arg_is_numeric, arg_values = zip(*(adj.eval_num(e) for e in kw.value.elts))
+                if not all(arg_is_numeric):
+                    raise WarpCodegenError(
+                        f"All elements of the tuple keyword argument '{kw.name}' must be numeric constants, got '{arg_values}'"
+                    )
+                return arg_values
             else:
-                return adj.resolve_path(kw.value)[0]
+                return adj.resolve_static_expression(kw.value)[0]
 
         kwds = {kw.arg: kwval(kw) for kw in node.keywords}
 
@@ -1483,15 +1695,19 @@ class Adjoint:
         # the ast.Index node appears in 3.7 versions
         # when performing array slices, e.g.: x = arr[i]
         # but in version 3.8 and higher it does not appear
+
+        if hasattr(node, "is_adjoint"):
+            node.value.is_adjoint = True
+
         return adj.eval(node.value)
 
     def emit_Subscript(adj, node):
         if hasattr(node.value, "attr") and node.value.attr == "adjoint":
             # handle adjoint of a variable, i.e. wp.adjoint[var]
+            node.slice.is_adjoint = True
             var = adj.eval(node.slice)
             var_name = var.label
-            var = Var(f"adj_{var_name}", type=var.type, constant=None, prefix=False, is_adjoint=True)
-            adj.symbols[var.label] = var
+            var = Var(f"adj_{var_name}", type=var.type, constant=None, prefix=False)
             return var
 
         target = adj.eval(node.value)
@@ -1514,29 +1730,34 @@ class Adjoint:
             var = adj.eval(node.slice)
             indices.append(var)
 
-        if is_array(target.type):
-            if len(indices) == target.type.ndim:
+        target_type = strip_reference(target.type)
+        if is_array(target_type):
+            if len(indices) == target_type.ndim:
                 # handles array loads (where each dimension has an index specified)
-                out = adj.add_call(warp.context.builtin_functions["load"], [target, *indices])
+                out = adj.add_builtin_call("address", [target, *indices])
             else:
                 # handles array views (fewer indices than dimensions)
-                out = adj.add_call(warp.context.builtin_functions["view"], [target, *indices])
+                out = adj.add_builtin_call("view", [target, *indices])
 
         else:
             # handles non-array type indexing, e.g: vec3, mat33, etc
-            out = adj.add_call(warp.context.builtin_functions["index"], [target, *indices])
+            out = adj.add_builtin_call("extract", [target, *indices])
 
-        out.is_adjoint = target.is_adjoint
         return out
 
     def emit_Assign(adj, node):
+        if len(node.targets) != 1:
+            raise WarpCodegenError("Assigning the same value to multiple variables is not supported")
+
+        lhs = node.targets[0]
+
         # handle the case where we are assigning multiple output variables
-        if isinstance(node.targets[0], ast.Tuple):
+        if isinstance(lhs, ast.Tuple):
             # record the expected number of outputs on the node
             # we do this so we can decide which function to
             # call based on the number of expected outputs
             if isinstance(node.value, ast.Call):
-                node.value.expects = len(node.targets[0].elts)
+                node.value.expects = len(lhs.elts)
 
             # evaluate values
             if isinstance(node.value, ast.Tuple):
@@ -1545,49 +1766,43 @@ class Adjoint:
                 out = adj.eval(node.value)
 
             names = []
-            for v in node.targets[0].elts:
+            for v in lhs.elts:
                 if isinstance(v, ast.Name):
                     names.append(v.id)
                 else:
-                    raise RuntimeError(
+                    raise WarpCodegenError(
                         "Multiple return functions can only assign to simple variables, e.g.: x, y = func()"
                     )
 
             if len(names) != len(out):
-                raise RuntimeError(
-                    "Multiple return functions need to receive all their output values, incorrect number of values to unpack (expected {}, got {})".format(
-                        len(out), len(names)
-                    )
+                raise WarpCodegenError(
+                    f"Multiple return functions need to receive all their output values, incorrect number of values to unpack (expected {len(out)}, got {len(names)})"
                 )
 
             for name, rhs in zip(names, out):
                 if name in adj.symbols:
                     if not types_equal(rhs.type, adj.symbols[name].type):
-                        raise TypeError(
-                            "Error, assigning to existing symbol {} ({}) with different type ({})".format(
-                                name, adj.symbols[name].type, rhs.type
-                            )
+                        raise WarpCodegenTypeError(
+                            f"Error, assigning to existing symbol {name} ({adj.symbols[name].type}) with different type ({rhs.type})"
                         )
 
                 adj.symbols[name] = rhs
 
-            return out
-
         # handles the case where we are assigning to an array index (e.g.: arr[i] = 2.0)
-        elif isinstance(node.targets[0], ast.Subscript):
-            if hasattr(node.targets[0].value, "attr") and node.targets[0].value.attr == "adjoint":
+        elif isinstance(lhs, ast.Subscript):
+            if hasattr(lhs.value, "attr") and lhs.value.attr == "adjoint":
                 # handle adjoint of a variable, i.e. wp.adjoint[var]
-                src_var = adj.eval(node.targets[0].slice)
+                lhs.slice.is_adjoint = True
+                src_var = adj.eval(lhs.slice)
                 var = Var(f"adj_{src_var.label}", type=src_var.type, constant=None, prefix=False)
-                adj.symbols[var.label] = var
                 value = adj.eval(node.value)
                 adj.add_forward(f"{var.emit()} = {value.emit()};")
-                return var
+                return
 
-            target = adj.eval(node.targets[0].value)
+            target = adj.eval(lhs.value)
             value = adj.eval(node.value)
 
-            slice = node.targets[0].slice
+            slice = lhs.slice
             indices = []
 
             if isinstance(slice, ast.Tuple):
@@ -1595,7 +1810,6 @@ class Adjoint:
                 for arg in slice.elts:
                     var = adj.eval(arg)
                     indices.append(var)
-
             elif isinstance(slice, ast.Index) and isinstance(slice.value, ast.Tuple):
                 # handles the x[i, j] case (Python 3.7.x)
                 for arg in slice.value.elts:
@@ -1606,65 +1820,84 @@ class Adjoint:
                 var = adj.eval(slice)
                 indices.append(var)
 
-            if is_array(target.type):
-                adj.add_call(warp.context.builtin_functions["store"], [target, *indices, value])
+            target_type = strip_reference(target.type)
 
-            elif type_is_vector(target.type) or type_is_matrix(target.type):
-                adj.add_call(warp.context.builtin_functions["indexset"], [target, *indices, value])
+            if is_array(target_type):
+                adj.add_builtin_call("array_store", [target, *indices, value])
+
+            elif type_is_vector(target_type) or type_is_matrix(target_type):
+                if is_reference(target.type):
+                    attr = adj.add_builtin_call("indexref", [target, *indices])
+                else:
+                    attr = adj.add_builtin_call("index", [target, *indices])
+
+                adj.add_builtin_call("store", [attr, value])
 
                 if warp.config.verbose and not adj.custom_reverse_mode:
                     lineno = adj.lineno + adj.fun_lineno
-                    line = adj.source.splitlines()[adj.lineno]
-                    node_source = adj.get_node_source(node.targets[0].value)
+                    line = adj.source_lines[adj.lineno]
+                    node_source = adj.get_node_source(lhs.value)
                     print(
                         f"Warning: mutating {node_source} in function {adj.fun_name} at {adj.filename}:{lineno}: this is a non-differentiable operation.\n{line}\n"
                     )
 
             else:
-                raise RuntimeError("Can only subscript assign array, vector, and matrix types")
+                raise WarpCodegenError("Can only subscript assign array, vector, and matrix types")
 
-            return var
-
-        elif isinstance(node.targets[0], ast.Name):
+        elif isinstance(lhs, ast.Name):
             # symbol name
-            name = node.targets[0].id
+            name = lhs.id
 
             # evaluate rhs
             rhs = adj.eval(node.value)
 
             # check type matches if symbol already defined
             if name in adj.symbols:
-                if not types_equal(rhs.type, adj.symbols[name].type):
-                    raise TypeError(
-                        "Error, assigning to existing symbol {} ({}) with different type ({})".format(
-                            name, adj.symbols[name].type, rhs.type
-                        )
+                if not types_equal(strip_reference(rhs.type), adj.symbols[name].type):
+                    raise WarpCodegenTypeError(
+                        f"Error, assigning to existing symbol {name} ({adj.symbols[name].type}) with different type ({rhs.type})"
                     )
 
             # handle simple assignment case (a = b), where we generate a value copy rather than reference
-            if isinstance(node.value, ast.Name):
-                out = adj.add_var(rhs.type)
-                adj.add_call(warp.context.builtin_functions["copy"], [out, rhs])
+            if isinstance(node.value, ast.Name) or is_reference(rhs.type):
+                out = adj.add_builtin_call("copy", [rhs])
             else:
                 out = rhs
 
             # update symbol map (assumes lhs is a Name node)
             adj.symbols[name] = out
-            return out
 
-        elif isinstance(node.targets[0], ast.Attribute):
+        elif isinstance(lhs, ast.Attribute):
             rhs = adj.eval(node.value)
-            attr = adj.emit_Attribute(node.targets[0])
-            adj.add_call(warp.context.builtin_functions["copy"], [attr, rhs])
+            aggregate = adj.eval(lhs.value)
+            aggregate_type = strip_reference(aggregate.type)
 
-            if warp.config.verbose and not adj.custom_reverse_mode:
-                lineno = adj.lineno + adj.fun_lineno
-                line = adj.source.splitlines()[adj.lineno]
-                msg = f'Warning: detected mutated struct {attr.label} during function "{adj.fun_name}" at {adj.filename}:{lineno}: this is a non-differentiable operation.\n{line}\n'
-                print(msg)
+            # assigning to a vector component
+            if type_is_vector(aggregate_type):
+                index = adj.vector_component_index(lhs.attr, aggregate_type)
+
+                if is_reference(aggregate.type):
+                    attr = adj.add_builtin_call("indexref", [aggregate, index])
+                else:
+                    attr = adj.add_builtin_call("index", [aggregate, index])
+
+                adj.add_builtin_call("store", [attr, rhs])
+
+            else:
+                attr = adj.emit_Attribute(lhs)
+                if is_reference(attr.type):
+                    adj.add_builtin_call("store", [attr, rhs])
+                else:
+                    adj.add_builtin_call("assign", [attr, rhs])
+
+                if warp.config.verbose and not adj.custom_reverse_mode:
+                    lineno = adj.lineno + adj.fun_lineno
+                    line = adj.source_lines[adj.lineno]
+                    msg = f'Warning: detected mutated struct {attr.label} during function "{adj.fun_name}" at {adj.filename}:{lineno}: this is a non-differentiable operation.\n{line}\n'
+                    print(msg)
 
         else:
-            raise RuntimeError("Error, unsupported assignment statement.")
+            raise WarpCodegenError("Error, unsupported assignment statement.")
 
     def emit_Return(adj, node):
         if node.value is None:
@@ -1675,37 +1908,26 @@ class Adjoint:
             var = (adj.eval(node.value),)
 
         if adj.return_var is not None:
-            old_ctypes = tuple(v.ctype() for v in adj.return_var)
-            new_ctypes = tuple(v.ctype() for v in var)
+            old_ctypes = tuple(v.ctype(value_type=True) for v in adj.return_var)
+            new_ctypes = tuple(v.ctype(value_type=True) for v in var)
             if old_ctypes != new_ctypes:
-                raise TypeError(
+                raise WarpCodegenTypeError(
                     f"Error, function returned different types, previous: [{', '.join(old_ctypes)}], new [{', '.join(new_ctypes)}]"
                 )
-        else:
-            adj.return_var = var
 
-        adj.add_return(var)
+        if var is not None:
+            adj.return_var = tuple()
+            for ret in var:
+                if is_reference(ret.type):
+                    ret = adj.add_builtin_call("copy", [ret])
+                adj.return_var += (ret,)
 
-    def emit_AugAssign(adj, node):
-        # convert inplace operations (+=, -=, etc) to ssa form, e.g.: c = a + b
-        left = adj.eval(node.target)
+        adj.add_return(adj.return_var)
 
-        if left.is_adjoint:
-            # replace augassign with assignment statement + binary op
-            new_node = ast.Assign(targets=[node.target], value=ast.BinOp(node.target, node.op, node.value))
-            adj.eval(new_node)
-            return
-
-        right = adj.eval(node.value)
-
-        # lookup
-        name = builtin_operators[type(node.op)]
-        func = warp.context.builtin_functions[name]
-
-        out = adj.add_call(func, [left, right])
-
-        # update symbol map
-        adj.symbols[node.target.id] = out
+    def emit_AugAssign(adj, node):
+        # replace augmented assignment with assignment statement + binary op
+        new_node = ast.Assign(targets=[node.target], value=ast.BinOp(node.target, node.op, node.value))
+        adj.eval(new_node)
 
     def emit_Tuple(adj, node):
         # LHS for expressions, such as i, j, k = 1, 2, 3
@@ -1715,131 +1937,159 @@ class Adjoint:
     def emit_Pass(adj, node):
         pass
 
+    node_visitors = {
+        ast.FunctionDef: emit_FunctionDef,
+        ast.If: emit_If,
+        ast.Compare: emit_Compare,
+        ast.BoolOp: emit_BoolOp,
+        ast.Name: emit_Name,
+        ast.Attribute: emit_Attribute,
+        ast.Str: emit_String,  # Deprecated in 3.8; use Constant
+        ast.Num: emit_Num,  # Deprecated in 3.8; use Constant
+        ast.NameConstant: emit_NameConstant,  # Deprecated in 3.8; use Constant
+        ast.Constant: emit_Constant,
+        ast.BinOp: emit_BinOp,
+        ast.UnaryOp: emit_UnaryOp,
+        ast.While: emit_While,
+        ast.For: emit_For,
+        ast.Break: emit_Break,
+        ast.Continue: emit_Continue,
+        ast.Expr: emit_Expr,
+        ast.Call: emit_Call,
+        ast.Index: emit_Index,  # Deprecated in 3.8; Use the index value directly instead.
+        ast.Subscript: emit_Subscript,
+        ast.Assign: emit_Assign,
+        ast.Return: emit_Return,
+        ast.AugAssign: emit_AugAssign,
+        ast.Tuple: emit_Tuple,
+        ast.Pass: emit_Pass,
+        ast.Ellipsis: emit_Ellipsis,
+    }
+
     def eval(adj, node):
         if hasattr(node, "lineno"):
             adj.set_lineno(node.lineno - 1)
 
-        node_visitors = {
-            ast.FunctionDef: Adjoint.emit_FunctionDef,
-            ast.If: Adjoint.emit_If,
-            ast.Compare: Adjoint.emit_Compare,
-            ast.BoolOp: Adjoint.emit_BoolOp,
-            ast.Name: Adjoint.emit_Name,
-            ast.Attribute: Adjoint.emit_Attribute,
-            ast.Str: Adjoint.emit_String,  # Deprecated in 3.8; use Constant
-            ast.Num: Adjoint.emit_Num,  # Deprecated in 3.8; use Constant
-            ast.NameConstant: Adjoint.emit_NameConstant,  # Deprecated in 3.8; use Constant
-            ast.Constant: Adjoint.emit_Constant,
-            ast.BinOp: Adjoint.emit_BinOp,
-            ast.UnaryOp: Adjoint.emit_UnaryOp,
-            ast.While: Adjoint.emit_While,
-            ast.For: Adjoint.emit_For,
-            ast.Break: Adjoint.emit_Break,
-            ast.Continue: Adjoint.emit_Continue,
-            ast.Expr: Adjoint.emit_Expr,
-            ast.Call: Adjoint.emit_Call,
-            ast.Index: Adjoint.emit_Index,  # Deprecated in 3.8; Use the index value directly instead.
-            ast.Subscript: Adjoint.emit_Subscript,
-            ast.Assign: Adjoint.emit_Assign,
-            ast.Return: Adjoint.emit_Return,
-            ast.AugAssign: Adjoint.emit_AugAssign,
-            ast.Tuple: Adjoint.emit_Tuple,
-            ast.Pass: Adjoint.emit_Pass,
-        }
-
-        emit_node = node_visitors.get(type(node))
-
-        if emit_node is not None:
-            if adj.is_user_function:
-                if hasattr(node, "value") and hasattr(node.value, "func") and hasattr(node.value.func, "attr"):
-                    if node.value.func.attr == "tid":
-                        lineno = adj.lineno + adj.fun_lineno
-                        line = adj.source.splitlines()[adj.lineno]
-
-                        warp.utils.warn(
-                            "Calling wp.tid() from a @wp.func is deprecated and will be removed in a future Warp "
-                            "version. Instead, obtain the indices from a @wp.kernel and pass them as "
-                            f"arguments to this function {adj.fun_name}, {adj.filename}:{lineno}:\n{line}\n",
-                            PendingDeprecationWarning,
-                            stacklevel=2,
-                        )
-            return emit_node(adj, node)
-        else:
-            raise Exception("Error, ast node of type {} not supported".format(type(node)))
+        emit_node = adj.node_visitors[type(node)]
+
+        return emit_node(adj, node)
 
     # helper to evaluate expressions of the form
     # obj1.obj2.obj3.attr in the function's global scope
-    def resolve_path(adj, node):
-        modules = []
+    def resolve_path(adj, path):
+        if len(path) == 0:
+            return None
 
-        while isinstance(node, ast.Attribute):
-            modules.append(node.attr)
-            node = node.value
+        # if root is overshadowed by local symbols, bail out
+        if path[0] in adj.symbols:
+            return None
 
-        if isinstance(node, ast.Name):
-            modules.append(node.id)
+        if path[0] in __builtins__:
+            return __builtins__[path[0]]
 
-        # reverse list since ast presents it backward order
-        path = [*reversed(modules)]
+        # Look up the closure info and append it to adj.func.__globals__
+        # in case you want to define a kernel inside a function and refer
+        # to variables you've declared inside that function:
+        extract_contents = (
+            lambda contents: contents
+            if isinstance(contents, warp.context.Function) or not callable(contents)
+            else contents
+        )
+        capturedvars = dict(
+            zip(
+                adj.func.__code__.co_freevars,
+                [extract_contents(c.cell_contents) for c in (adj.func.__closure__ or [])],
+            )
+        )
+        vars_dict = {**adj.func.__globals__, **capturedvars}
 
-        if len(path) == 0:
-            return None, path
+        if path[0] in vars_dict:
+            func = vars_dict[path[0]]
 
-        # try and evaluate object path
-        try:
-            # Look up the closure info and append it to adj.func.__globals__
-            # in case you want to define a kernel inside a function and refer
-            # to variables you've declared inside that function:
-            extract_contents = (
-                lambda contents: contents
-                if isinstance(contents, warp.context.Function) or not callable(contents)
-                else contents
-            )
-            capturedvars = dict(
-                zip(
-                    adj.func.__code__.co_freevars,
-                    [extract_contents(c.cell_contents) for c in (adj.func.__closure__ or [])],
-                )
-            )
+        # Support Warp types in kernels without the module suffix (e.g. v = vec3(0.0,0.2,0.4)):
+        else:
+            func = getattr(warp, path[0], None)
 
-            vars_dict = {**adj.func.__globals__, **capturedvars}
-            func = eval(".".join(path), vars_dict)
-            return func, path
-        except Exception:
-            pass
+        if func:
+            for i in range(1, len(path)):
+                if hasattr(func, path[i]):
+                    func = getattr(func, path[i])
 
-        # I added this so people can eg do this kind of thing
-        # in a kernel:
+        return func
 
-        # v = vec3(0.0,0.2,0.4)
+    # Evaluates a static expression that does not depend on runtime values
+    # if eval_types is True, try resolving the path using evaluated type information as well
+    def resolve_static_expression(adj, root_node, eval_types=True):
+        attributes = []
 
-        # vec3 is now an alias and is not in warp.context.builtin_functions.
-        # This means it can't be directly looked up in Adjoint.add_call, and
-        # needs to be looked up by digging some information out of the
-        # python object it actually came from.
+        node = root_node
+        while isinstance(node, ast.Attribute):
+            attributes.append(node.attr)
+            node = node.value
 
-        # Before this fix, resolve_path was returning None, as the
-        # "vec3" symbol is not available. In this situation I'm assuming
-        # it's a member of the warp module and trying to look it up:
-        try:
-            evalstr = ".".join(["warp"] + path)
-            func = eval(evalstr, {"warp": warp})
-            return func, path
-        except Exception:
-            return None, path
+        if eval_types and isinstance(node, ast.Call) and isinstance(node.func, ast.Name):
+            # support for operators returning modules
+            # i.e. operator_name(*operator_args).x.y.z
+            operator_args = node.args
+            operator_name = node.func.id
+
+            if operator_name == "type":
+                if len(operator_args) != 1:
+                    raise WarpCodegenError(f"type() operator expects exactly one argument, got {len(operator_args)}")
+
+                # type() operator
+                var = adj.eval(operator_args[0])
+
+                if isinstance(var, Var):
+                    var_type = strip_reference(var.type)
+                    # Allow accessing type attributes, for instance array.dtype
+                    while attributes:
+                        attr_name = attributes.pop()
+                        var_type, prev_type = adj.resolve_type_attribute(var_type, attr_name), var_type
+
+                        if var_type is None:
+                            raise WarpCodegenAttributeError(
+                                f"{attr_name} is not an attribute of {type_repr(prev_type)}"
+                            )
+
+                    return var_type, [type_repr(var_type)]
+                else:
+                    raise WarpCodegenError(f"Cannot deduce the type of {var}")
+
+        # reverse list since ast presents it backward order
+        path = [*reversed(attributes)]
+        if isinstance(node, ast.Name):
+            path.insert(0, node.id)
+
+        # Try resolving path from captured context
+        captured_obj = adj.resolve_path(path)
+        if captured_obj is not None:
+            return captured_obj, path
+
+        # Still nothing found, maybe this is a predefined type attribute like `dtype`
+        if eval_types:
+            try:
+                val = adj.eval(root_node)
+                if val:
+                    return [val, type_repr(val)]
+
+            except Exception:
+                pass
+
+        return None, path
 
     # annotate generated code with the original source code line
     def set_lineno(adj, lineno):
         if adj.lineno is None or adj.lineno != lineno:
             line = lineno + adj.fun_lineno
-            source = adj.raw_source[lineno].strip().ljust(80 - len(adj.prefix), " ")
+            source = adj.source_lines[lineno].strip().ljust(80 - len(adj.indentation), " ")
             adj.add_forward(f"// {source}       <L {line}>")
             adj.add_reverse(f"// adj: {source}  <L {line}>")
         adj.lineno = lineno
 
     def get_node_source(adj, node):
         # return the Python code corresponding to the given AST node
-        return ast.get_source_segment("".join(adj.raw_source), node)
+        return ast.get_source_segment(adj.source, node)
 
 
 # ----------------
@@ -1856,7 +2106,10 @@ cpu_module_header = """
 #define int(x) cast_int(x)
 #define adj_int(x, adj_x, adj_ret) adj_cast_int(x, adj_x, adj_ret)
 
-using namespace wp;
+#define builtin_tid1d() wp::tid(wp::s_threadIdx)
+#define builtin_tid2d(x, y) wp::tid(x, y, wp::s_threadIdx, dim)
+#define builtin_tid3d(x, y, z) wp::tid(x, y, z, wp::s_threadIdx, dim)
+#define builtin_tid4d(x, y, z, w) wp::tid(x, y, z, w, wp::s_threadIdx, dim)
 
 """
 
@@ -1871,8 +2124,10 @@ cuda_module_header = """
 #define int(x) cast_int(x)
 #define adj_int(x, adj_x, adj_ret) adj_cast_int(x, adj_x, adj_ret)
 
-
-using namespace wp;
+#define builtin_tid1d() wp::tid(_idx)
+#define builtin_tid2d(x, y) wp::tid(x, y, _idx, dim)
+#define builtin_tid3d(x, y, z) wp::tid(x, y, z, _idx, dim)
+#define builtin_tid4d(x, y, z, w) wp::tid(x, y, z, w, _idx, dim)
 
 """
 
@@ -1886,7 +2141,9 @@ struct {name}
     {{
     }}
 
-    CUDA_CALLABLE {name}& operator += (const {name}&) {{ return *this; }}
+    CUDA_CALLABLE {name}& operator += (const {name}& rhs)
+    {{{prefix_add_body}
+        return *this;}}
 
 }};
 
@@ -1942,24 +2199,18 @@ cuda_kernel_template = """
 extern "C" __global__ void {name}_cuda_kernel_forward(
     {forward_args})
 {{
-    size_t _idx = grid_index();
-    if (_idx >= dim.size)
-        return;
-
-    set_launch_bounds(dim);
-
-{forward_body}}}
+    for (size_t _idx = static_cast<size_t>(blockDim.x) * static_cast<size_t>(blockIdx.x) + static_cast<size_t>(threadIdx.x);
+         _idx < dim.size;
+         _idx += static_cast<size_t>(blockDim.x) * static_cast<size_t>(gridDim.x)) {{
+{forward_body}}}}}
 
 extern "C" __global__ void {name}_cuda_kernel_backward(
     {reverse_args})
 {{
-    size_t _idx = grid_index();
-    if (_idx >= dim.size)
-        return;
-
-    set_launch_bounds(dim);
-
-{reverse_body}}}
+    for (size_t _idx = static_cast<size_t>(blockDim.x) * static_cast<size_t>(blockIdx.x) + static_cast<size_t>(threadIdx.x);
+         _idx < dim.size;
+         _idx += static_cast<size_t>(blockDim.x) * static_cast<size_t>(gridDim.x)) {{
+{reverse_body}}}}}
 
 """
 
@@ -1985,11 +2236,9 @@ extern "C" {{
 WP_API void {name}_cpu_forward(
     {forward_args})
 {{
-    set_launch_bounds(dim);
-
     for (size_t i=0; i < dim.size; ++i)
     {{
-        s_threadIdx = i;
+        wp::s_threadIdx = i;
 
         {name}_cpu_kernel_forward(
             {forward_params});
@@ -1999,11 +2248,9 @@ WP_API void {name}_cpu_forward(
 WP_API void {name}_cpu_backward(
     {reverse_args})
 {{
-    set_launch_bounds(dim);
-
     for (size_t i=0; i < dim.size; ++i)
     {{
-        s_threadIdx = i;
+        wp::s_threadIdx = i;
 
         {name}_cpu_kernel_backward(
             {reverse_params});
@@ -2109,8 +2356,13 @@ def codegen_struct(struct, device="cpu", indent_size=4):
 
     body = []
     indent_block = " " * indent_size
-    for label, var in struct.vars.items():
-        body.append(var.ctype() + " " + label + ";\n")
+
+    if len(struct.vars) > 0:
+        for label, var in struct.vars.items():
+            body.append(var.ctype() + " " + label + ";\n")
+    else:
+        # for empty structs, emit the dummy attribute to avoid any compiler-specific alignment issues
+        body.append("char _dummy_;\n")
 
     forward_args = []
     reverse_args = []
@@ -2118,17 +2370,25 @@ def codegen_struct(struct, device="cpu", indent_size=4):
     forward_initializers = []
     reverse_body = []
     atomic_add_body = []
+    prefix_add_body = []
 
     # forward args
     for label, var in struct.vars.items():
-        forward_args.append(f"{var.ctype()} const& {label} = {{}}")
-        reverse_args.append(f"{var.ctype()} const&")
+        var_ctype = var.ctype()
+        forward_args.append(f"{var_ctype} const& {label} = {{}}")
+        reverse_args.append(f"{var_ctype} const&")
 
-        atomic_add_body.append(f"{indent_block}adj_atomic_add(&p->{label}, t.{label});\n")
+        namespace = "wp::" if var_ctype.startswith("wp::") or var_ctype == "bool" else ""
+        atomic_add_body.append(f"{indent_block}{namespace}adj_atomic_add(&p->{label}, t.{label});\n")
 
         prefix = f"{indent_block}," if forward_initializers else ":"
         forward_initializers.append(f"{indent_block}{prefix} {label}{{{label}}}\n")
 
+    # prefix-add operator
+    for label, var in struct.vars.items():
+        if not is_array(var.type):
+            prefix_add_body.append(f"{indent_block}{label} += rhs.{label};\n")
+
     # reverse args
     for label, var in struct.vars.items():
         reverse_args.append(var.ctype() + " & adj_" + label)
@@ -2146,6 +2406,7 @@ def codegen_struct(struct, device="cpu", indent_size=4):
         forward_initializers="".join(forward_initializers),
         reverse_args=indent(reverse_args),
         reverse_body="".join(reverse_body),
+        prefix_add_body="".join(prefix_add_body),
         atomic_add_body="".join(atomic_add_body),
     )
 
@@ -2189,7 +2450,7 @@ def codegen_func_forward(adj, func_type="kernel", device="cpu"):
     return s
 
 
-def codegen_func_reverse_body(adj, device="cpu", indent=4):
+def codegen_func_reverse_body(adj, device="cpu", indent=4, func_type="kernel"):
     body = []
     indent_block = " " * indent
 
@@ -2207,7 +2468,11 @@ def codegen_func_reverse_body(adj, device="cpu", indent=4):
     for l in reversed(adj.blocks[0].body_reverse):
         body += [l + "\n"]
 
-    body += ["return;\n"]
+    # In grid-stride kernels the reverse body is in a for loop
+    if device == "cuda" and func_type == "kernel":
+        body += ["continue;\n"]
+    else:
+        body += ["return;\n"]
 
     return "".join([indent_block + l for l in body])
 
@@ -2230,20 +2495,17 @@ def codegen_func_reverse(adj, func_type="kernel", device="cpu"):
     s += "    // dual vars\n"
 
     for var in adj.variables:
-        if isinstance(var.type, Struct):
-            s += f"    {var.ctype()} {var.emit('adj')};\n"
-        else:
-            s += f"    {var.ctype()} {var.emit('adj')}(0);\n"
+        s += f"    {var.ctype(value_type=True)} {var.emit_adj()} = {{}};\n"
 
     if device == "cpu":
         s += codegen_func_reverse_body(adj, device=device, indent=4)
     elif device == "cuda":
         if func_type == "kernel":
-            s += codegen_func_reverse_body(adj, device=device, indent=8)
+            s += codegen_func_reverse_body(adj, device=device, indent=8, func_type=func_type)
         else:
-            s += codegen_func_reverse_body(adj, device=device, indent=4)
+            s += codegen_func_reverse_body(adj, device=device, indent=4, func_type=func_type)
     else:
-        raise ValueError("Device {} not supported for codegen".format(device))
+        raise ValueError(f"Device {device} not supported for codegen")
 
     return s
 
@@ -2298,7 +2560,7 @@ def codegen_func(adj, c_func_name: str, device="cpu", options={}):
         forward_template = cuda_forward_function_template
         reverse_template = cuda_reverse_function_template
     else:
-        raise ValueError("Device {} is not supported".format(device))
+        raise ValueError(f"Device {device} is not supported")
 
     # codegen body
     forward_body = codegen_func_forward(adj, func_type="function", device=device)
@@ -2335,6 +2597,55 @@ def codegen_func(adj, c_func_name: str, device="cpu", options={}):
     return s
 
 
+def codegen_snippet(adj, name, snippet, adj_snippet):
+    forward_args = []
+    reverse_args = []
+
+    # forward args
+    for i, arg in enumerate(adj.args):
+        s = f"{arg.ctype()} {arg.emit().replace('var_', '')}"
+        forward_args.append(s)
+        reverse_args.append(s)
+
+    # reverse args
+    for i, arg in enumerate(adj.args):
+        if isinstance(arg.type, indexedarray):
+            _arg = Var(arg.label, array(dtype=arg.type.dtype, ndim=arg.type.ndim))
+            reverse_args.append(_arg.ctype() + " & adj_" + arg.label)
+        else:
+            reverse_args.append(arg.ctype() + " & adj_" + arg.label)
+
+    forward_template = cuda_forward_function_template
+    reverse_template = cuda_reverse_function_template
+
+    s = ""
+    s += forward_template.format(
+        name=name,
+        return_type="void",
+        forward_args=indent(forward_args),
+        forward_body=snippet,
+        filename=adj.filename,
+        lineno=adj.fun_lineno,
+    )
+
+    if adj_snippet:
+        reverse_body = adj_snippet
+    else:
+        reverse_body = ""
+
+    s += reverse_template.format(
+        name=name,
+        return_type="void",
+        reverse_args=indent(reverse_args),
+        forward_body=snippet,
+        reverse_body=reverse_body,
+        filename=adj.filename,
+        lineno=adj.fun_lineno,
+    )
+
+    return s
+
+
 def codegen_kernel(kernel, device, options):
     # Update the module's options with the ones defined on the kernel, if any.
     options = dict(options)
@@ -2342,8 +2653,8 @@ def codegen_kernel(kernel, device, options):
 
     adj = kernel.adj
 
-    forward_args = ["launch_bounds_t dim"]
-    reverse_args = ["launch_bounds_t dim"]
+    forward_args = ["wp::launch_bounds_t dim"]
+    reverse_args = ["wp::launch_bounds_t dim"]
 
     # forward args
     for arg in adj.args:
@@ -2372,7 +2683,7 @@ def codegen_kernel(kernel, device, options):
     elif device == "cuda":
         template = cuda_kernel_template
     else:
-        raise ValueError("Device {} is not supported".format(device))
+        raise ValueError(f"Device {device} is not supported")
 
     s = template.format(
         name=kernel.get_mangled_name(),
@@ -2392,7 +2703,7 @@ def codegen_module(kernel, device="cpu"):
     adj = kernel.adj
 
     # build forward signature
-    forward_args = ["launch_bounds_t dim"]
+    forward_args = ["wp::launch_bounds_t dim"]
     forward_params = ["dim"]
 
     for arg in adj.args: