gstaichi 0.1.23.dev0__cp310-cp310-win_amd64.whl → 0.1.25.dev0__cp310-cp310-win_amd64.whl

{taichi → gstaichi}/sparse/_sparse_grid.py

@@ -1,12 +1,12 @@
 # type: ignore
 
-from taichi.lang.impl import grouped, root, static
-from taichi.lang.kernel_impl import kernel
-from taichi.lang.misc import ij, ijk
-from taichi.lang.snode import is_active
-from taichi.lang.struct import Struct
-from taichi.types.annotations import template
-from taichi.types.primitive_types import f32
+from gstaichi.lang.impl import grouped, root, static
+from gstaichi.lang.kernel_impl import kernel
+from gstaichi.lang.misc import ij, ijk
+from gstaichi.lang.snode import is_active
+from gstaichi.lang.struct import Struct
+from gstaichi.types.annotations import template
+from gstaichi.types.primitive_types import f32
 
 
 def grid(field_dict, shape):

{taichi → gstaichi}/tools/__init__.py

@@ -1,12 +1,12 @@
 # type: ignore
 
-"""Taichi utility module.
+"""GsTaichi utility module.
 
 - `image` submodule for image io.
 - `video` submodule for exporting results to video files.
 - `diagnose` submodule for printing system environment information.
 """
 
-from taichi.tools.diagnose import *
-from taichi.tools.np2ply import *
-from taichi.tools.vtk import *
+from gstaichi.tools.diagnose import *
+from gstaichi.tools.np2ply import *
+from gstaichi.tools.vtk import *

{taichi → gstaichi}/tools/diagnose.py

@@ -8,7 +8,7 @@ import sys
 
 
 def main():
-    print("Taichi system diagnose:")
+    print("GsTaichi system diagnose:")
     print("")
     executable = sys.executable
 
@@ -38,7 +38,7 @@ def main():
 
     def try_print(tag, expr):
         try:
-            cmd = f'import taichi as ti; print("===="); print({expr}, end="")'
+            cmd = f'import gstaichi as ti; print("===="); print({expr}, end="")'
             ret = subprocess.check_output([executable, "-c", cmd]).decode()
             ret = ret.split("====" + os.linesep, maxsplit=1)[1]
             print(f"{tag}: {ret}")
@@ -48,7 +48,7 @@ def main():
     print("")
     try_print("import", "ti")
     print("")
-    for arch in ["cpu", "metal", "opengl", "cuda", "vulkan"]:
+    for arch in ["cpu", "metal", "cuda", "vulkan"]:
         try_print(arch, f"ti.lang.misc.is_arch_supported(ti.{arch})")
     print("")
 
@@ -81,37 +81,30 @@ def main():
         print(f"{nvidia_smi.decode()}")
 
     try:
-        ti_header = subprocess.check_output([executable, "-c", "import taichi"])
+        ti_header = subprocess.check_output([executable, "-c", "import gstaichi"])
     except Exception as e:
-        print(f"`import taichi` failed: {e}")
+        print(f"`import gstaichi` failed: {e}")
     else:
         print(f"{ti_header.decode()}")
 
     try:
-        ti_init_test = subprocess.check_output([executable, "-c", "import taichi as ti; ti.init()"])
+        ti_init_test = subprocess.check_output([executable, "-c", "import gstaichi as ti; ti.init()"])
     except Exception as e:
         print(f"`ti.init()` failed: {e}")
     else:
         print(f"{ti_init_test.decode()}")
 
     try:
-        ti_opengl_test = subprocess.check_output([executable, "-c", "import taichi as ti; ti.init(arch=ti.opengl)"])
+        ti_cuda_test = subprocess.check_output([executable, "-c", "import gstaichi as ti; ti.init(arch=ti.cuda)"])
     except Exception as e:
-        print(f"Taichi OpenGL test failed: {e}")
-    else:
-        print(f"{ti_opengl_test.decode()}")
-
-    try:
-        ti_cuda_test = subprocess.check_output([executable, "-c", "import taichi as ti; ti.init(arch=ti.cuda)"])
-    except Exception as e:
-        print(f"Taichi CUDA test failed: {e}")
+        print(f"GsTaichi CUDA test failed: {e}")
     else:
         print(f"{ti_cuda_test.decode()}")
 
     try:
-        ti_laplace = subprocess.check_output([executable, "-m", "taichi", "example", "minimal"])
+        ti_laplace = subprocess.check_output([executable, "-m", "gstaichi", "example", "minimal"])
     except Exception as e:
-        print(f"`python/taichi/examples/algorithm/laplace.py` failed: {e}")
+        print(f"`python/gstaichi/examples/algorithm/laplace.py` failed: {e}")
     else:
         print(f"{ti_laplace.decode()}")
 

gstaichi/types/__init__.py

@@ -0,0 +1,19 @@
+# type: ignore
+
+"""
+This module defines data types in GsTaichi:
+
+- primitive: int, float, etc.
+- compound: matrix, vector, struct.
+- template: for reference types.
+- ndarray: for arbitrary arrays.
+- quant: for quantized types, see "https://yuanming.gstaichi.graphics/publication/2021-quangstaichi/quangstaichi.pdf"
+"""
+
+from gstaichi.types import quant
+from gstaichi.types.annotations import *
+from gstaichi.types.compound_types import *
+from gstaichi.types.ndarray_type import *
+from gstaichi.types.primitive_types import *
+from gstaichi.types.texture_type import *
+from gstaichi.types.utils import *

{taichi → gstaichi}/types/annotations.py

@@ -36,7 +36,7 @@ class Template:
 
 
 template = Template
-"""Alias for :class:`~taichi.types.annotations.Template`.
+"""Alias for :class:`~gstaichi.types.annotations.Template`.
 """
 
 

{taichi → gstaichi}/types/compound_types.py

@@ -1,7 +1,7 @@
 # type: ignore
 
-import taichi
-from taichi._lib.utils import ti_python_core as _ti_python_core
+import gstaichi
+from gstaichi._lib.utils import ti_python_core as _ti_python_core
 
 _type_factory = _ti_python_core.get_type_factory_instance()
 
@@ -18,7 +18,7 @@ def matrix(n=None, m=None, dtype=None):
     Args:
         n (int): number of rows of the matrix.
         m (int): number of columns of the matrix.
-        dtype (:mod:`~taichi.types.primitive_types`): matrix data type.
+        dtype (:mod:`~gstaichi.types.primitive_types`): matrix data type.
 
     Returns:
         A matrix type.
@@ -28,7 +28,7 @@ def matrix(n=None, m=None, dtype=None):
         >>> mat2x2 = ti.types.matrix(2, 2, ti.f32)  # 2x2 matrix type
         >>> M = mat2x2([[1., 2.], [3., 4.]])  # an instance of this type
     """
-    return taichi.lang.matrix.MatrixType(n, m, 2, dtype)
+    return gstaichi.lang.matrix.MatrixType(n, m, 2, dtype)
 
 
 def vector(n=None, dtype=None):
@@ -36,7 +36,7 @@ def vector(n=None, dtype=None):
 
     Args:
         n (int): dimension of the vector.
-        dtype (:mod:`~taichi.types.primitive_types`): vector data type.
+        dtype (:mod:`~gstaichi.types.primitive_types`): vector data type.
 
     Returns:
         A vector type.
@@ -46,7 +46,7 @@ def vector(n=None, dtype=None):
         >>> vec3 = ti.types.vector(3, ti.f32)  # 3d vector type
         >>> v = vec3([1., 2., 3.])  # an instance of this type
     """
-    return taichi.lang.matrix.VectorType(n, dtype)
+    return gstaichi.lang.matrix.VectorType(n, dtype)
 
 
 def struct(**kwargs):
@@ -65,7 +65,7 @@ def struct(**kwargs):
         >>> sphere = ti.types.struct(center=vec3, radius=float)
         >>> s = sphere(center=vec3([0., 0., 0.]), radius=1.0)
     """
-    return taichi.lang.struct.StructType(**kwargs)
+    return gstaichi.lang.struct.StructType(**kwargs)
 
 
 def argpack(**kwargs):
@@ -84,7 +84,7 @@ def argpack(**kwargs):
         >>> sphere = ti.types.argpack(center=vec3, radius=float)
         >>> s = sphere(center=vec3([0., 0., 0.]), radius=1.0)
     """
