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}/_lib/utils.py

@@ -45,11 +45,11 @@ def import_ti_python_core():
         pyddir = os.path.dirname(os.path.realpath(__file__))
         os.environ["PATH"] += os.pathsep + pyddir
     try:
-        from taichi._lib.core import taichi_python as core  # pylint: disable=C0415
+        from gstaichi._lib.core import gstaichi_python as core  # pylint: disable=C0415
     except Exception as e:
         if isinstance(e, ImportError):
             print(
-                Fore.YELLOW + "Share object taichi_python import failed, "
+                Fore.YELLOW + "Share object gstaichi_python import failed, "
                 "check this page for possible solutions:\n"
                 "https://docs.taichi-lang.org/docs/install" + Fore.RESET
             )
@@ -89,7 +89,7 @@ package_root = os.path.join(os.path.dirname(os.path.dirname(os.path.realpath(__f
 
 def get_core_shared_object():
     directory = os.path.join(package_root, "_lib")
-    return os.path.join(directory, "libtaichi_python.so")
+    return os.path.join(directory, "libgstaichi_python.so")
 
 
 def print_red_bold(*args, **kwargs):
@@ -120,11 +120,11 @@ if log_level:
 
 def get_dll_name(name):
     if get_os_name() == "linux":
-        return f"libtaichi_{name}.so"
+        return f"libgstaichi_{name}.so"
     if get_os_name() == "osx":
-        return f"libtaichi_{name}.dylib"
+        return f"libgstaichi_{name}.dylib"
     if get_os_name() == "win":
-        return f"taichi_{name}.dll"
+        return f"gstaichi_{name}.dll"
     raise Exception(f"Unknown OS: {get_os_name()}")
 
 
@@ -141,8 +141,8 @@ def compare_version(latest, current):
     return tuple(latest_num) > tuple(current_num)
 
 
-def _print_taichi_header():
-    header = "[Taichi] "
+def _print_gstaichi_header():
+    header = "[GsTaichi] "
     header += f"version {ti_python_core.get_version_string()}, "
 
     try:
@@ -171,8 +171,8 @@ def _print_taichi_header():
     print(header)
 
 
-if os.getenv("ENABLE_TAICHI_HEADER_PRINT", "True").lower() not in ("false", "0", "f"):
-    _print_taichi_header()
+if os.getenv("ENABLE_GSTAICHI_HEADER_PRINT", "True").lower() not in ("false", "0", "f"):
+    _print_gstaichi_header()
 
 
 def try_get_wheel_tag(module):
@@ -218,28 +218,28 @@ def warn_restricted_version():
 
     if get_os_name() == "linux":
         try:
-            import taichi as ti  # pylint: disable=import-outside-toplevel
+            import gstaichi as ti  # pylint: disable=import-outside-toplevel
 
             wheel_tag = try_get_wheel_tag(ti)
             if wheel_tag and "manylinux2014" in wheel_tag:
                 print_yellow_bold(
-                    "You have installed a restricted version of taichi, certain features (e.g. Vulkan & GGUI) will not work."
+                    "You have installed a restricted version of gstaichi, certain features (e.g. Vulkan & GGUI) will not work."
                 )
                 libc_ver = try_get_loaded_libc_version()
                 if libc_ver and libc_ver < (2, 27):
                     print_yellow_bold(
-                        "!! Taichi requires glibc >= 2.27 to run, please try upgrading your OS to a recent one (e.g. Ubuntu 18.04 or later) if possible."
+                        "!! GsTaichi requires glibc >= 2.27 to run, please try upgrading your OS to a recent one (e.g. Ubuntu 18.04 or later) if possible."
                     )
 
                 pip_ver = try_get_pip_version()
                 if pip_ver and pip_ver < (20, 3, 0):
                     print_yellow_bold(
                         f"!! Your pip (version {'.'.join(map(str, pip_ver))}) is outdated (20.3.0 or later required), "
-                        "try upgrading pip and install taichi again."
+                        "try upgrading pip and install gstaichi again."
                     )
                     print()
                     print_yellow_bold("    $ python3 -m pip install --upgrade pip")
-                    print_yellow_bold("    $ python3 -m pip install --force-reinstall taichi")
+                    print_yellow_bold("    $ python3 -m pip install --force-reinstall gstaichi")
                     print()
 
                 print_yellow_bold(

{taichi → gstaichi}/_logging.py

@@ -3,7 +3,7 @@
 import inspect
 import os
 
-from taichi._lib import core as ti_python_core
+from gstaichi._lib import core as ti_python_core
 
 
 def _get_logging(name):

{taichi → gstaichi}/_main.py

@@ -16,10 +16,10 @@ import rich
 from colorama import Fore
 from rich.console import Console
 
-from taichi._lib import core as _ti_core
-from taichi._lib import utils
-from taichi.lang import impl
-from taichi.tools import diagnose
+from gstaichi._lib import core as _ti_core
+from gstaichi._lib import utils
+from gstaichi.lang import impl
+from gstaichi.tools import diagnose
 
 
 def timer(func):
@@ -53,14 +53,14 @@ def register(func):
 
 
 @registerableCLI
-class TaichiMain:
+class GsTaichiMain:
     def __init__(self, test_mode: bool = False):
-        self.banner = f"\n{'*' * 43}\n**      Taichi Programming Language      **\n{'*' * 43}"
+        self.banner = f"\n{'*' * 43}\n**      GsTaichi Programming Language      **\n{'*' * 43}"
         print(self.banner)
 
         print(self._get_friend_links())
 
-        parser = argparse.ArgumentParser(description="Taichi CLI", usage=self._usage())
+        parser = argparse.ArgumentParser(description="GsTaichi CLI", usage=self._usage())
         parser.add_argument("command", help="command from the above list to run")
 
         # Flag for unit testing
@@ -81,7 +81,7 @@ class TaichiMain:
         if args.command not in self.registered_commands:  # pylint: disable=E1101
             # TODO: do we really need this?
             if args.command.endswith(".py"):
-                TaichiMain._exec_python_file(args.command)
+                GsTaichiMain._exec_python_file(args.command)
             else:
                 print(f"{args.command} is not a valid command!")
                 self.main_parser.print_help()
@@ -94,8 +94,8 @@ class TaichiMain:
         return (
             "\n"
             "Docs:   https://docs.taichi-lang.org/\n"
-            "GitHub: https://github.com/taichi-dev/taichi/\n"
-            "Forum:  https://forum.taichi.graphics/\n"
+            "GitHub: https://github.com/taichi-dev/gstaichi/\n"
+            "Forum:  https://forum.gstaichi.graphics/\n"
         )
 
     def _usage(self) -> str:
@@ -124,7 +124,7 @@ class TaichiMain:
     @staticmethod
     def _get_available_examples() -> set:
         """Get a set of all available example names."""
-        examples_dir = TaichiMain._get_examples_dir()
+        examples_dir = GsTaichiMain._get_examples_dir()
         all_examples = examples_dir.rglob("*.py")
         all_example_names = {f.stem: f.parent for f in all_examples}
         return all_example_names
@@ -158,11 +158,11 @@ class TaichiMain:
             box=rich.box.HORIZONTALS,
             show_header=False,
             header_style="bold #2070b2",
-            title="[bold][#3fdda4]TAICHI[#f8e020] EXAMPLES",
+            title="[bold][#3fdda4]GSTAICHI[#f8e020] EXAMPLES",
         )
 
         ncols = 3
-        choices = TaichiMain._get_available_examples()
+        choices = GsTaichiMain._get_available_examples()
         nrows, rem = divmod(len(choices), ncols)
         if rem > 0:
             nrows += 1
@@ -173,7 +173,7 @@ class TaichiMain:
         parser = argparse.ArgumentParser(prog="ti example", description=f"{self.example.__doc__}")
         parser.add_argument(
             "name",
-            type=TaichiMain._example_choices_type(choices.keys()),
+            type=GsTaichiMain._example_choices_type(choices.keys()),
             choices=sorted(choices.keys()),
             help=console.print(table),
             nargs="?",
@@ -208,7 +208,7 @@ class TaichiMain:
         # TODO: Pass the arguments to downstream correctly(#3216).
         args = parser.parse_args(arguments)
 
-        examples_dir = TaichiMain._get_examples_dir()
+        examples_dir = GsTaichiMain._get_examples_dir()
         example_name = args.name
         if example_name is None:
             try:
@@ -382,9 +382,9 @@ class TaichiMain:
         if self.test_mode:
             return args
 
-        baseline_dir = TaichiMain._get_benchmark_baseline_dir()
-        output_dir = TaichiMain._get_benchmark_output_dir()
-        TaichiMain._display_benchmark_regression(baseline_dir, output_dir, args)
+        baseline_dir = GsTaichiMain._get_benchmark_baseline_dir()
+        output_dir = GsTaichiMain._get_benchmark_output_dir()
+        GsTaichiMain._display_benchmark_regression(baseline_dir, output_dir, args)
 
         return None
 
@@ -398,8 +398,8 @@ class TaichiMain:
         if self.test_mode:
             return args
 
-        baseline_dir = TaichiMain._get_benchmark_baseline_dir()
-        output_dir = TaichiMain._get_benchmark_output_dir()
+        baseline_dir = GsTaichiMain._get_benchmark_baseline_dir()
+        output_dir = GsTaichiMain._get_benchmark_output_dir()
         shutil.rmtree(baseline_dir, True)
         shutil.copytree(output_dir, baseline_dir)
         print(f"[benchmark] baseline data saved to {baseline_dir}")
@@ -417,7 +417,7 @@ class TaichiMain:
         parser = argparse.ArgumentParser(prog="ti run", description=f"{self.run.__doc__}")
         parser.add_argument(
             "filename",
-            help="A single (Python) script to run with Taichi, e.g. render.py",
+            help="A single (Python) script to run with GsTaichi, e.g. render.py",
         )
         args = parser.parse_args(arguments)
 
@@ -459,7 +459,7 @@ class TaichiMain:
     @staticmethod
     @register
     def repl(arguments: list = sys.argv[2:]):
-        """Start Taichi REPL / Python shell with 'import taichi as ti'"""
+        """Start GsTaichi REPL / Python shell with 'import gstaichi as ti'"""
 
         def local_scope():
             try:
@@ -477,7 +477,7 @@ class TaichiMain:
     @staticmethod
     @register
     def lint(arguments: list = sys.argv[2:]):
-        """Run pylint checker for the Python codebase of Taichi"""
+        """Run pylint checker for the Python codebase of GsTaichi"""
         # TODO: support arguments for lint specific files
         # parser = argparse.ArgumentParser(prog='ti lint', description=f"{self.lint.__doc__}")
         # args = parser.parse_args(arguments)
@@ -495,13 +495,6 @@ class TaichiMain:
 
         pylint.lint.Run(options)
 
-    @register
-    def module(self, arguments: list = sys.argv[2:]):
-        """Taichi module tools"""
-        from taichi import _ti_module  # pylint: disable=C0415
-
-        _ti_module._main(arguments)
-
     @staticmethod
     @register
     def cache(arguments: list = sys.argv[2:]):
@@ -544,7 +537,7 @@ class TaichiMain:
 
 
 def main():
-    cli = TaichiMain()
+    cli = GsTaichiMain()
     return cli()
 
 

gstaichi/_snode/__init__.py

@@ -0,0 +1,5 @@
+# type: ignore
+
+from gstaichi._snode.fields_builder import FieldsBuilder
+
+__all__ = ["FieldsBuilder"]

{taichi → gstaichi}/_snode/fields_builder.py

@@ -2,12 +2,12 @@
 
 from typing import Any, Optional, Sequence, Union
 
-from taichi._lib import core as _ti_core
-from taichi._lib.core.taichi_python import SNode as SNodeCxx
-from taichi._snode.snode_tree import SNodeTree
-from taichi.lang import impl, snode
-from taichi.lang.exception import TaichiRuntimeError
-from taichi.lang.util import warning
+from gstaichi._lib import core as _ti_core
+from gstaichi._lib.core.gstaichi_python import SNodeCxx
+from gstaichi._snode.snode_tree import SNodeTree
+from gstaichi.lang import impl, snode
+from gstaichi.lang.exception import GsTaichiRuntimeError
+from gstaichi.lang.util import warning
 
 _snode_registry = _ti_core.SNodeRegistry()
 
@@ -61,7 +61,7 @@ class FieldsBuilder:
 
     # TODO: move this to SNodeTree class.
     def deactivate_all(self):
-        """Same as :func:`taichi.lang.snode.SNode.deactivate_all`"""
+        """Same as :func:`gstaichi.lang.snode.SNode.deactivate_all`"""
         if self.finalized:
             self.root.deactivate_all()
         else:
@@ -72,7 +72,7 @@ class FieldsBuilder:
         indices: Union[Sequence[_Axis], _Axis],
         dimensions: Union[Sequence[int], int],
     ):
-        """Same as :func:`taichi.lang.snode.SNode.dense`"""
+        """Same as :func:`gstaichi.lang.snode.SNode.dense`"""
         self._check_not_finalized()
         self.empty = False
         return self.root.dense(indices, dimensions)
@@ -82,15 +82,15 @@ class FieldsBuilder:
         indices: Union[Sequence[_Axis], _Axis],
         dimensions: Union[Sequence[int], int],
     ):
-        """Same as :func:`taichi.lang.snode.SNode.pointer`"""
+        """Same as :func:`gstaichi.lang.snode.SNode.pointer`"""
         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.")
         self._check_not_finalized()
         self.empty = False
         return self.root.pointer(indices, dimensions)
 
     def _hash(self, indices, dimensions):
-        """Same as :func:`taichi.lang.snode.SNode.hash`"""
+        """Same as :func:`gstaichi.lang.snode.SNode.hash`"""
         raise NotImplementedError()
 
     def dynamic(
@@ -99,16 +99,16 @@ class FieldsBuilder:
         dimension: Union[Sequence[int], int],
         chunk_size: Optional[int] = None,
     ):
-        """Same as :func:`taichi.lang.snode.SNode.dynamic`"""
+        """Same as :func:`gstaichi.lang.snode.SNode.dynamic`"""
         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.")
 
         if dimension >= 2**31:
-            raise TaichiRuntimeError(
+            raise GsTaichiRuntimeError(
                 f"The maximum dimension of a dynamic SNode cannot exceed the maximum value of a 32-bit signed integer: Got {dimension} > 2**31-1"
             )
         if chunk_size is not None and chunk_size >= 2**31:
-            raise TaichiRuntimeError(
+            raise GsTaichiRuntimeError(
                 f"Chunk size cannot exceed the maximum value of a 32-bit signed integer: Got {chunk_size} > 2**31-1"
             )
 
@@ -121,9 +121,9 @@ class FieldsBuilder:
         indices: Union[Sequence[_Axis], _Axis],
         dimensions: Union[Sequence[int], int],
     ):
-        """Same as :func:`taichi.lang.snode.SNode.bitmasked`"""
+        """Same as :func:`gstaichi.lang.snode.SNode.bitmasked`"""
         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.")
         self._check_not_finalized()
         self.empty = False
         return self.root.bitmasked(indices, dimensions)
@@ -134,32 +134,32 @@ class FieldsBuilder:
         dimensions: Union[Sequence[int], int],
         max_num_bits: int,
     ):
-        """Same as :func:`taichi.lang.snode.SNode.quant_array`"""
+        """Same as :func:`gstaichi.lang.snode.SNode.quant_array`"""
         self._check_not_finalized()
         self.empty = False
         return self.root.quant_array(indices, dimensions, max_num_bits)
 
     def place(self, *args: Any, offset: Optional[Union[Sequence[int], int]] = None):
-        """Same as :func:`taichi.lang.snode.SNode.place`"""
+        """Same as :func:`gstaichi.lang.snode.SNode.place`"""
         self._check_not_finalized()
         self.empty = False
         self.root.place(*args, offset=offset)
 
     def lazy_grad(self):
-        """Same as :func:`taichi.lang.snode.SNode.lazy_grad`"""
+        """Same as :func:`gstaichi.lang.snode.SNode.lazy_grad`"""
         # TODO: This complicates the implementation. Figure out why we need this
         self._check_not_finalized()
         self.empty = False
         self.root.lazy_grad()
 
     def _allocate_adjoint_checkbit(self):
-        """Same as :func:`taichi.lang.snode.SNode._allocate_adjoint_checkbit`"""
+        """Same as :func:`gstaichi.lang.snode.SNode._allocate_adjoint_checkbit`"""
         self._check_not_finalized()
         self.empty = False
         self.root._allocate_adjoint_checkbit()
 
     def lazy_dual(self):
-        """Same as :func:`taichi.lang.snode.SNode.lazy_dual`"""
+        """Same as :func:`gstaichi.lang.snode.SNode.lazy_dual`"""
         # TODO: This complicates the implementation. Figure out why we need this
         self._check_not_finalized()
         self.empty = False
@@ -172,18 +172,16 @@ class FieldsBuilder:
             raise_warning (bool): Raise warning or not."""
         return self._finalize(raise_warning, compile_only=False)
 
-    def _finalize_for_aot(self):
-        """Constructs the SNodeTree and compiles the type for AOT purpose."""
-        return self._finalize(raise_warning=False, compile_only=True)
-
-    def _finalize(self, raise_warning, compile_only):
+    def _finalize(self, raise_warning, compile_only) -> SNodeTree:
         self._check_not_finalized()
         if self.empty and raise_warning:
             warning("Finalizing an empty FieldsBuilder!")
         self.finalized = True
         impl.get_runtime().finalize_fields_builder(self)
-        return SNodeTree(_ti_core.finalize_snode_tree(_snode_registry, self.ptr, impl.get_runtime().prog, compile_only))
+        return SNodeTree(
+            _ti_core.finalize_snode_tree(_snode_registry, self.ptr, impl.get_runtime()._prog, compile_only)
+        )
 
     def _check_not_finalized(self):
         if self.finalized:
-            raise TaichiRuntimeError("FieldsBuilder finalized")
+            raise GsTaichiRuntimeError("FieldsBuilder finalized")

{taichi → gstaichi}/_snode/snode_tree.py

@@ -1,12 +1,12 @@
 # type: ignore
 
-# The reason we import just the taichi.core.util module, instead of the ti_python_core
+# The reason we import just the gstaichi.core.util module, instead of the ti_python_core
 # object within it, is that ti_python_core is stateful. While in practice ti_python_core is
 # loaded during the import procedure, it's probably still good to delay the
 # access to it.
 
-from taichi.lang import impl
-from taichi.lang.exception import TaichiRuntimeError
+from gstaichi.lang import impl
+from gstaichi.lang.exception import GsTaichiRuntimeError
 
 
 class SNodeTree:
@@ -17,7 +17,7 @@ class SNodeTree:
 
     def destroy(self):
         if self.destroyed:
-            raise TaichiRuntimeError("SNode tree has been destroyed")
+            raise GsTaichiRuntimeError("SNode tree has been destroyed")
         if self.prog != impl.get_runtime().prog:
             return
         self.ptr.destroy_snode_tree(impl.get_runtime().prog)
@@ -30,5 +30,5 @@ class SNodeTree:
     @property
     def id(self):
         if self.destroyed:
-            raise TaichiRuntimeError("SNode tree has been destroyed")
+            raise GsTaichiRuntimeError("SNode tree has been destroyed")
         return self.ptr.id()

gstaichi/_test_tools/load_kernel_string.py

@@ -0,0 +1,30 @@
+import importlib.util
+import sys
+import tempfile
+from contextlib import contextmanager
+from pathlib import Path
+
+
+def import_kernel_from_file(kernel_filepath: Path, kernel_name: str):
+    spec = importlib.util.spec_from_file_location(kernel_name, kernel_filepath)
+    assert spec is not None
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[kernel_name] = module
+    loader = spec.loader
+    assert loader is not None
+    loader.exec_module(module)
+    return getattr(module, kernel_name)
+
+
+@contextmanager
+def load_kernel_from_string(kernel_str: str, kernel_name: str):
+    with tempfile.TemporaryDirectory() as temp_dir:
+        filepath = Path(temp_dir) / f"{kernel_name}.py"
+        with open(filepath, "w") as f:
+            f.write(kernel_str)
+        try:
+            kernel = import_kernel_from_file(kernel_filepath=filepath, kernel_name=kernel_name)
+            yield kernel
+        finally:
+            if kernel_name in sys.modules:
+                del sys.modules[kernel_name]

gstaichi/_version.py

@@ -0,0 +1 @@
+__version__ = '0.1.25.dev0'

{taichi → gstaichi}/_version_check.py

@@ -8,11 +8,11 @@ import threading
 import uuid
 from urllib import request
 
-from taichi._lib import core as _ti_core
+from gstaichi._lib import core as _ti_core
 
 
 def check_version(cur_uuid):
-    # Check Taichi version for the user.
+    # Check GsTaichi version for the user.
     major = _ti_core.get_version_major()
     minor = _ti_core.get_version_minor()
     patch = _ti_core.get_version_patch()
@@ -20,8 +20,11 @@ def check_version(cur_uuid):
     payload = {"version": version, "platform": "", "python": ""}
 
     system = platform.system()
-    if system == "Linux":
+    u = platform.uname()
+    if (u.system, u.machine) == ("Linux", "x86_64"):
         payload["platform"] = "manylinux_2_27_x86_64"
+    elif (u.system, u.machine) in (("Linux", "arm64"), ("Linux", "aarch64")):
+        payload["platform"] = "manylinux_2_27_aarch64"
     elif system == "Windows":
         payload["platform"] = "win_amd64"
     elif system == "Darwin":
@@ -38,11 +41,11 @@ def check_version(cur_uuid):
     payload["uuid"] = cur_uuid
     if os.getenv("TI_CI") == "1":
         payload["type"] = "CI"
-    # We do not want request exceptions break users' usage of Taichi.
+    # We do not want request exceptions break users' usage of GsTaichi.
     try:
         payload = json.dumps(payload)
         payload = payload.encode()
-        req = request.Request("https://metadata.taichi.graphics/check_version", method="POST")
+        req = request.Request("https://metadata.gstaichi.graphics/check_version", method="POST")
         req.add_header("Content-Type", "application/json")
         with request.urlopen(req, data=payload, timeout=5) as response:
             response = json.loads(response.read().decode("utf-8"))

gstaichi/ad/__init__.py

@@ -0,0 +1,3 @@
+# type: ignore
+
+from gstaichi.ad._ad import *

{taichi → gstaichi}/ad/_ad.py

@@ -1,6 +1,6 @@
 # type: ignore
 
-"""Taichi automatic differentiation module.
+"""GsTaichi automatic differentiation module.
 
 This module supplies two decorators for users to customize their
 gradient computation task.
@@ -11,16 +11,16 @@ from functools import reduce
 
 import numpy as np
 
-import taichi.types.primitive_types as types
-from taichi import _snode
-from taichi.lang import impl
-from taichi.lang._ndarray import Ndarray
-from taichi.lang.expr import Expr
-from taichi.lang.field import Field, ScalarField
-from taichi.lang.kernel_impl import kernel
-from taichi.lang.snode import SNode
-from taichi.types import ndarray, template
-from taichi.types.enums import AutodiffMode, SNodeGradType
+import gstaichi.types.primitive_types as types
+from gstaichi import _snode
+from gstaichi.lang import impl
+from gstaichi.lang._ndarray import Ndarray
+from gstaichi.lang.expr import Expr
+from gstaichi.lang.field import Field, ScalarField
+from gstaichi.lang.kernel_impl import kernel
+from gstaichi.lang.snode import SNode
+from gstaichi.types import ndarray, template
+from gstaichi.types.enums import AutodiffMode, SNodeGradType
 
 
 class GradChecker:
@@ -140,19 +140,19 @@ def restore_all_fields(all_fields, backups):
 
 class Tape:
     def __init__(self, loss=None, clear_gradients=True, validation=False, grad_check=None):
-        """A context manager for reverse mode autodiff :class:`~taichi.ad.Tape`. The
+        """A context manager for reverse mode autodiff :class:`~gstaichi.ad.Tape`. The
         context manager would catching all of the callings of functions that
-        decorated by :func:`~taichi.lang.kernel_impl.kernel` or
-        :func:`~taichi.ad.grad_replaced` under `with` statement, and calculate
+        decorated by :func:`~gstaichi.lang.kernel_impl.kernel` or
+        :func:`~gstaichi.ad.grad_replaced` under `with` statement, and calculate
         all the partial gradients of a given loss variable by calling all of the
         gradient function of the callings caught in reverse order while `with`
         statement ended.
 
-        See also :func:`~taichi.lang.kernel_impl.kernel` and
-        :func:`~taichi.ad.grad_replaced` for gradient functions.
+        See also :func:`~gstaichi.lang.kernel_impl.kernel` and
+        :func:`~gstaichi.ad.grad_replaced` for gradient functions.
 
         Args:
-            loss(:class:`~taichi.lang.expr.Expr`): The loss field, which shape should be ().
+            loss(:class:`~gstaichi.lang.expr.Expr`): The loss field, which shape should be ().
             clear_gradients(Bool): Before `with` body start, clear all gradients or not.
             validation(Bool): Check whether the code inside the context manager is autodiff valid, e.g., agree with the global data access rule.
             grad_check(List[Field]): List of fields that need to check gradients.
@@ -293,7 +293,7 @@ def clear_all_gradients(gradient_type=SNodeGradType.ADJOINT):
 
         places = tuple(places)
         if places:
-            from taichi._kernels import clear_gradients  # pylint: disable=C0415
+            from gstaichi._kernels import clear_gradients  # pylint: disable=C0415
 
             clear_gradients(places)
 
@@ -302,12 +302,12 @@ def clear_all_gradients(gradient_type=SNodeGradType.ADJOINT):
 
 
 def grad_replaced(func):
-    """A decorator for python function to customize gradient with Taichi's autodiff
+    """A decorator for python function to customize gradient with GsTaichi's autodiff
     system, e.g. `ti.ad.Tape()` and `kernel.grad()`.
 
-    This decorator forces Taichi's autodiff system to use a user-defined gradient
+    This decorator forces GsTaichi's autodiff system to use a user-defined gradient
     function for the decorated function. Its customized gradient must be decorated
-    by :func:`~taichi.ad.grad_for`.
+    by :func:`~gstaichi.ad.grad_for`.
 
     Args:
         fn (Callable): The python function to be decorated.
@@ -353,10 +353,10 @@ def grad_replaced(func):
 def grad_for(primal):
     """Generates a decorator to decorate `primal`'s customized gradient function.
 
-    See :func:`~taichi.lang.grad_replaced` for examples.
+    See :func:`~gstaichi.lang.grad_replaced` for examples.
 
     Args:
-        primal (Callable): The primal function, must be decorated by :func:`~taichi.ad.grad_replaced`.
+        primal (Callable): The primal function, must be decorated by :func:`~gstaichi.ad.grad_replaced`.
 
     Returns:
         Callable: The decorator used to decorate customized gradient function."""
@@ -369,7 +369,7 @@ def grad_for(primal):
             raise RuntimeError(f"Primal function `{primal.__name__}` must be decorated by ti.ad.grad_replaced")
         if primal.grad is not None:
             raise RuntimeError(
-                "Primal function must be a **python** function instead of a taichi kernel. Please wrap the taichi kernel in a @ti.ad.grad_replaced decorated python function instead."
+                "Primal function must be a **python** function instead of a gstaichi kernel. Please wrap the gstaichi kernel in a @ti.ad.grad_replaced decorated python function instead."
             )
         primal.grad = decorated
         return decorated
@@ -378,9 +378,9 @@ def grad_for(primal):
 
 
 def no_grad(func):
-    """A decorator for python function to skip gradient calculation within Taichi's
+    """A decorator for python function to skip gradient calculation within GsTaichi's
     autodiff system, e.g. `ti.ad.Tape()` and `kernel.grad()`.
-    This decorator forces Taichi's autodiff system to use an empty gradient function
+    This decorator forces GsTaichi's autodiff system to use an empty gradient function
     for the decorated function.
 
     Args: