gstaichi 0.1.20.dev0__cp310-cp310-macosx_15_0_arm64.whl → 0.1.25.dev0__cp310-cp310-macosx_15_0_arm64.whl

{taichi → gstaichi}/lang/runtime_ops.py

@@ -1,11 +1,11 @@
 # type: ignore
 
-from taichi.lang import impl
+from gstaichi.lang import impl
 
 
 def sync():
     """Blocks the calling thread until all the previously
-    launched Taichi kernels have completed.
+    launched GsTaichi kernels have completed.
     """
     impl.get_runtime().sync()
 

{taichi → gstaichi}/lang/shell.py

@@ -4,8 +4,8 @@ import functools
 import os
 import sys
 
-from taichi._lib import core as _ti_core
-from taichi._logging import info
+from gstaichi._lib import core as _ti_core
+from gstaichi._logging import info
 
 pybuf_enabled = False
 _env_enable_pybuf = os.environ.get("TI_ENABLE_PYBUF", "1")
@@ -28,7 +28,7 @@ def _shell_pop_print(old_call):
     def new_call(*args, **kwargs):
         ret = old_call(*args, **kwargs)
         # print's in kernel won't take effect until ti.sync(), discussion:
-        # https://github.com/taichi-dev/taichi/pull/1303#discussion_r444897102
+        # https://github.com/taichi-dev/gstaichi/pull/1303#discussion_r444897102
         print(_ti_core.pop_python_print_buffer(), end="")
         return ret
 

{taichi → gstaichi}/lang/simt/__init__.py

@@ -1,5 +1,5 @@
 # type: ignore
 
-from taichi.lang.simt import block, grid, subgroup, warp
+from gstaichi.lang.simt import block, grid, subgroup, warp
 
 __all__ = ["warp", "subgroup", "block", "grid"]

{taichi → gstaichi}/lang/simt/block.py

@@ -1,13 +1,13 @@
 # type: ignore
 
-from taichi._lib import core as _ti_core
-from taichi.lang import impl
-from taichi.lang.expr import make_expr_group
-from taichi.lang.util import taichi_scope
+from gstaichi._lib import core as _ti_core
+from gstaichi.lang import impl
+from gstaichi.lang.expr import make_expr_group
+from gstaichi.lang.util import gstaichi_scope
 
 
 def arch_uses_spv(arch):
-    return arch == _ti_core.vulkan or arch == _ti_core.metal or arch == _ti_core.opengl or arch == _ti_core.dx11
+    return arch == _ti_core.vulkan or arch == _ti_core.metal
 
 
 def sync():
@@ -66,7 +66,7 @@ def global_thread_idx():
 
 
 class SharedArray:
-    _is_taichi_class = True
+    _is_gstaichi_class = True
 
     def __init__(self, shape, dtype):
         if isinstance(shape, int):
@@ -82,7 +82,7 @@ class SharedArray:
         self.dtype = dtype
         self.shared_array_proxy = impl.expr_init_shared_array(self.shape, dtype)
 
-    @taichi_scope
+    @gstaichi_scope
     def subscript(self, *indices):
         ast_builder = impl.get_runtime().compiling_callable.ast_builder()
         return impl.Expr(

{taichi → gstaichi}/lang/simt/grid.py

@@ -1,6 +1,6 @@
 # type: ignore
 
-from taichi.lang import impl
+from gstaichi.lang import impl
 
 
 def memfence():

{taichi → gstaichi}/lang/simt/subgroup.py

@@ -1,6 +1,6 @@
 # type: ignore
 
-from taichi.lang import impl
+from gstaichi.lang import impl
 
 
 def barrier():

{taichi → gstaichi}/lang/simt/warp.py

@@ -1,6 +1,6 @@
 # type: ignore
 
-from taichi.lang import impl
+from gstaichi.lang import impl
 
 
 def all_nonzero(mask, predicate):

{taichi → gstaichi}/lang/snode.py

@@ -2,23 +2,25 @@
 
 import numbers
 
-from taichi._lib import core as _ti_core
-from taichi._lib.core.taichi_python import Axis
-from taichi._lib.core.taichi_python import SNode as SNodeCxx
-from taichi.lang import expr, impl, matrix
-from taichi.lang.exception import TaichiRuntimeError
-from taichi.lang.field import BitpackedFields, Field
-from taichi.lang.util import get_traceback
+from gstaichi._lib import core as _ti_core
+from gstaichi._lib.core.gstaichi_python import (
+    Axis,
+    SNodeCxx,
+)
+from gstaichi.lang import expr, impl, matrix
+from gstaichi.lang.exception import GsTaichiRuntimeError
+from gstaichi.lang.field import BitpackedFields, Field
+from gstaichi.lang.util import get_traceback
 
 
 class SNode:
     """A Python-side SNode wrapper.
 
-    For more information on Taichi's SNode system, please check out
+    For more information on GsTaichi's SNode system, please check out
     these references:
 
     * https://docs.taichi-lang.org/docs/sparse
-    * https://yuanming.taichi.graphics/publication/2019-taichi/taichi-lang.pdf
+    * https://yuanming.gstaichi.graphics/publication/2019-gstaichi/gstaichi-lang.pdf
 
     Arg:
         ptr (pointer): The C++ side SNode pointer.
@@ -35,7 +37,7 @@ class SNode:
             dimensions (Union[List[int], int]): Shape of each axis.
 
         Returns:
-            The added :class:`~taichi.lang.SNode` instance.
+            The added :class:`~gstaichi.lang.SNode` instance.
         """
         if isinstance(dimensions, numbers.Number):
             dimensions = [dimensions] * len(axes)
@@ -49,10 +51,10 @@ class SNode:
             dimensions (Union[List[int], int]): Shape of each axis.
 
         Returns:
-            The added :class:`~taichi.lang.SNode` instance.
+            The added :class:`~gstaichi.lang.SNode` instance.
         """
         if not _ti_core.is_extension_supported(impl.current_cfg().arch, _ti_core.Extension.sparse):
-            raise TaichiRuntimeError("Pointer SNode is not supported on this backend.")
+            raise GsTaichiRuntimeError("Pointer SNode is not supported on this backend.")
         if isinstance(dimensions, numbers.Number):
             dimensions = [dimensions] * len(axes)
         return SNode(self.ptr.pointer(axes, dimensions, _ti_core.DebugInfo(get_traceback())))
@@ -75,10 +77,10 @@ class SNode:
             chunk_size (int): Chunk size.
 
         Returns:
-            The added :class:`~taichi.lang.SNode` instance.
+            The added :class:`~gstaichi.lang.SNode` instance.
         """
         if not _ti_core.is_extension_supported(impl.current_cfg().arch, _ti_core.Extension.sparse):
-            raise TaichiRuntimeError("Dynamic SNode is not supported on this backend.")
+            raise GsTaichiRuntimeError("Dynamic SNode is not supported on this backend.")
         assert len(axis) == 1
         if chunk_size is None:
             chunk_size = dimension
@@ -92,10 +94,10 @@ class SNode:
             dimensions (Union[List[int], int]): Shape of each axis.
 
         Returns:
-            The added :class:`~taichi.lang.SNode` instance.
+            The added :class:`~gstaichi.lang.SNode` instance.
         """
         if not _ti_core.is_extension_supported(impl.current_cfg().arch, _ti_core.Extension.sparse):
-            raise TaichiRuntimeError("Bitmasked SNode is not supported on this backend.")
+            raise GsTaichiRuntimeError("Bitmasked SNode is not supported on this backend.")
         if isinstance(dimensions, numbers.Number):
             dimensions = [dimensions] * len(axes)
         return SNode(self.ptr.bitmasked(axes, dimensions, _ti_core.DebugInfo(get_traceback())))
@@ -109,17 +111,17 @@ class SNode:
             max_num_bits (int): Maximum number of bits it can hold.
 
         Returns:
-            The added :class:`~taichi.lang.SNode` instance.
+            The added :class:`~gstaichi.lang.SNode` instance.
         """
         if isinstance(dimensions, numbers.Number):
             dimensions = [dimensions] * len(axes)
         return SNode(self.ptr.quant_array(axes, dimensions, max_num_bits, _ti_core.DebugInfo(get_traceback())))
 
     def place(self, *args, offset: numbers.Number | tuple[numbers.Number] | None = None) -> "SNode":
-        """Places a list of Taichi fields under the `self` container.
+        """Places a list of GsTaichi fields under the `self` container.
 
         Args:
-            *args (List[ti.field]): A list of Taichi fields to place.
+            *args (List[ti.field]): A list of GsTaichi fields to place.
             offset (Union[Number, tuple[Number]]): Offset of the field domain.
 
         Returns:
@@ -150,11 +152,11 @@ class SNode:
         """Automatically place the adjoint fields following the layout of their primal fields.
 
         Users don't need to specify ``needs_grad`` when they define scalar/vector/matrix fields (primal fields) using autodiff.
-        When all the primal fields are defined, using ``taichi.root.lazy_grad()`` could automatically generate
+        When all the primal fields are defined, using ``gstaichi.root.lazy_grad()`` could automatically generate
         their corresponding adjoint fields (gradient field).
 
         To know more details about primal, adjoint fields and ``lazy_grad()``,
-        please see Page 4 and Page 13-14 of DiffTaichi Paper: https://arxiv.org/pdf/1910.00935.pdf
+        please see Page 4 and Page 13-14 of DiffGsTaichi Paper: https://arxiv.org/pdf/1910.00935.pdf
         """
         self.ptr.lazy_grad()
 
@@ -236,10 +238,10 @@ class SNode:
         return ret
 
     def _loop_range(self):
-        """Gets the taichi_python.SNode to serve as loop range.
+        """Gets the gstaichi_python.SNode to serve as loop range.
 
         Returns:
-            taichi_python.SNode: See above.
+            gstaichi_python.SNode: See above.
         """
         return self.ptr
 
@@ -294,14 +296,14 @@ class SNode:
             c.deactivate_all()
         SNodeType = _ti_core.SNodeType
         if self.ptr.type == SNodeType.pointer or self.ptr.type == SNodeType.bitmasked:
-            from taichi._kernels import snode_deactivate  # pylint: disable=C0415
+            from gstaichi._kernels import snode_deactivate  # pylint: disable=C0415
 
             snode_deactivate(self)
         if self.ptr.type == SNodeType.dynamic:
             # Note that dynamic nodes are different from other sparse nodes:
             # instead of deactivating each element, we only need to deactivate
             # its parent, whose linked list of chunks of elements will be deleted.
-            from taichi._kernels import (  # pylint: disable=C0415
+            from gstaichi._kernels import (  # pylint: disable=C0415
                 snode_deactivate_dynamic,
             )
 
@@ -340,11 +342,11 @@ def rescale_index(a, b, I):
 
     Args:
 
-        a, b (Union[:class:`~taichi.Field`, :class:`~taichi.MatrixField`): Input taichi fields or snodes.
-        I (Union[list, :class:`~taichi.Vector`]): grouped loop index.
+        a, b (Union[:class:`~gstaichi.Field`, :class:`~gstaichi.MatrixField`): Input gstaichi fields or snodes.
+        I (Union[list, :class:`~gstaichi.Vector`]): grouped loop index.
 
     Returns:
-        Ib (:class:`~taichi.Vector`): rescaled grouped loop index
+        Ib (:class:`~gstaichi.Vector`): rescaled grouped loop index
     """
 
     assert isinstance(a, (Field, SNode)), "The first argument must be a field or an SNode"
@@ -357,7 +359,7 @@ def rescale_index(a, b, I):
         ), "The third argument must be an index (list, ti.Vector, or Expr with TensorType)"
         n = I.n
 