-    return taichi.lang.argpack.ArgPackType(**kwargs)
+    return gstaichi.lang.argpack.ArgPackType(**kwargs)
 
 
 __all__ = ["matrix", "vector", "struct", "argpack"]

{taichi → gstaichi}/types/enums.py

@@ -1,6 +1,6 @@
 # type: ignore
 
-from taichi._lib import core as _ti_core
+from gstaichi._lib import core as _ti_core
 
 Layout = _ti_core.Layout
 AutodiffMode = _ti_core.AutodiffMode

{taichi → gstaichi}/types/ndarray_type.py

@@ -1,7 +1,7 @@
 # type: ignore
 
-from taichi.types.compound_types import CompoundType, matrix, vector
-from taichi.types.enums import Layout, to_boundary_enum
+from gstaichi.types.compound_types import CompoundType, matrix, vector
+from gstaichi.types.enums import Layout, to_boundary_enum
 
 
 class NdarrayTypeMetadata:
@@ -47,10 +47,10 @@ def _make_matrix_dtype_from_element_shape(element_dim, element_shape, primitive_
 
 
 class NdarrayType:
-    """Type annotation for arbitrary arrays, including external arrays (numpy ndarrays and torch tensors) and Taichi ndarrays.
+    """Type annotation for arbitrary arrays, including external arrays (numpy ndarrays and torch tensors) and GsTaichi ndarrays.
 
-    For external arrays, we treat it as a Taichi data container with Scalar, Vector or Matrix elements.
-    For Taichi vector/matrix ndarrays, we will automatically identify element dimension and their corresponding axis by the dimension of datatype, say scalars, matrices or vectors.
+    For external arrays, we treat it as a GsTaichi data container with Scalar, Vector or Matrix elements.
+    For GsTaichi vector/matrix ndarrays, we will automatically identify element dimension and their corresponding axis by the dimension of datatype, say scalars, matrices or vectors.
     For example, given type annotation `ti.types.ndarray(dtype=ti.math.vec3)`, a numpy array `np.zeros(10, 10, 3)` will be recognized as a 10x10 matrix composed of vec3 elements.
 
     Args:
@@ -100,7 +100,7 @@ class NdarrayType:
         else:
             if self.dtype is not None:
                 # Check dtype match for scalar.
-                from taichi.lang import util  # pylint: disable=C0415
+                from gstaichi.lang import util  # pylint: disable=C0415
 
                 if not util.cook_dtype(self.dtype) == ndarray_type.element_type:
                     raise TypeError(
@@ -129,7 +129,7 @@ class NdarrayType:
 
 ndarray = NdarrayType
 NDArray = NdarrayType
-"""Alias for :class:`~taichi.types.ndarray_type.NdarrayType`.
+"""Alias for :class:`~gstaichi.types.ndarray_type.NdarrayType`.
 
 Example::
 

{taichi → gstaichi}/types/primitive_types.py

@@ -1,6 +1,6 @@
-# type: ignore
+from typing import Union
 
-from taichi._lib import core as ti_python_core
+from gstaichi._lib import core as ti_python_core
 
 # ========================================
 # real types
@@ -14,7 +14,7 @@ float16 = ti_python_core.DataType_f16
 # ----------------------------------------
 
 f16 = float16
-"""Alias for :const:`~taichi.types.primitive_types.float16`
+"""Alias for :const:`~gstaichi.types.primitive_types.float16`
 """
 
 # ----------------------------------------
@@ -26,7 +26,7 @@ float32 = ti_python_core.DataType_f32
 # ----------------------------------------
 
 f32 = float32
-"""Alias for :const:`~taichi.types.primitive_types.float32`
+"""Alias for :const:`~gstaichi.types.primitive_types.float32`
 """
 
 # ----------------------------------------
@@ -38,7 +38,7 @@ float64 = ti_python_core.DataType_f64
 # ----------------------------------------
 
 f64 = float64
-"""Alias for :const:`~taichi.types.primitive_types.float64`
+"""Alias for :const:`~gstaichi.types.primitive_types.float64`
 """
 # ----------------------------------------
 
@@ -54,7 +54,7 @@ int8 = ti_python_core.DataType_i8
 # ----------------------------------------
 
 i8 = int8
-"""Alias for :const:`~taichi.types.primitive_types.int8`
+"""Alias for :const:`~gstaichi.types.primitive_types.int8`
 """
 
 # ----------------------------------------
@@ -66,7 +66,7 @@ int16 = ti_python_core.DataType_i16
 # ----------------------------------------
 
 i16 = int16
-"""Alias for :const:`~taichi.types.primitive_types.int16`
+"""Alias for :const:`~gstaichi.types.primitive_types.int16`
 """
 
 # ----------------------------------------
@@ -78,7 +78,7 @@ int32 = ti_python_core.DataType_i32
 # ----------------------------------------
 
 i32 = int32
-"""Alias for :const:`~taichi.types.primitive_types.int32`
+"""Alias for :const:`~gstaichi.types.primitive_types.int32`
 """
 
 # ----------------------------------------
@@ -90,7 +90,7 @@ int64 = ti_python_core.DataType_i64
 # ----------------------------------------
 
 i64 = int64
-"""Alias for :const:`~taichi.types.primitive_types.int64`
+"""Alias for :const:`~gstaichi.types.primitive_types.int64`
 """
 
 # ----------------------------------------
@@ -108,13 +108,13 @@ uint1 = ti_python_core.DataType_u1
 # ----------------------------------------
 
 u1 = uint1
-"""Alias for :const:`~taichi.types.primitive_types.uint1`
+"""Alias for :const:`~gstaichi.types.primitive_types.uint1`
 """
 
 # ----------------------------------------
 
 u8 = uint8
-"""Alias for :const:`~taichi.types.primitive_types.uint8`
+"""Alias for :const:`~gstaichi.types.primitive_types.uint8`
 """
 
 # ----------------------------------------
@@ -126,7 +126,7 @@ uint16 = ti_python_core.DataType_u16
 # ----------------------------------------
 
 u16 = uint16
-"""Alias for :const:`~taichi.types.primitive_types.uint16`
+"""Alias for :const:`~gstaichi.types.primitive_types.uint16`
 """
 
 # ----------------------------------------
@@ -138,7 +138,7 @@ uint32 = ti_python_core.DataType_u32
 # ----------------------------------------
 
 u32 = uint32
-"""Alias for :const:`~taichi.types.primitive_types.uint32`
+"""Alias for :const:`~gstaichi.types.primitive_types.uint32`
 """
 
 # ----------------------------------------
@@ -150,7 +150,7 @@ uint64 = ti_python_core.DataType_u64
 # ----------------------------------------
 
 u64 = uint64
-"""Alias for :const:`~taichi.types.primitive_types.uint64`
+"""Alias for :const:`~gstaichi.types.primitive_types.uint64`
 """
 
 # ----------------------------------------
@@ -174,6 +174,8 @@ integer_type_ids = [id(t) for t in integer_types]
 all_types = real_types + integer_types
 type_ids = [id(t) for t in all_types]
 
+_python_primitive_types = Union[int, float, bool, str, None]
+
 __all__ = [
     "float32",
     "f32",
@@ -200,4 +202,5 @@ __all__ = [
     "uint64",
     "u64",
     "ref",
+    "_python_primitive_types",
 ]

{taichi → gstaichi}/types/quant.py

@@ -2,11 +2,11 @@
 
 """
 This module defines generators of quantized types.
-For more details, read https://yuanming.taichi.graphics/publication/2021-quantaichi/quantaichi.pdf.
+For more details, read https://yuanming.gstaichi.graphics/publication/2021-quangstaichi/quangstaichi.pdf.
 """
 
-from taichi._lib.utils import ti_python_core as _ti_python_core
-from taichi.types.primitive_types import i32
+from gstaichi._lib.utils import ti_python_core as _ti_python_core
+from gstaichi.types.primitive_types import i32
 
 _type_factory = _ti_python_core.get_type_factory_instance()
 
@@ -23,10 +23,10 @@ def int(bits, signed=True, compute=None):  # pylint: disable=W0622
         DataType: The specified type.
     """
     if compute is None:
-        from taichi.lang import impl  # pylint: disable=C0415
+        from gstaichi.lang import impl  # pylint: disable=C0415
 
         compute = impl.get_runtime().default_ip if signed else impl.get_runtime().default_up
-    if isinstance(compute, _ti_python_core.DataType):
+    if isinstance(compute, _ti_python_core.DataTypeCxx):
         compute = compute.get_ptr()
     return _type_factory.get_quant_int_type(bits, signed, compute)
 
@@ -45,10 +45,10 @@ def fixed(bits, signed=True, max_value=1.0, compute=None, scale=None):
         DataType: The specified type.
     """
     if compute is None:
-        from taichi.lang import impl  # pylint: disable=C0415
+        from gstaichi.lang import impl  # pylint: disable=C0415
 
         compute = impl.get_runtime().default_fp
-    if isinstance(compute, _ti_python_core.DataType):
+    if isinstance(compute, _ti_python_core.DataTypeCxx):
         compute = compute.get_ptr()
     # TODO: handle cases with bits > 32
     underlying_type = int(bits=bits, signed=signed, compute=i32)
@@ -73,10 +73,10 @@ def float(exp, frac, signed=True, compute=None):  # pylint: disable=W0622
         DataType: The specified type.
     """
     if compute is None:
-        from taichi.lang import impl  # pylint: disable=C0415
+        from gstaichi.lang import impl  # pylint: disable=C0415
 
         compute = impl.get_runtime().default_fp
-    if isinstance(compute, _ti_python_core.DataType):
+    if isinstance(compute, _ti_python_core.DataTypeCxx):
         compute = compute.get_ptr()
     # Exponent is always unsigned
     exp_type = int(bits=exp, signed=False, compute=i32)

{taichi → gstaichi}/types/texture_type.py

@@ -1,8 +1,8 @@
 # type: ignore
 
-from taichi.lang.exception import TaichiCompilationError
-from taichi.types.enums import Format
-from taichi.types.primitive_types import f16, f32, i8, i16, i32, u8, u16, u32
+from gstaichi.lang.exception import GsTaichiCompilationError
+from gstaichi.types.enums import Format
+from gstaichi.types.primitive_types import f16, f32, i8, i16, i32, u8, u16, u32
 
 FORMAT2TY_CH = {
     Format.r8: (u8, 1),
@@ -71,7 +71,7 @@ class RWTextureType:
     def __init__(self, num_dimensions, lod=0, fmt=None):
         self.num_dimensions = num_dimensions
         if fmt is None:
-            raise TaichiCompilationError("fmt is required for rw_texture type")
+            raise GsTaichiCompilationError("fmt is required for rw_texture type")
         else:
             self.fmt = fmt
         self.lod = lod
@@ -79,7 +79,7 @@ class RWTextureType:
 
 texture = TextureType
 rw_texture = RWTextureType
-"""Alias for :class:`~taichi.types.ndarray_type.TextureType`.
+"""Alias for :class:`~gstaichi.types.ndarray_type.TextureType`.
 """
 
 __all__ = ["texture", "rw_texture"]

{taichi → gstaichi}/types/utils.py

@@ -1,6 +1,6 @@
 # type: ignore
 
-from taichi._lib import core as ti_python_core
+from gstaichi._lib import core as ti_python_core
 
 is_signed = ti_python_core.is_signed
 

{gstaichi-0.1.23.dev0.dist-info → gstaichi-0.1.25.dev0.dist-info}/METADATA

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: gstaichi
-Version: 0.1.23.dev0
-Summary: The Taichi Programming Language
-Home-page: https://github.com/Genesis-Embedded-AI/taichi
-Author: Taichi developers
+Version: 0.1.25.dev0
+Summary: The GsTaichi Programming Language
+Home-page: https://github.com/Genesis-Embedded-AI/gstaichi
+Author: GsTaichi developers
 License: Apache Software License (http://www.apache.org/licenses/LICENSE-2.0)
 Keywords: graphics,simulation
 Classifier: Development Status :: 5 - Production/Stable
@@ -47,16 +47,15 @@ Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 
-# GS-Taichi
+# GsTaichi
 
-[Taichi](https://github.com/taichi-dev/taichi) was forked in June 2025. This repository (or gs-taichi) is now a fully independent project with no intention of maintaining backward compatibility with the original taichi. Whilst the repo largely resembles upstream for now, we have made the following changes:
+[GsTaichi](https://github.com/Genesis-Embodied-AI/gstaichi) was forked in June 2025. This repository (or gstaichi) is now a fully independent project with no intention of maintaining backward compatibility with the original taichi. Whilst the repo largely resembles upstream for now, we have made the following changes:
 - revamped continuous integration, to run using recent python versions (up to 3.13), recent mac os x versions (up to 15), and to run reliably (at least 95% of runs with correct code succeed)
 - added dataclasses.dataclass structs:
     - work with both ndarrays and fields (cf ti.struct (field only), ti.dataclass (field only), ti.data_oriented (field only), argpack (ndarray only))
     - can be passed into child `ti.func`tions (cf argpack)
     - does not affect kernel runtime speed (kernels see only the underlying arrays, no indirection is added within the kernel layer)
-- removed GUI/GGUI
-- upgraded supported OS and Python versions (eg added support for Python 3.13)
+- removed GUI/GGUI, C-API, AOT, DX11, DX12, IOS, Android, OpenGL, GLES
 
 Planned features:
 - reduce warm cache launch latency
@@ -66,19 +65,17 @@ Planned features:
 Planned pruning:
 - remove argpack
 - remove ti CLI
-- remove OpenGL (please use Vulkan)
-- remove mobile device support (Android etc)
 - remove support for NVidia GPUs earlier than sm_60/Pascal
 
-# What is gs-taichi?
+# What is gstaichi?
 
-GS-Taichi is a high performance multi-platform compiler, targeted at physics simulations. It compiles Python code into parallelizable kernels that can run on:
+GsTaichi is a high performance multi-platform compiler, targeted at physics simulations. It compiles Python code into parallelizable kernels that can run on:
 - NVidia GPUs, using CUDA
 - Vulkan-compatible GPUs, using SPIR-V
 - Mac Metal GPUs
 - x86 and arm64 CPUs
 
-GS-Taichi supports automatic differentiation. GS-Taichi lets you build fully fused GPU kernels, using Python.
+GsTaichi supports automatic differentiation. GsTaichi lets you build fully fused GPU kernels, using Python.
 
 [Genesis simulator](https://genesis-world.readthedocs.io/en/latest/)'s best-in-class performance can be largely attributed to Taichi, its underlying GPU acceleration framework for Python. Given how critical is this component, we decided to fork Taichi and build our own very framework from there, so that from now on, we are free to drive its development in the direction that best supports the continuous improvement of Genesis simulator.
 
@@ -89,7 +86,7 @@ GS-Taichi supports automatic differentiation. GS-Taichi lets you build fully fus
 
 ## Procedure
 ```
-pip install gs-taichi
+pip install gstaichi
 ```
 
 (For how to build from source, see our CI build scripts, e.g. [linux build scripts](.github/workflows/scripts_new/linux_x86/) )
@@ -97,11 +94,11 @@ pip install gs-taichi
 # Documentation
 
 - [docs](docs/lang/articles)
-- [API reference](https://ideal-adventure-2n6lpyw.pages.github.io/taichi.html)
+- [API reference](https://ideal-adventure-2n6lpyw.pages.github.io/gstaichi.html)
 
 # Something is broken!
 
-- [Create an issue](https://github.com/Genesis-Embodied-AI/taichi/issues/new/choose)
+- [Create an issue](https://github.com/Genesis-Embodied-AI/gstaichi/issues/new/choose)
 
 # Acknowledgements