-    from taichi.lang.kernel_impl import pyfunc  # pylint: disable=C0415
+    from gstaichi.lang.kernel_impl import pyfunc  # pylint: disable=C0415
 
     @pyfunc
     def _rescale_index():
@@ -376,9 +378,9 @@ def append(node, indices, val):
     """Append a value `val` to a SNode `node` at index `indices`.
 
     Args:
-        node (:class:`~taichi.SNode`): Input SNode.
-        indices (Union[int, :class:`~taichi.Vector`]): the indices to visit.
-        val (Union[:mod:`~taichi.types.primitive_types`, :mod:`~taichi.types.compound_types`]): the data to be appended.
+        node (:class:`~gstaichi.SNode`): Input SNode.
+        indices (Union[int, :class:`~gstaichi.Vector`]): the indices to visit.
+        val (Union[:mod:`~gstaichi.types.primitive_types`, :mod:`~gstaichi.types.compound_types`]): the data to be appended.
     """
     ptrs = expr._get_flattened_ptrs(val)
     append_expr = expr.Expr(
@@ -396,8 +398,8 @@ def is_active(node, indices):
     `indices` is active or not.
 
     Args:
-        node (:class:`~taichi.SNode`): Must be a pointer, hash or bitmasked node.
-        indices (Union[int, list, :class:`~taichi.Vector`]): the indices to visit.
+        node (:class:`~gstaichi.SNode`): Must be a pointer, hash or bitmasked node.
+        indices (Union[int, list, :class:`~gstaichi.Vector`]): the indices to visit.
 
     Returns:
         bool: the cell `node[indices]` is active or not.
@@ -414,8 +416,8 @@ def activate(node, indices):
     """Explicitly activate a cell of `node` at location `indices`.
 
     Args:
-        node (:class:`~taichi.SNode`): Must be a pointer, hash or bitmasked node.
-        indices (Union[int, :class:`~taichi.Vector`]): the indices to activate.
+        node (:class:`~gstaichi.SNode`): Must be a pointer, hash or bitmasked node.
+        indices (Union[int, :class:`~gstaichi.Vector`]): the indices to activate.
     """
     impl.get_runtime().compiling_callable.ast_builder().insert_activate(
         node._snode.ptr, expr.make_expr_group(indices), _ti_core.DebugInfo(impl.get_runtime().get_current_src_info())
@@ -425,12 +427,12 @@ def activate(node, indices):
 def deactivate(node, indices):
     """Explicitly deactivate a cell of `node` at location `indices`.
 
-    After deactivation, the Taichi runtime automatically recycles and zero-fills
+    After deactivation, the GsTaichi runtime automatically recycles and zero-fills
     the memory of the deactivated cell.
 
     Args:
-        node (:class:`~taichi.SNode`): Must be a pointer, hash or bitmasked node.
-        indices (Union[int, :class:`~taichi.Vector`]): the indices to deactivate.
+        node (:class:`~gstaichi.SNode`): Must be a pointer, hash or bitmasked node.
+        indices (Union[int, :class:`~gstaichi.Vector`]): the indices to deactivate.
     """
     impl.get_runtime().compiling_callable.ast_builder().insert_deactivate(
         node._snode.ptr, expr.make_expr_group(indices), _ti_core.DebugInfo(impl.get_runtime().get_current_src_info())
@@ -441,8 +443,8 @@ def length(node, indices):
     """Return the length of the dynamic SNode `node` at index `indices`.
 
     Args:
-        node (:class:`~taichi.SNode`): a dynamic SNode.
-        indices (Union[int, :class:`~taichi.Vector`]): the indices to query.
+        node (:class:`~gstaichi.SNode`): a dynamic SNode.
+        indices (Union[int, :class:`~gstaichi.Vector`]): the indices to query.
 
     Returns:
         int: the length of cell `node[indices]`.
@@ -458,11 +460,11 @@ def length(node, indices):
 def get_addr(f, indices):
     """Query the memory address (on CUDA/x64) of field `f` at index `indices`.
 
-    Currently, this function can only be called inside a taichi kernel.
+    Currently, this function can only be called inside a gstaichi kernel.
 
     Args:
-        f (Union[:class:`~taichi.Field`, :class:`~taichi.MatrixField`]): Input taichi field for memory address query.
-        indices (Union[int, :class:`~taichi.Vector`]): The specified field indices of the query.
+        f (Union[:class:`~gstaichi.Field`, :class:`~gstaichi.MatrixField`]): Input gstaichi field for memory address query.
+        indices (Union[int, :class:`~gstaichi.Vector`]): The specified field indices of the query.
 
     Returns:
         ti.u64: The memory address of `f[indices]`.

{taichi → gstaichi}/lang/source_builder.py

@@ -7,11 +7,11 @@ import shutil
 import subprocess
 import tempfile
 
-from taichi._lib import core as _ti_core
-from taichi.lang import impl
-from taichi.lang.exception import TaichiSyntaxError
-from taichi.lang.expr import make_expr_group
-from taichi.lang.util import get_clangpp
+from gstaichi._lib import core as _ti_core
+from gstaichi.lang import impl
+from gstaichi.lang.exception import GsTaichiSyntaxError
+from gstaichi.lang.expr import make_expr_group
+from gstaichi.lang.util import get_clangpp
 
 
 class SourceBuilder:
@@ -36,7 +36,7 @@ class SourceBuilder:
 
         if filename.endswith((".cpp", ".c", ".cc")):
             if impl.current_cfg().arch not in [_ti_core.Arch.x64, _ti_core.Arch.cuda]:
-                raise TaichiSyntaxError("Unsupported arch for external function call")
+                raise GsTaichiSyntaxError("Unsupported arch for external function call")
             if compile_fn is None:
 
                 def compile_fn_impl(filename):
@@ -62,7 +62,7 @@ class SourceBuilder:
             self.mode = "bc"
         elif filename.endswith(".cu"):
             if impl.current_cfg().arch not in [_ti_core.Arch.cuda]:
-                raise TaichiSyntaxError("Unsupported arch for external function call")
+                raise GsTaichiSyntaxError("Unsupported arch for external function call")
             if compile_fn is None:
                 shutil.copy(filename, os.path.join(self.td, "source.cu"))
 
@@ -83,12 +83,12 @@ class SourceBuilder:
             self.mode = "bc"
         elif filename.endswith((".so", ".dylib", ".dll")):
             if impl.current_cfg().arch not in [_ti_core.Arch.x64]:
-                raise TaichiSyntaxError("Unsupported arch for external function call")
+                raise GsTaichiSyntaxError("Unsupported arch for external function call")
             self.so = ctypes.CDLL(filename)
             self.mode = "so"
         elif filename.endswith(".ll"):
             if impl.current_cfg().arch not in [_ti_core.Arch.x64, _ti_core.Arch.cuda]:
-                raise TaichiSyntaxError("Unsupported arch for external function call")
+                raise GsTaichiSyntaxError("Unsupported arch for external function call")
             subprocess.call(
                 "llvm-as " + filename + " -o " + os.path.join(self.td, "source.bc"),
                 shell=True,
@@ -97,17 +97,17 @@ class SourceBuilder:
             self.mode = "bc"
         elif filename.endswith(".bc"):
             if impl.current_cfg().arch not in [_ti_core.Arch.x64, _ti_core.Arch.cuda]:
-                raise TaichiSyntaxError("Unsupported arch for external function call")
+                raise GsTaichiSyntaxError("Unsupported arch for external function call")
             self.bc = filename
             self.mode = "bc"
         else:
-            raise TaichiSyntaxError("Unsupported file type for external function call.")
+            raise GsTaichiSyntaxError("Unsupported file type for external function call.")
         return self
 
     @classmethod
     def from_source(cls, source_code, compile_fn=None):
         if impl.current_cfg().arch not in [_ti_core.Arch.x64, _ti_core.Arch.cuda]:
-            raise TaichiSyntaxError("Unsupported arch for external function call")
+            raise GsTaichiSyntaxError("Unsupported arch for external function call")
         _temp_dir = tempfile.mkdtemp()
         _temp_source = os.path.join(_temp_dir, "_temp_source.cpp")
         with open(_temp_source, "w") as f:
@@ -144,7 +144,7 @@ class SourceBuilder:
         if self.mode == "so":
             return external_func_call_wrapper
 
-        raise TaichiSyntaxError("Error occurs when calling external function.")
+        raise GsTaichiSyntaxError("Error occurs when calling external function.")
 
 
 __all__ = []

{taichi → gstaichi}/lang/struct.py

@@ -5,21 +5,21 @@ from types import MethodType
 
 import numpy as np
 
-from taichi._lib import core as _ti_core
-from taichi.lang import expr, impl, ops
-from taichi.lang.exception import (
-    TaichiRuntimeTypeError,
-    TaichiSyntaxError,
-    TaichiTypeError,
+from gstaichi._lib import core as _ti_core
+from gstaichi.lang import expr, impl, ops
+from gstaichi.lang.exception import (
+    GsTaichiRuntimeTypeError,
+    GsTaichiSyntaxError,
+    GsTaichiTypeError,
 )
-from taichi.lang.expr import Expr
-from taichi.lang.field import Field, ScalarField, SNodeHostAccess
-from taichi.lang.matrix import Matrix, MatrixType
-from taichi.lang.util import cook_dtype, in_python_scope, python_scope, taichi_scope
-from taichi.types import primitive_types
-from taichi.types.compound_types import CompoundType
-from taichi.types.enums import Layout
-from taichi.types.utils import is_signed
+from gstaichi.lang.expr import Expr
+from gstaichi.lang.field import Field, ScalarField, SNodeHostAccess
+from gstaichi.lang.matrix import Matrix, MatrixType
+from gstaichi.lang.util import cook_dtype, gstaichi_scope, in_python_scope, python_scope
+from gstaichi.types import primitive_types
+from gstaichi.types.compound_types import CompoundType
+from gstaichi.types.enums import Layout
+from gstaichi.types.utils import is_signed
 
 
 class Struct:
@@ -50,7 +50,7 @@ _
         dict_items([('v', [0. 0. 0.]), ('t', 1.0), ('A', {'v': [[0.], [0.], [0.]], 't': 1.0})])
     """
 
-    _is_taichi_class = True
+    _is_gstaichi_class = True
     _instance_count = 0
 
     def __init__(self, *args, **kwargs):
@@ -60,7 +60,7 @@ _
         elif len(args) == 0:
             self.__entries = kwargs
         else:
-            raise TaichiSyntaxError(
+            raise GsTaichiSyntaxError(
                 "Custom structs need to be initialized using either dictionary or keyword arguments"
             )
         self.__methods = self.__entries.pop("__struct_methods", {})
@@ -171,14 +171,14 @@ _
 
         return setter
 
-    @taichi_scope
+    @gstaichi_scope
     def _assign(self, other):
         if not isinstance(other, (dict, Struct)):
-            raise TaichiTypeError("Only dict or Struct can be assigned to a Struct")
+            raise GsTaichiTypeError("Only dict or Struct can be assigned to a Struct")
         if isinstance(other, dict):
             other = Struct(other)
         if self.__entries.keys() != other.__entries.keys():
-            raise TaichiTypeError(f"Member mismatch between structs {self.keys}, {other.keys}")
+            raise GsTaichiTypeError(f"Member mismatch between structs {self.keys}, {other.keys}")
         for k, v in self.items:
             v._assign(other.__entries[k])
         self.__dtype = other.__dtype
@@ -242,7 +242,7 @@ _
         needs_dual=False,
         layout=Layout.AOS,
     ):
-        """Creates a :class:`~taichi.StructField` with each element
+        """Creates a :class:`~gstaichi.StructField` with each element
         has this struct as its type.
 
         Args:
@@ -280,7 +280,7 @@ _
         """
 
         if shape is None and offset is not None:
-            raise TaichiSyntaxError("shape cannot be None when offset is being set")
+            raise GsTaichiSyntaxError("shape cannot be None when offset is being set")
 
         field_dict = {}
 
@@ -321,7 +321,7 @@ _
                 offset = (offset,)
 
             if offset is not None and len(shape) != len(offset):
-                raise TaichiSyntaxError(
+                raise GsTaichiSyntaxError(
                     f"The dimensionality of shape and offset must be the same ({len(shape)} != {len(offset)})"
                 )
             dim = len(shape)
@@ -365,7 +365,7 @@ class _IntermediateStruct(Struct):
 
 
 class StructField(Field):
-    """Taichi struct field with SNode implementation.
+    """GsTaichi struct field with SNode implementation.
 
        Instead of directly constraining Expr entries, the StructField object
        directly hosts members as `Field` instances to support nested structs.
@@ -463,7 +463,7 @@ class StructField(Field):
         """Gets SNode of representative field member for loop range info.
 
         Returns:
-            taichi_python.SNode: SNode of representative (first) field member.
+            gstaichi_python.SNode: SNode of representative (first) field member.
         """
         return self._members[0]._loop_range()
 
@@ -680,13 +680,13 @@ class StructType(CompoundType):
                     return False
         return True
 
-    def from_taichi_object(self, func_ret, ret_index=()):
+    def from_gstaichi_object(self, func_ret, ret_index=()):
         d = {}
         items = self.members.items()
         for index, pair in enumerate(items):
             name, dtype = pair
             if isinstance(dtype, CompoundType):
-                d[name] = dtype.from_taichi_object(func_ret, ret_index + (index,))
+                d[name] = dtype.from_gstaichi_object(func_ret, ret_index + (index,))
             else:
                 d[name] = expr.Expr(
                     _ti_core.make_get_element_expr(
@@ -717,7 +717,7 @@ class StructType(CompoundType):
                 elif dtype in primitive_types.real_types:
                     d[name] = launch_ctx.get_struct_ret_float(ret_index + (index,))
                 else:
-                    raise TaichiRuntimeTypeError(f"Invalid return type on index={ret_index + (index, )}")
+                    raise GsTaichiRuntimeTypeError(f"Invalid return type on index={ret_index + (index, )}")
         d["__struct_methods"] = self.methods
 
         struct = Struct(d)
@@ -740,7 +740,7 @@ class StructType(CompoundType):
                 elif dtype in primitive_types.real_types:
                     launch_ctx.set_struct_arg_float(ret_index + (index,), struct[name])
                 else:
-                    raise TaichiRuntimeTypeError(f"Invalid argument type on index={ret_index + (index, )}")
+                    raise GsTaichiRuntimeTypeError(f"Invalid argument type on index={ret_index + (index, )}")
 
     def set_argpack_struct_args(self, struct, argpack, ret_index=()):
         # TODO: move this to class Struct after we add dtype to Struct
@@ -758,12 +758,12 @@ class StructType(CompoundType):
                 elif dtype in primitive_types.real_types:
                     argpack.set_arg_float(ret_index + (index,), struct[name])
                 else:
-                    raise TaichiRuntimeTypeError(f"Invalid argument type on index={ret_index + (index, )}")
+                    raise GsTaichiRuntimeTypeError(f"Invalid argument type on index={ret_index + (index, )}")
 
     def cast(self, struct):
         # sanity check members
         if self.members.keys() != struct._Struct__entries.keys():
-            raise TaichiSyntaxError("Incompatible arguments for custom struct members!")
+            raise GsTaichiSyntaxError("Incompatible arguments for custom struct members!")
         entries = {}
         for k, dtype in self.members.items():
             if isinstance(dtype, MatrixType):
@@ -806,7 +806,7 @@ class StructType(CompoundType):
 
 
 def dataclass(cls):
-    """Converts a class with field annotations and methods into a taichi struct type.
+    """Converts a class with field annotations and methods into a gstaichi struct type.
 
     This will return a normal custom struct type, with the functions added to it.
     Struct fields can be generated in the normal way from the struct type.
@@ -834,7 +834,7 @@ def dataclass(cls):
         cls (Class): the class with annotations and methods to convert to a struct
 
     Returns:
-        A taichi struct with the annotations as fields
+        A gstaichi struct with the annotations as fields
             and methods from the class attached.
     """
     # save the annotation fields for the struct
@@ -842,7 +842,7 @@ def dataclass(cls):
     # raise error if there are default values
     for k in fields.keys():
         if hasattr(cls, k):
-            raise TaichiSyntaxError("Default value in @dataclass is not supported.")
+            raise GsTaichiSyntaxError("Default value in @dataclass is not supported.")
     # get the class methods to be attached to the struct types
     fields["__struct_methods"] = {
         attribute: getattr(cls, attribute)