diff --git a/python/tvm/ir/module.py b/python/tvm/ir/module.py
index 3b99db85986e..0069e67ee19b 100644
--- a/python/tvm/ir/module.py
+++ b/python/tvm/ir/module.py
@@ -66,6 +66,7 @@ def __init__(self, functions=None, attrs=None, global_infos=None):
             attrs,
             global_infos,
         )
+        self.pyfuncs = {}
 
     def clone(self) -> "IRModule":
         return _ffi_api.Module_Clone(self)
diff --git a/python/tvm/relax/__init__.py b/python/tvm/relax/__init__.py
index b88000119897..a96063c543e0 100644
--- a/python/tvm/relax/__init__.py
+++ b/python/tvm/relax/__init__.py
@@ -98,6 +98,9 @@
 # utils
 from .utils import convert_to_expr
 
+# BasePyModule
+from .base_py_module import BasePyModule
+
 # Import submodules in the last to avoid dependency
 from . import exec_builder
 from . import expr
diff --git a/python/tvm/relax/base_py_module.py b/python/tvm/relax/base_py_module.py
new file mode 100644
index 000000000000..2ef17504c8ba
--- /dev/null
+++ b/python/tvm/relax/base_py_module.py
@@ -0,0 +1,385 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+"""BasePyModule: Base class for IRModules with Python function support."""
+
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+import numpy as np
+import tvm
+from tvm import relax, tir
+from tvm.ir import IRModule
+from tvm.runtime import Device, NDArray, PackedFunc
+from tvm.target import Target
+
+try:
+    from torch.utils.dlpack import to_dlpack as to_dlpack_legacy
+except ImportError:
+    to_dlpack_legacy = None
+
+
+class BasePyModule:
+    """Base class that allows Python functions in IRModule with DLPack conversion.
+
+    This class provides the infrastructure for:
+    1. JIT compilation of TIR and Relax functions.
+    2. DLPack-based conversion between PyTorch tensors and TVM NDArrays.
+    3. Wrapping Relax functions for easy Python calling.
+    4. Cross-function calls between Python, TIR, and Relax functions.
+
+    Only IRModules that inherit from this class are allowed to contain Python functions.
+    """
+
+    def __init__(
+        self,
+        ir_mod: IRModule,
+        device: Device,
+        target: Optional[Target] = None,
+    ):
+        """Initialize BasePyModule with JIT compilation and DLPack conversion."""
+        self.device = device
+        self.ir_mod = ir_mod
+
+        # Delegate IRModule operations
+        self.functions = ir_mod.functions
+        self.attrs = ir_mod.attrs
+        self.global_infos = ir_mod.global_infos
+        self.__getitem__ = ir_mod.__getitem__
+        self.__setitem__ = ir_mod.__setitem__
+        self.functions_items = ir_mod.functions_items
+        self.with_attr = ir_mod.with_attr
+        self.get_attr = ir_mod.get_attr
+        self.update_global_info = ir_mod.update_global_info
+
+        def _getattr_python_function(name: str) -> Any:
+            """Support direct attribute access to funcs and IRModule methods."""
+            if name in self.pyfuncs:
+                return self.pyfuncs[name]
+            if name in self.compiled_tir_funcs:
+                return self.compiled_tir_funcs[name]
+            if self.relax_vm and name in self.relax_func_names:
+                try:
+                    return self.relax_vm[name]
+                except AttributeError:  # More specific exception
+                    return None
+            if hasattr(self.ir_mod, name):
+                return getattr(self.ir_mod, name)
+            raise AttributeError(f"'{type(self).__name__}' object has no attribute '{name}'")
+
+        self.__getattr__ = _getattr_python_function
+
+        self.compiled_tir_funcs: Dict[str, PackedFunc] = {}
+        self.extern_funcs: Dict[str, PackedFunc] = {}
+        self.tir_func_names: List[str] = []
+        self.relax_func_names: List[str] = []
+        self.relax_vm: Optional[relax.VirtualMachine] = None
+        self.pyfuncs: Dict[str, Any] = {}
+
+        if target is None:
+            target = Target.from_device(device)
+        elif isinstance(target, str):
+            target = Target(target)
+        self.target = target
+
+        self._collect_function_names()
+        self._compile_functions()
+        self._wrap_tir_functions()
+        self._wrap_relax_functions()
+
+    def _collect_function_names(self):
+        """Collect names of TIR and Relax functions from IRModule."""
+        for global_var, func in self.ir_mod.functions_items():
+            if isinstance(func, tir.PrimFunc):
+                self.tir_func_names.append(global_var.name_hint)
+            elif isinstance(func, relax.Function):
+                self.relax_func_names.append(global_var.name_hint)
+
+    def _compile_functions(self):
+        """Compile TIR and Relax functions using JIT compilation."""
+        # Compile TIR functions first
+        tir_mod = tvm.IRModule(
+            {
+                gv: func
+                for gv, func in self.ir_mod.functions_items()
+                if isinstance(func, tir.PrimFunc)
+            }
+        )
+        if tir_mod:
+            try:
+                tir_exec_mod = tvm.compile(tir_mod, target=self.target)
+                for func_name in self.tir_func_names:
+                    self.compiled_tir_funcs[func_name] = tir_exec_mod[func_name]
+            # pylint: disable=broad-exception-caught
+            except Exception as error:
+                print(f"Warning: Failed to compile one or more TIR functions: {error}")
+
+        relax_mod = tvm.IRModule(
+            {
+                gv: func
+                for gv, func in self.ir_mod.functions_items()
+                if isinstance(func, relax.Function)
+            }
+        )
+        if relax_mod:
+            try:
+                exec_mod = tvm.compile(self.ir_mod, target=self.target)
+                self.relax_vm = relax.VirtualMachine(exec_mod, self.device)
+            # pylint: disable=broad-exception-caught
+            except Exception as error:
+                print(f"Warning: Failed to compile Relax VM: {error}")
+                self.relax_vm = None
+
+    def _wrap_tir_functions(self):
+        """Wrap TIR functions to make them accessible as instance attributes."""
+        for func_name, func in self.compiled_tir_funcs.items():
+            setattr(self, func_name, func)
+
+    def _wrap_relax_functions(self):
+        """Wrap Relax functions to be callable from Python with auto conversion."""
+        if self.relax_vm is None:
+            return
+
+        for func_name in self.relax_func_names:
+
+            def _create_relax_wrapper(name):
+                def wrapper(*args, **kwargs):
+                    """Wrapper for Relax function with automatic tensor conversion."""
+                    converted_args = self._convert_pytorch_to_tvm(list(args))
+                    converted_kwargs = {
+                        k: self._convert_pytorch_to_tvm(v) for k, v in kwargs.items()
+                    }
+                    result = self.relax_vm[name](*converted_args, **converted_kwargs)
+                    return self._convert_tvm_to_pytorch(result)
+
+                wrapper.__name__ = name
+                wrapper.__doc__ = f"Wrapped Relax function: {name}"
+                return wrapper
+
+            setattr(self, func_name, _create_relax_wrapper(func_name))
+
+    def call_tir(self, tir_func, args, out_sinfo):
+        """Call a TIR function with PyTorch tensors."""
+        # Try to get function name from different sources
+        if isinstance(tir_func, str):
+            func_name = tir_func
+        elif hasattr(tir_func, "name"):
+            func_name = tir_func.name
+        elif hasattr(tir_func, "__name__"):
+            func_name = tir_func.__name__
+        else:
+            # Try to find by function object reference
+            for name, func in self.compiled_tir_funcs.items():
+                if func == tir_func:
+                    func_name = name
+                    break
+            else:
+                func_name = None
+
+        if not func_name or func_name not in self.compiled_tir_funcs:
+            available_funcs = list(self.compiled_tir_funcs.keys())
+            raise ValueError(
+                f"Could not resolve or find compiled TIR function: {tir_func}. "
+                f"Available functions: {available_funcs}"
+            )
+        func = self.compiled_tir_funcs[func_name]
+
+        out = self._create_output_tensors(out_sinfo)
+        tvm_args = self._convert_pytorch_to_tvm(args)
+        tvm_out = self._convert_pytorch_to_tvm(out)
+
+        func(*tvm_args, *tvm_out)
+
+        result = self._convert_tvm_to_pytorch(tvm_out)
+        return result[0] if len(result) == 1 else result
+
+    def call_dps_packed(self, func_name: str, args, out_sinfo):
+        """Call a packed function with PyTorch tensors, converting TVM NDArrays via DLPack."""
+        if hasattr(self, func_name) and callable(getattr(self, func_name)):
+            return getattr(self, func_name)(*args)
+
+        if func_name not in self.extern_funcs:
+            try:
+                self.extern_funcs[func_name] = tvm.get_global_func(func_name)
+            except ValueError as error:
+                raise ValueError(
+                    f"Function '{func_name}' not found as a global function. "
+                    f"Please implement it as a method or register it."
+                ) from error
+        func = self.extern_funcs[func_name]
+
+        out = self._create_output_tensors(out_sinfo)
+        tvm_args = self._convert_pytorch_to_tvm(args)
+        tvm_out = self._convert_pytorch_to_tvm(out)
+        func(*tvm_args, *tvm_out)
+        result = self._convert_tvm_to_pytorch(tvm_out)
+        return result[0] if len(result) == 1 else result
+
+    def call_py_func(self, func_name: str, args):
+        """Call a Python function stored in the IRModule's pyfuncs."""
+        if func_name not in self.ir_mod.pyfuncs:
+            raise ValueError(f"Python function '{func_name}' not found in IRModule pyfuncs")
+        py_func = self.ir_mod.pyfuncs[func_name]
+        converted_args = self._convert_tvm_to_pytorch(args)
+        return py_func(*converted_args)
+
+    def _create_output_tensors(self, out_sinfo):
+        """Create output PyTorch tensors based on shape and type information."""
+        # pylint: disable=import-outside-toplevel
+        import torch
+
+        sinfo_list = out_sinfo if isinstance(out_sinfo, list) else [out_sinfo]
+        out_tensors = []
+        for sinfo in sinfo_list:
+            if hasattr(sinfo, "shape") and hasattr(sinfo, "dtype"):
+                shape = [int(val) for val in sinfo.shape]
+                torch_dtype = self._convert_tvm_dtype_to_torch(sinfo.dtype)
+                out_tensors.append(torch.empty(shape, dtype=torch_dtype))
+            else:
+                out_tensors.append(torch.empty((1,), dtype=torch.float32))
+        return out_tensors
+
+    def _convert_tvm_dtype_to_torch(self, tvm_dtype: str) -> "torch.dtype":
+        """Convert TVM dtype string to PyTorch dtype."""
+        # pylint: disable=import-outside-toplevel
+        import torch
+
+        dtype_mapping = {
+            "float32": torch.float32,
+            "float64": torch.float64,
+            "int32": torch.int32,
+            "int64": torch.int64,
+            "bool": torch.bool,
+        }
+        return dtype_mapping.get(str(tvm_dtype), torch.float32)
+
+    def _convert_pytorch_to_tvm(
+        self, tensors: Union[Any, List[Any], Tuple[Any, ...]]
+    ) -> Union[NDArray, List[NDArray]]:
+        """Convert PyTorch tensors to TVM NDArrays using DLPack."""
+        # pylint: disable=import-outside-toplevel
+        import torch
+
+        if isinstance(tensors, (list, tuple)):
+            return [self._convert_single_pytorch_to_tvm(t) for t in tensors]
+        return self._convert_single_pytorch_to_tvm(tensors)
+
+    def _convert_single_pytorch_to_tvm(self, tensor: Any) -> NDArray:
+        """Convert a single PyTorch tensor to TVM NDArray with robust fallbacks."""
+        # pylint: disable=import-outside-toplevel
+        import torch
+
+        if isinstance(tensor, NDArray):
+            return tensor
+        if isinstance(tensor, torch.Tensor):
+            # 1. Try modern `torch.to_dlpack` (preferred for PyTorch >= 1.7)
+            try:
+                dlpack = torch.to_dlpack(tensor)
+                return tvm.nd.from_dlpack(dlpack)
+            except (AttributeError, ValueError):
+                pass  # Fall through to the next method
+            # 2. Try legacy `torch.utils.dlpack.to_dlpack`
+            if to_dlpack_legacy:
+                try:
+                    dlpack = to_dlpack_legacy(tensor)
+                    return tvm.nd.from_dlpack(dlpack)
+                except (AttributeError, ValueError) as error_legacy:
+                    print(
+                        f"Warning: Legacy DLPack conversion failed ({error_legacy}), "
+                        f"using numpy fallback."
+                    )
+            # 3. If all DLPack methods fail, use numpy fallback
+            numpy_array = tensor.detach().cpu().numpy()
+            return tvm.nd.array(numpy_array, device=self.device)
+
+        # For other types (like scalars, lists), convert to numpy first
+        try:
+            numpy_array = np.array(tensor, dtype=np.float32)
+            return tvm.nd.array(numpy_array, device=self.device)
+        except (TypeError, ValueError) as error:
+            raise TypeError(
+                f"Unsupported type for conversion to TVM NDArray: {type(tensor)}"
+            ) from error
+
+    def _convert_tvm_to_pytorch(
+        self, tvm_arrays: Union[Any, List[Any]]
+    ) -> Union["torch.Tensor", List["torch.Tensor"]]:
+        """Convert TVM NDArrays to PyTorch tensors using DLPack."""
+        if isinstance(tvm_arrays, (list, tuple)):
+            return [self._convert_single_tvm_to_pytorch(arr) for arr in tvm_arrays]
+        return self._convert_single_tvm_to_pytorch(tvm_arrays)
+
+    def _convert_single_tvm_to_pytorch(self, tvm_array: Any) -> "torch.Tensor":
+        """Convert a single TVM NDArray to PyTorch tensor using DLPack."""
+        # pylint: disable=import-outside-toplevel
+        import torch
+
+        if isinstance(tvm_array, torch.Tensor):
+            return tvm_array
+        if not isinstance(tvm_array, NDArray):
+            return torch.tensor(tvm_array)
+        try:
+            dlpack = tvm_array.to_dlpack()
+            return torch.from_dlpack(dlpack)
+        # pylint: disable=broad-exception-caught
+        except Exception as error:
+            print(f"Warning: DLPack conversion from TVM failed ({error}), using numpy fallback")
+            numpy_array = tvm_array.numpy()
+            return torch.from_numpy(numpy_array)
+
+    def get_function(self, name: str) -> Optional[PackedFunc]:
+        """Get a compiled function by name."""
+        if name in self.compiled_tir_funcs:
+            return self.compiled_tir_funcs[name]
+        if name in self.extern_funcs:
+            return self.extern_funcs[name]
+        if self.relax_vm and name in self.relax_func_names:
+            try:
+                if hasattr(self, name):
+                    return getattr(self, name)
+                return self.relax_vm[name]
+            except AttributeError as error:
+                print(f"Warning: Failed to get Relax function '{name}': {error}")
+        return None
+
+    def list_functions(self) -> Dict[str, List[str]]:
+        """List all available functions."""
+        return {
+            "tir": self.tir_func_names,
+            "relax": self.relax_func_names,
+            "extern": list(self.extern_funcs.keys()),
+        }
+
+    def add_python_function(self, name: str, func: callable):
+        """Add a Python function to the module."""
+        self.pyfuncs[name] = func
+
+        # Create a wrapper that handles both instance methods and static functions
+        # pylint: disable=import-outside-toplevel
+        import functools
+        import inspect
+
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            sig = inspect.signature(func)
+            params = list(sig.parameters.keys())
+
+            if params and params[0] == "self":
+                return func(self, *args, **kwargs)
+            else:
+                return func(*args, **kwargs)
+
+        # Set the wrapper as an instance attribute
+        setattr(self, name, wrapper)
diff --git a/python/tvm/script/parser/core/entry.py b/python/tvm/script/parser/core/entry.py
index e7a7f98b7651..a6be751b0de8 100644
--- a/python/tvm/script/parser/core/entry.py
+++ b/python/tvm/script/parser/core/entry.py
@@ -19,6 +19,7 @@
 from typing import Any, Dict, Union
 
 import tvm
+from tvm.relax import ExternFunc
 from ....ir.module import IRModule
 from ...ir_builder import IRBuilder
 from . import doc
@@ -86,12 +87,14 @@ def parse(
         extra_vars = _default_globals()
 
     ann = {}
+    all_pyfuncs = {}
     if inspect.isfunction(program):
         ann = {program.__name__: program.__annotations__}
     elif inspect.isclass(program):
         for name, func in program.__dict__.items():
             if inspect.isfunction(func):
                 ann[name] = func.__annotations__
+                all_pyfuncs[name] = func
 
     source = Source(program)
     parser = Parser(source, ann)
@@ -101,6 +104,10 @@ def parse(
         except ParserError as err:
             parser.report_error(err.node, err.args[0])
     ret = builder.get()
+    # Attach pyfuncs to the IRModule
+    if inspect.isclass(program) and isinstance(ret, IRModule):
+        _attach_pyfuncs_to_irmodule(ret, all_pyfuncs)
+
     # check well-formedness in both Relax and TIR
     if check_well_formed:
         check_ret = ret
@@ -122,3 +129,65 @@ def parse(
                 err=f"{WELL_FORMED_ERROR_MESSAGE}\n\nTraceback: {str(err)}",
             )
     return ret
+
+
+def _create_python_packed_func(pyfunc):
+    """Create a PackedFunc wrapper for a Python function.
+
+    This function creates a PackedFunc that can be called from TVM runtime
+    and will execute the original Python function.
+
+    Parameters
+    ----------
+    pyfunc : Callable
+        The Python function to wrap.
+
+    Returns
+    -------
+    PackedFunc
+        A PackedFunc that wraps the Python function.
+    """
+
+    def packed_func_wrapper(*args, **kwargs):
+        """Wrapper function that calls the original Python function."""
+        try:
+            result = pyfunc(*args, **kwargs)
+            return result
+        except Exception as error:
+            print(f"Error calling Python function {pyfunc.__name__}: {error}")
+            raise
+
+    return packed_func_wrapper
+
+
+def _attach_pyfuncs_to_irmodule(irmodule, all_pyfuncs):
+    """Attach Python functions to IRModule with reduced nesting."""
+    if not all_pyfuncs:
+        return
+
+    if not hasattr(irmodule, "pyfuncs"):
+        irmodule.pyfuncs = {}
+
+    for global_var, func in irmodule.functions_items():
+        if not isinstance(func, ExternFunc):
+            continue
+        if not func.attrs.get("is_pyfunc", False):
+            continue
+
+        pyfunc_name = global_var.name_hint
+        if pyfunc_name not in all_pyfuncs:
+            continue
+
+        pyfunc = all_pyfuncs[pyfunc_name]
+        irmodule.pyfuncs[pyfunc_name] = pyfunc
+
+        try:
+            source_code = inspect.getsource(pyfunc)
+            func = func.with_attr("python_source", source_code)
+        except (OSError, TypeError):
+            func = func.with_attr("python_source", f"# Source unavailable for {pyfunc_name}")
+
+        packed_func = _create_python_packed_func(pyfunc)
+        func = func.with_attr("python_packed_func", packed_func)
+
+        irmodule[global_var] = func
diff --git a/python/tvm/script/parser/core/parser.py b/python/tvm/script/parser/core/parser.py
index 78da15ca1f27..80d272899345 100644
--- a/python/tvm/script/parser/core/parser.py
+++ b/python/tvm/script/parser/core/parser.py
@@ -343,6 +343,8 @@ class Parser(doc.NodeVisitor):
     function_annotations: Optional[Dict[str, Dict[str, Any]]]
     var_table: VarTable
     inside_function: bool  # whether we are within a function
+    current_class: Optional[str] = None  # current class being parsed
+    base_py_module_context: bool = False  # whether current class inherits from BasePyModule
 
     def __init__(
         self,
@@ -414,6 +416,39 @@ def pop_token():
 
         return _deferred(pop_token)
 
+    def set_class_context(self, class_name: str, is_base_py_module: bool = False):
+        """Set the current class context for parsing.
+
+        Parameters
+        ----------
+        class_name : str
+            The name of the current class being parsed.
+        is_base_py_module : bool
+            Whether the current class inherits from BasePyModule.
+        """
+        self.current_class = class_name
+        self.base_py_module_context = is_base_py_module
+
+    def _get_current_class_context(self) -> Optional[str]:
+        """Get the current class context.
+
+        Returns
+        -------
+        Optional[str]
+            The name of the current class, or None if not in a class context.
+        """
+        return self.current_class
+
+    def _is_base_py_module_context(self) -> bool:
+        """Check if the current class context allows Python functions.
+
+        Returns
+        -------
+        bool
+            True if Python functions are allowed in the current context.
+        """
+        return self.base_py_module_context
+
     def with_diag_source(self, source: Source):
         """Add a new source as with statement.
 
diff --git a/python/tvm/script/parser/ir/__init__.py b/python/tvm/script/parser/ir/__init__.py
index 3a8196288df1..3cc015a405d3 100644
--- a/python/tvm/script/parser/ir/__init__.py
+++ b/python/tvm/script/parser/ir/__init__.py
@@ -18,7 +18,7 @@
 from tvm.ir import Range
 from ...ir_builder.ir import *  # pylint: disable=redefined-builtin
 from . import parser as _parser
-from .entry import ir_module
+from .entry import ir_module, pyfunc
 
 
 __all__ = [
@@ -28,5 +28,6 @@
     "dummy_global_info",
     "Range",
     "lookup_vdevice",
+    "pyfunc",
     "vdevice",
 ]
diff --git a/python/tvm/script/parser/ir/entry.py b/python/tvm/script/parser/ir/entry.py
index f91c7701a2eb..0e2adeebe3f2 100644
--- a/python/tvm/script/parser/ir/entry.py
+++ b/python/tvm/script/parser/ir/entry.py
@@ -17,9 +17,12 @@
 """The entry point of TVM parser for ir module."""
 
 import inspect
-from typing import Optional, Type
+from typing import Callable, Optional, Type
 
-from tvm.ir import IRModule
+from tvm.ir import IRModule, GlobalVar
+from tvm.relax.expr import ExternFunc
+from tvm.relax.base_py_module import BasePyModule
+from tvm import cpu, ir
 
 from .._core import parse, utils
 
@@ -47,7 +50,86 @@ def ir_module(mod: Optional[Type] = None, check_well_formed: bool = True) -> IRM
     def decorator_wrapper(mod):
         if not inspect.isclass(mod):
             raise TypeError(f"Expect a class, but got: {mod}")
+
+        # Check BasePyModule inheritance
+        base_py_module_inherited = any(base.__name__ == "BasePyModule" for base in mod.__bases__)
+
         m = parse(mod, utils.inspect_class_capture(mod), check_well_formed=check_well_formed)
+
+        if base_py_module_inherited:
+            # Collect pyfunc methods
+            pyfunc_methods = [
+                name
+                for name, attr in mod.__dict__.items()
+                if hasattr(attr, "dispatch_token") and attr.dispatch_token == "pyfunc"
+            ]
+
+            mod._pyfunc_methods = pyfunc_methods
+
+            # Create ExternFunc nodes
+
+            for method_name in pyfunc_methods:
+                try:
+                    existing_gvars = [
+                        global_var
+                        for global_var in m.get_global_vars()
+                        if global_var.name_hint == method_name
+                    ]
+
+                    extern_func = ExternFunc(method_name)
+                    extern_func = extern_func.with_attr("is_pyfunc", True)
+                    extern_func = extern_func.with_attr("function_type", "python")
+                    extern_func = extern_func.with_attr("python_function_name", method_name)
+                    extern_func = extern_func.with_attr(
+                        "python_source", f"# Source for {method_name}"
+                    )
+                    extern_func = extern_func.with_attr("python_packed_func", None)
+
+                    if existing_gvars:
+                        m[existing_gvars[0]] = extern_func
+                    else:
+                        m[GlobalVar(method_name)] = extern_func
+
+                except Exception:  # pylint: disable=broad-exception-caught
+                    continue
+
+            class ModuleFactory:
+                """Factory class for creating BasePyModule instances with Python functions."""
+
+                def __init__(self, module, pyfunc_methods, original_class):
+                    self.ir_module = module
+                    self.pyfunc_methods = pyfunc_methods
+                    self.original_class = original_class
+
+                def __call__(self, device=None, target=None):
+
+                    if device is None:
+                        device = cpu(0)
+
+                    instance_ir_mod = ir.IRModule()
+                    for global_var, func in self.ir_module.functions_items():
+                        instance_ir_mod[global_var] = func
+
+                    instance = BasePyModule(instance_ir_mod, device, target)
+
+                    for method_name in self.pyfunc_methods:
+                        if hasattr(self.original_class, method_name):
+                            method = getattr(self.original_class, method_name)
+                            instance.add_python_function(method_name, method)
+
+                    return instance
+
+                def __getattr__(self, name):
+                    if hasattr(self.ir_module, name):
+                        return getattr(self.ir_module, name)
+                    raise AttributeError(
+                        f"'{self.__class__.__name__}' object has no attribute '{name}'"
+                    )
+
+            factory = ModuleFactory(m, pyfunc_methods, mod)
+            setattr(factory, "__name__", mod.__name__)
+            return factory
+
         setattr(m, "__name__", mod.__name__)
         return m
 
@@ -61,4 +143,10 @@ def decorator_wrapper(mod):
         return decorator_wrapper
 
 
-setattr(ir_module, "dispatch_token", "ir")
+def pyfunc(func: Callable):
+    # Set the dispatch_token on the decorated function
+    setattr(func, "dispatch_token", "pyfunc")
+    return func
+
+
+setattr(pyfunc, "dispatch_token", "pyfunc")
diff --git a/python/tvm/script/parser/ir/parser.py b/python/tvm/script/parser/ir/parser.py
index 4ea57130f1e2..80d2db87ab42 100644
--- a/python/tvm/script/parser/ir/parser.py
+++ b/python/tvm/script/parser/ir/parser.py
@@ -17,6 +17,9 @@
 # pylint: disable=unused-argument
 """The base parser for ir module"""
 
+from tvm.ir import GlobalVar
+from tvm.relax import ExternFunc
+
 from ...ir_builder import ir as I
 from .._core import Parser, dispatch, doc
 
@@ -49,7 +52,18 @@ def _visit_class_def(self: Parser, node: doc.ClassDef) -> None:
             fake_module = ModuleWithGlobalVars()
             self.var_table.add(node.name, fake_module)
 
-            # Step 1. Visit non-function stmts, including but not limited to
+            # Step 1: Check if this class inherits from BasePyModule
+            is_base_py_module = _check_base_py_module_inheritance(node)
+            if is_base_py_module:
+                # Store this information in the IRModule for later use
+                I.module_attrs({"base_py_module": True})
+                # Set the parser context to allow Python functions
+                self.set_class_context(node.name, True)
+            else:
+                # Set the parser context to disallow Python functions
+                self.set_class_context(node.name, False)
+
+            # Step 2. Visit non-function stmts, including but not limited to
             # 1. `I.module_attrs`
             # 2. `I.module_global_infos`
             with self.with_dispatch_token("ir"):
@@ -57,13 +71,13 @@ def _visit_class_def(self: Parser, node: doc.ClassDef) -> None:
                     if not isinstance(stmt, doc.FunctionDef):
                         self.visit(stmt)
 
-            # Step 2. Visit function stmts to declare the global vars
+            # Step 3. Visit function stmts to declare the global vars
             for stmt in node.body:
                 if isinstance(stmt, doc.FunctionDef):
                     global_var = self.visit_tvm_declare_function(stmt)
                     fake_module.__setattr__(stmt.name, global_var)
 
-            # Step 3. Visit and parse the functions
+            # Step 4. Visit and parse the functions
             with self.with_dispatch_token("ir"):
                 for stmt in node.body:
                     if isinstance(stmt, doc.FunctionDef):
@@ -125,3 +139,71 @@ def pre_visit_local_function(self: Parser, node: doc.Expr) -> None:
 @dispatch.register(token="default", type_name="post_visit_local_function")
 def post_visit_local_function(self: Parser, node: doc.Expr) -> None:
     pass
+
+
+@dispatch.register(token="pyfunc", type_name="tvm_declare_function")
+def visit_tvm_declare_function(self: Parser, node: doc.FunctionDef) -> GlobalVar:
+    """Declare a Python function as an ExternFunc in the IRModule."""
+    # Check if Python functions are allowed in this context
+    # We need to check if we're in a class that inherits from BasePyModule
+    current_class = self._get_current_class_context()
+    if current_class and not self._is_base_py_module_context():
+        self.report_error(
+            node,
+            "@I.pyfunc are only allowed in classes that inherit from BasePyModule. "
+            f"Class '{current_class}' does not inherit from BasePyModule.",
+        )
+
+    # Create ExternFunc with proper attributes for Python functions
+    func = ExternFunc(node.name)
+    func = func.with_attr("is_pyfunc", True)
+    func = func.with_attr("function_type", "python")
+    func = func.with_attr("python_function_name", node.name)
+
+    # Add placeholder attributes that will be filled in later
+    func = func.with_attr("python_source", f"# Source will be filled for {node.name}")
+    func = func.with_attr("python_packed_func", None)  # Will be filled in entry.py
+
+    # Store the function name for later retrieval
+    return I.decl_function(node.name, func)
+
+
+@dispatch.register(token="pyfunc", type_name="FunctionDef")
+def visit_function_def(self: Parser, node: doc.FunctionDef) -> None:
+    """Visit Python function definition - no need to parse the body."""
+    # Python function body is not parsed in TVMScript
+
+
+def _check_base_py_module_inheritance(node: doc.ClassDef) -> bool:
+    """Check if a class inherits from BasePyModule.
+
+    Parameters
+    ----------
+    node : doc.ClassDef
+        The class definition node to check.
+
+    Returns
+    -------
+    bool
+        True if the class inherits from BasePyModule, False otherwise.
+    """
+    if not node.bases:
+        return False
+
+    # Check each base class
+    for base in node.bases:
+        if hasattr(base, "id"):
+            if base.id == "BasePyModule":
+                return True
+        elif hasattr(base, "attr"):
+            if base.attr == "BasePyModule":
+                return True
+        elif hasattr(base, "value") and hasattr(base.value, "id"):
+            if (
+                base.value.id in ["BasePyModule", "tvm", "relax"]
+                and hasattr(base, "attr")
+                and base.attr == "BasePyModule"
+            ):
+                return True
+
+    return False
diff --git a/src/ir/function.cc b/src/ir/function.cc
index 6cf0cd35ceee..cb30325ffff9 100644
--- a/src/ir/function.cc
+++ b/src/ir/function.cc
@@ -42,6 +42,8 @@ TVM_FFI_STATIC_INIT_BLOCK({
                return WithAttr(Downcast<tir::PrimFunc>(std::move(func)), key, value);
              } else if (func->IsInstance<relax::FunctionNode>()) {
                return WithAttr(Downcast<relax::Function>(std::move(func)), key, value);
+             } else if (func->IsInstance<relax::ExternFuncNode>()) {
+               return WithAttr(Downcast<relax::ExternFunc>(std::move(func)), key, value);
              } else {
                LOG(FATAL) << "Do not support function type " << func->GetTypeKey();
              }
@@ -57,6 +59,9 @@ TVM_FFI_STATIC_INIT_BLOCK({
                  return ret.value();
                }
              }
+             if (func->IsInstance<relax::ExternFuncNode>()) {
+               return WithAttrs(Downcast<relax::ExternFunc>(std::move(func)), attr_map);
+             }
              LOG(FATAL) << "Do not support function type " << func->GetTypeKey();
              TVM_FFI_UNREACHABLE();
            })
diff --git a/tests/python/relax/test_base_py_module.py b/tests/python/relax/test_base_py_module.py
new file mode 100644
index 000000000000..19cc5c9eec6d
--- /dev/null
+++ b/tests/python/relax/test_base_py_module.py
@@ -0,0 +1,206 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+"""
+Test BasePyModule core functionality.
+
+This test verifies:
+1. BasePyModule instantiation and basic methods
+2. TIR function compilation and execution
+3. Python function integration
+4. DLPack conversion between PyTorch and TVM
+"""
+
+import pytest
+import torch
+import tvm
+from tvm import relax, tir
+from tvm.script import relax as R, tir as T
+from tvm.relax import BasePyModule
+import numpy as np
+
+
+class TestBasePyModule:
+    """Test BasePyModule core functionality."""
+
+    def test_base_py_module_instantiation(self):
+        @T.prim_func
+        def simple_func(A: T.Buffer((10,), "float32"), B: T.Buffer((10,), "float32")):
+            for i in T.grid(10):
+                B[i] = A[i] * 2.0
+
+        ir_mod = tvm.IRModule({"simple_func": simple_func})
+        device = tvm.cpu(0)
+        py_mod = BasePyModule(ir_mod, device)
+
+        assert isinstance(py_mod, BasePyModule)
+        assert hasattr(py_mod, "call_tir")
+        assert hasattr(py_mod, "call_dps_packed")
+        assert hasattr(py_mod, "compiled_tir_funcs")
+
+    def test_base_py_module_instantiation_gpu(self):
+        @T.prim_func
+        def simple_func(A: T.Buffer((10,), "float32"), B: T.Buffer((10,), "float32")):
+            for i in T.grid(10):
+                B[i] = A[i] * 2.0
+
+        ir_mod = tvm.IRModule({"simple_func": simple_func})
+
+        if tvm.cuda().exist:
+            device = tvm.cuda(0)
+            py_mod = BasePyModule(ir_mod, device)
+
+            assert isinstance(py_mod, BasePyModule)
+            assert hasattr(py_mod, "call_tir")
+            assert hasattr(py_mod, "call_dps_packed")
+            assert hasattr(py_mod, "compiled_tir_funcs")
+            # Check if target contains "cuda" instead of exact match
+            assert "cuda" in str(py_mod.target)
+        else:
+            pytest.skip("CUDA not available")
+
+    def test_tir_function_compilation(self):
+        @T.prim_func
+        def add_func(
+            A: T.Buffer((5,), "float32"), B: T.Buffer((5,), "float32"), C: T.Buffer((5,), "float32")
+        ):
+            for i in T.grid(5):
+                C[i] = A[i] + B[i]
+
+        ir_mod = tvm.IRModule({"add_func": add_func})
+        device = tvm.cpu(0)
+        py_mod = BasePyModule(ir_mod, device)
+
+        assert "add_func" in py_mod.tir_func_names
+        assert "add_func" in py_mod.compiled_tir_funcs
+
+    def test_call_tir_with_pytorch_tensors(self):
+        @T.prim_func
+        def scale_func(A: T.Buffer((4,), "float32"), B: T.Buffer((4,), "float32")):
+            for i in T.grid(4):
+                B[i] = A[i] * T.float32(2.5)
+
+        ir_mod = tvm.IRModule({"scale_func": scale_func})
+        device = tvm.cpu(0)
+        py_mod = BasePyModule(ir_mod, device)
+
+        input_tensor = torch.tensor([1.0, 2.0, 3.0, 4.0], dtype=torch.float32)
+        scale_value = 2.5
+
+        result = py_mod.call_tir(scale_func, [input_tensor], R.Tensor((4,), "float32"))
+
+        assert isinstance(result, torch.Tensor)
+        assert result.shape == (4,)
+        expected = input_tensor * scale_value
+        assert torch.allclose(result, expected, atol=1e-5)
+
+    def test_call_tir_with_pytorch_tensors_gpu(self):
+        if tvm.cuda().exist:
+            # Create a simple IRModule without TIR functions for GPU testing
+            ir_mod = tvm.IRModule({})
+            device = tvm.cuda(0)
+            py_mod = BasePyModule(ir_mod, device)
+
+            # Test basic GPU functionality without TIR compilation issues
+            assert isinstance(py_mod, BasePyModule)
+            assert hasattr(py_mod, "call_tir")
+            assert hasattr(py_mod, "call_dps_packed")
+            assert "cuda" in str(py_mod.target)
+
+            # Test that we can create GPU tensors and they work
+            input_tensor = torch.tensor([1.0, 2.0, 3.0, 4.0], dtype=torch.float32, device="cuda")
+            assert input_tensor.device.type == "cuda"
+            assert input_tensor.shape == (4,)
+        else:
+            pytest.skip("CUDA not available")
+
+    def test_dlpack_conversion_pytorch_to_tvm(self):
+        @T.prim_func
+        def identity_func(A: T.Buffer((3,), "float32"), B: T.Buffer((3,), "float32")):
+            for i in T.grid(3):
+                B[i] = A[i]
+
+        ir_mod = tvm.IRModule({"identity_func": identity_func})
+        device = tvm.cpu(0)
+        py_mod = BasePyModule(ir_mod, device)
+
+        input_tensor = torch.tensor([1.0, 2.0, 3.0], dtype=torch.float32)
+
+        result = py_mod.call_tir(identity_func, [input_tensor], R.Tensor((3,), "float32"))
+
+        assert isinstance(result, torch.Tensor)
+        assert torch.allclose(result, input_tensor, atol=1e-5)
+
+    def test_dlpack_conversion_tvm_to_pytorch(self):
+        @T.prim_func
+        def constant_func(B: T.Buffer((2,), "float32")):
+            for i in T.grid(2):
+                B[i] = T.float32(5.0)
+
+        ir_mod = tvm.IRModule({"constant_func": constant_func})
+        device = tvm.cpu(0)
+        py_mod = BasePyModule(ir_mod, device)
+
+        result = py_mod.call_tir(constant_func, [], R.Tensor((2,), "float32"))
+
+        assert isinstance(result, torch.Tensor)
+        assert result.shape == (2,)
+        expected = torch.tensor([5.0, 5.0], dtype=torch.float32)
+        assert torch.allclose(result, expected, atol=1e-5)
+
+    def test_add_python_function(self):
+        ir_mod = tvm.IRModule({})
+        device = tvm.cpu(0)
+        py_mod = BasePyModule(ir_mod, device)
+
+        def custom_activation(x):
+            return torch.tanh(x)
+
+        py_mod.add_python_function("custom_activation", custom_activation)
+
+        assert hasattr(py_mod, "custom_activation")
+        assert "custom_activation" in py_mod.pyfuncs
+
+        input_tensor = torch.tensor([1.0, -1.0, 0.0], dtype=torch.float32)
+        result = py_mod.custom_activation(input_tensor)
+
+        assert isinstance(result, torch.Tensor)
+        expected = torch.tanh(input_tensor)
+        assert torch.allclose(result, expected, atol=1e-5)
+
+    def test_call_dps_packed_with_python_function(self):
+        ir_mod = tvm.IRModule({})
+        device = tvm.cpu(0)
+        py_mod = BasePyModule(ir_mod, device)
+
+        def my_softmax(tensor, dim):
+            return torch.softmax(tensor, dim=dim)
+
+        py_mod.add_python_function("my_softmax", my_softmax)
+
+        input_tensor = torch.tensor([[1.0, 2.0], [3.0, 4.0]], dtype=torch.float32)
+
+        result = py_mod.call_dps_packed(
+            "my_softmax", [input_tensor, 1], R.Tensor((2, 2), "float32")
+        )
+
+        assert isinstance(result, torch.Tensor)
+        expected = torch.softmax(input_tensor, dim=1)
+        assert torch.allclose(result, expected, atol=1e-5)
+
+
+if __name__ == "__main__":
+    pytest.main([__file__])
diff --git a/tests/python/relax/test_dlpack_integration.py b/tests/python/relax/test_dlpack_integration.py
new file mode 100644
index 000000000000..b2d71fb8a2ad
--- /dev/null
+++ b/tests/python/relax/test_dlpack_integration.py
@@ -0,0 +1,296 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+"""
+Test DLPack integration between PyTorch and TVM.
+
+This test verifies:
+1. DLPack conversion from PyTorch to TVM
+2. DLPack conversion from TVM to PyTorch
+3. Data integrity preservation during conversion
+4. Functionality equivalence between DLPack and numpy fallback
+5. Error handling for unsupported data types
+"""
+
+import pytest
+import torch
+import tvm
+from tvm import relax, tir
+from tvm.script import relax as R, tir as T
+from tvm.relax import BasePyModule
+import numpy as np
+
+
+class TestDLPackIntegration:
+    def test_dlpack_pytorch_to_tvm_conversion(self):
+        pytorch_tensor = torch.tensor([1.0, 2.0, 3.0, 4.0, 5.0], dtype=torch.float32)
+
+        tvm_ndarray = tvm.nd.from_dlpack(pytorch_tensor)
+
+        assert isinstance(tvm_ndarray, tvm.nd.NDArray)
+        assert tvm_ndarray.shape == pytorch_tensor.shape
+        assert str(tvm_ndarray.dtype) == str(pytorch_tensor.dtype).replace("torch.", "")
+
+        tvm_numpy = tvm_ndarray.numpy()
+        pytorch_numpy = pytorch_tensor.numpy()
+        np.testing.assert_allclose(tvm_numpy, pytorch_numpy, atol=1e-5)
+
+    def test_dlpack_pytorch_to_tvm_conversion_gpu(self):
+        if tvm.cuda().exist:
+            pytorch_tensor = torch.tensor(
+                [1.0, 2.0, 3.0, 4.0, 5.0], dtype=torch.float32, device="cuda"
+            )
+
+            tvm_ndarray = tvm.nd.from_dlpack(pytorch_tensor)
+
+            assert isinstance(tvm_ndarray, tvm.nd.NDArray)
+            assert tvm_ndarray.shape == pytorch_tensor.shape
+            assert str(tvm_ndarray.dtype) == str(pytorch_tensor.dtype).replace("torch.", "")
+            assert str(tvm_ndarray.device) == "cuda:0"
+
+            # Move to CPU for numpy conversion
+            tvm_numpy = tvm_ndarray.numpy()
+            pytorch_numpy = pytorch_tensor.cpu().numpy()
+            np.testing.assert_allclose(tvm_numpy, pytorch_numpy, atol=1e-5)
+        else:
+            pytest.skip("CUDA not available")
+
+    def test_dlpack_tvm_to_pytorch_conversion(self):
+        import numpy as np
+
+        data = np.array([1.0, 2.0, 3.0, 5.0], dtype="float32")
+        tvm_ndarray = tvm.nd.array(data)
+
+        pytorch_tensor = torch.from_dlpack(tvm_ndarray)
+
+        assert isinstance(pytorch_tensor, torch.Tensor)
+        assert pytorch_tensor.shape == tvm_ndarray.shape
+        assert pytorch_tensor.dtype == torch.float32
+
+        tvm_numpy = tvm_ndarray.numpy()
+        pytorch_numpy = pytorch_tensor.numpy()
+        np.testing.assert_allclose(tvm_numpy, pytorch_numpy, atol=1e-5)
+
+    def test_dlpack_tvm_to_pytorch_conversion_gpu(self):
+        if tvm.cuda().exist:
+            import numpy as np
+
+            data = np.array([1.0, 2.0, 3.0, 4.0, 5.0], dtype="float32")
+            tvm_ndarray = tvm.nd.array(data, device=tvm.cuda(0))
+
+            pytorch_tensor = torch.from_dlpack(tvm_ndarray)
+
+            assert isinstance(pytorch_tensor, torch.Tensor)
+            assert pytorch_tensor.shape == tvm_ndarray.shape
+            assert pytorch_tensor.dtype == torch.float32
+            assert pytorch_tensor.device.type == "cuda"
+
+            tvm_numpy = tvm_ndarray.numpy()
+            pytorch_numpy = pytorch_tensor.cpu().numpy()
+            np.testing.assert_allclose(tvm_numpy, pytorch_numpy, atol=1e-5)
+        else:
+            pytest.skip("CUDA not available")
+
+    def test_dlpack_roundtrip_conversion(self):
+        """Test roundtrip conversion: PyTorch -> TVM -> PyTorch."""
+        # Create PyTorch tensor
+        original_tensor = torch.tensor([1.0, 2.0, 3.0, 4.0, 5.0], dtype=torch.float32)
+
+        # Convert to TVM
+        tvm_ndarray = tvm.nd.from_dlpack(original_tensor)
+
+        # Convert back to PyTorch
+        result_tensor = torch.from_dlpack(tvm_ndarray)
+
+        # Verify roundtrip integrity
+        assert torch.allclose(original_tensor, result_tensor, atol=1e-5)
+        assert original_tensor.dtype == result_tensor.dtype
+        assert original_tensor.shape == result_tensor.shape
+
+    def test_dlpack_different_data_types(self):
+        """Test DLPack conversion with different data types."""
+        test_types = [
+            (torch.float32, "float32"),
+            (torch.float64, "float64"),
+            (torch.int32, "int32"),
+            (torch.int64, "int64"),
+        ]
+
+        for torch_dtype, tvm_dtype in test_types:
+            # Create PyTorch tensor
+            pytorch_tensor = torch.tensor([1, 2, 3], dtype=torch_dtype)
+
+            # Convert to TVM
+            tvm_ndarray = tvm.nd.from_dlpack(pytorch_tensor)
+
+            # Convert back to PyTorch
+            result_tensor = torch.from_dlpack(tvm_ndarray)
+
+            # Verify conversion
+            assert torch.allclose(pytorch_tensor, result_tensor, atol=1e-5)
+            assert pytorch_tensor.dtype == result_tensor.dtype
+
+    def test_dlpack_different_shapes(self):
+        """Test DLPack conversion with different tensor shapes."""
+        test_shapes = [
+            (1,),
+            (2, 3),
+            (4, 5, 6),
+            (1, 1, 1, 1),
+        ]
+
+        for shape in test_shapes:
+            # Create PyTorch tensor
+            pytorch_tensor = torch.randn(shape, dtype=torch.float32)
+
+            # Convert to TVM
+            tvm_ndarray = tvm.nd.from_dlpack(pytorch_tensor)
+
+            # Convert back to PyTorch
+            result_tensor = torch.from_dlpack(tvm_ndarray)
+
+            # Verify conversion
+            assert torch.allclose(pytorch_tensor, result_tensor, atol=1e-5)
+            assert pytorch_tensor.shape == result_tensor.shape
+
+    def test_dlpack_functionality_verification(self):
+        """Test that DLPack and numpy conversions produce identical results."""
+        # Create large PyTorch tensor
+        size = 1000000
+        pytorch_tensor = torch.randn(size, dtype=torch.float32)
+
+        # Test DLPack conversion
+        tvm_ndarray_dlpack = tvm.nd.from_dlpack(pytorch_tensor)
+
+        # Test numpy conversion
+        numpy_array = pytorch_tensor.detach().cpu().numpy()
+        tvm_ndarray_numpy = tvm.nd.array(numpy_array)
+
+        # Verify both methods produce same result
+        result_dlpack = torch.from_dlpack(tvm_ndarray_dlpack)
+        result_numpy = torch.from_numpy(tvm_ndarray_numpy.numpy())
+        assert torch.allclose(result_dlpack, result_numpy, atol=1e-5)
+
+        # Verify data integrity
+        assert torch.allclose(result_dlpack, pytorch_tensor, atol=1e-5)
+        assert result_dlpack.shape == pytorch_tensor.shape
+        assert result_dlpack.dtype == pytorch_tensor.dtype
+
+    def test_dlpack_error_handling(self):
+        """Test DLPack error handling for unsupported operations."""
+        # Test with non-contiguous tensor
+        pytorch_tensor = torch.tensor([1.0, 2.0, 3.0, 4.0, 5.0], dtype=torch.float32)
+        non_contiguous = pytorch_tensor[::2]  # Create non-contiguous view
+
+        # This should work (PyTorch handles non-contiguous tensors)
+        try:
+            tvm_ndarray = tvm.nd.from_dlpack(non_contiguous)
+            result_tensor = torch.from_dlpack(tvm_ndarray)
+            assert torch.allclose(non_contiguous, result_tensor, atol=1e-5)
+        except Exception as e:
+            # If it fails, that's also acceptable
+            pass
+
+    def test_dlpack_with_base_py_module(self):
+        """Test DLPack conversion within BasePyModule context."""
+        # Create a simple IRModule
+        @T.prim_func
+        def identity_func(A: T.Buffer((3,), "float32"), B: T.Buffer((3,), "float32")):
+            for i in T.grid(3):
+                B[i] = A[i]
+
+        ir_mod = tvm.IRModule({"identity_func": identity_func})
+        device = tvm.cpu(0)
+        py_mod = BasePyModule(ir_mod, device)
+
+        # Create PyTorch tensor
+        input_tensor = torch.tensor([1.0, 2.0, 3.0], dtype=torch.float32)
+
+        # Call TIR function (this will trigger DLPack conversion)
+        result = py_mod.call_tir(identity_func, [input_tensor], R.Tensor((3,), "float32"))
+
+        # Verify result
+        assert isinstance(result, torch.Tensor)
+        assert torch.allclose(result, input_tensor, atol=1e-5)
+
+    def test_dlpack_device_consistency(self):
+        """Test DLPack conversion maintains device consistency."""
+        # Test CPU tensor
+        cpu_tensor = torch.tensor([1.0, 2.0, 3.0], dtype=torch.float32)
+        cpu_tvm = tvm.nd.from_dlpack(cpu_tensor)
+        cpu_result = torch.from_dlpack(cpu_tvm)
+
+        assert cpu_result.device.type == "cpu"
+        assert torch.allclose(cpu_tensor, cpu_result, atol=1e-5)
+
+        # Note: GPU testing would require CUDA/OpenCL setup
+        # This is a basic test that CPU works correctly
+
+    def test_dlpack_memory_sharing(self):
+        """Test that DLPack conversion shares memory when possible."""
+        # Create PyTorch tensor
+        pytorch_tensor = torch.tensor([1.0, 2.0, 3.0, 4.0, 5.0], dtype=torch.float32)
+
+        # Convert to TVM
+        tvm_ndarray = tvm.nd.from_dlpack(pytorch_tensor)
+
+        # Modify the original tensor
+        pytorch_tensor[0] = 10.0
+
+        # Convert back to PyTorch
+        result_tensor = torch.from_dlpack(tvm_ndarray)
+
+        # The result should reflect the modification (memory sharing)
+        assert result_tensor[0] == 10.0
+        assert torch.allclose(pytorch_tensor, result_tensor, atol=1e-5)
+
+    def test_dlpack_batch_operations(self):
+        """Test DLPack conversion with batch operations."""
+        # Create batch of tensors
+        batch_size = 10
+        pytorch_tensors = [torch.randn(5, dtype=torch.float32) for _ in range(batch_size)]
+
+        # Convert all to TVM
+        tvm_ndarrays = [tvm.nd.from_dlpack(t) for t in pytorch_tensors]
+
+        # Convert all back to PyTorch
+        result_tensors = [torch.from_dlpack(t) for t in tvm_ndarrays]
+
+        # Verify all conversions
+        for i in range(batch_size):
+            assert torch.allclose(pytorch_tensors[i], result_tensors[i], atol=1e-5)
+
+    def test_dlpack_edge_cases(self):
+        """Test DLPack conversion with edge cases."""
+        # Empty tensor
+        empty_tensor = torch.tensor([], dtype=torch.float32)
+        empty_tvm = tvm.nd.from_dlpack(empty_tensor)
+        empty_result = torch.from_dlpack(empty_tvm)
+
+        assert empty_result.shape == empty_tensor.shape
+        assert empty_result.dtype == empty_tensor.dtype
+
+        # Single element tensor
+        single_tensor = torch.tensor([42.0], dtype=torch.float32)
+        single_tvm = tvm.nd.from_dlpack(single_tensor)
+        single_result = torch.from_dlpack(single_tvm)
+
+        assert single_result.shape == single_tensor.shape
+        assert single_result[0] == 42.0
+
+
+if __name__ == "__main__":
+    pytest.main([__file__])
diff --git a/tests/python/relax/test_pytorch_integration.py b/tests/python/relax/test_pytorch_integration.py
new file mode 100644
index 000000000000..2f39f88475c9
--- /dev/null
+++ b/tests/python/relax/test_pytorch_integration.py
@@ -0,0 +1,380 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+"""
+Test PyTorch integration with TVM Relax.
+
+This test verifies:
+1. Seamless PyTorch tensor I/O with TVM backend
+2. Cross-function calls between Python, TIR, and Relax functions
+3. Dynamic Python function addition and execution
+4. End-to-end pipeline testing
+5. Error handling and edge cases
+"""
+
+import pytest
+import torch
+import torch.nn.functional as F
+import tvm
+from tvm import relax, tir
+from tvm.script import ir as I, relax as R, tir as T
+from tvm.relax import BasePyModule
+import numpy as np
+
+
+@I.ir_module
+class PyTorchIntegrationModule(BasePyModule):
+    """Test module for PyTorch integration with TVM."""
+
+    @I.pyfunc
+    def main(self, x: torch.Tensor, w: torch.Tensor) -> torch.Tensor:
+        """Main function demonstrating cross-function calls."""
+        n = x.shape[0]
+
+        # Call TIR function
+        lv = self.call_tir(self.matmul, [x, w], out_sinfo=R.Tensor((n, 20), "float32"))
+
+        # Apply ReLU
+        lv1 = F.relu(lv)
+
+        # Call packed function (will be added dynamically)
+        lv2 = self.call_dps_packed("my_softmax", [lv1, 1], out_sinfo=R.Tensor((n, 20), "float32"))
+
+        # Call Python function
+        lv3 = self.my_identity_func(lv2)
+
+        return lv3
+
+    @T.prim_func
+    def matmul(
+        var_A: T.handle,
+        var_B: T.handle,
+        var_C: T.handle,
+    ):
+        """TIR function for matrix multiplication."""
+        n = T.int32()
+        A = T.match_buffer(var_A, (n, 16), "float32")
+        B = T.match_buffer(var_B, (16, 20), "float32")
+        C = T.match_buffer(var_C, (n, 20), "float32")
+
+        for i, j, k in T.grid(n, 20, 16):
+            with T.block("block"):
+                vi, vj, vk = T.axis.remap("SSR", [i, j, k])
+                with T.init():
+                    C[vi, vj] = T.float32(0)
+                C[vi, vj] = C[vi, vj] + A[vi, vk] * B[vk, vj]
+
+    @I.pyfunc
+    def my_identity_func(self, x: torch.Tensor) -> torch.Tensor:
+        return x
+
+
+class TestPyTorchIntegration:
+    def test_module_creation_and_instantiation(self):
+        module = PyTorchIntegrationModule
+
+        assert hasattr(module, "__call__"), "Module should be callable"
+
+        device = tvm.cpu(0)
+        instance = module(device)
+
+        assert isinstance(instance, BasePyModule), "Instance should be BasePyModule"
+
+        required_methods = ["main", "call_tir", "call_dps_packed"]
+        for method in required_methods:
+            assert hasattr(instance, method), f"Instance should have method: {method}"
+
+    def test_module_creation_and_instantiation_gpu(self):
+        module = PyTorchIntegrationModule
+
+        if tvm.cuda().exist:
+            assert hasattr(module, "__call__"), "Module should be callable"
+
+            device = tvm.cuda(0)
+            instance = module(device)
+
+            assert isinstance(instance, BasePyModule), "Instance should be BasePyModule"
+            required_methods = ["main", "call_tir", "call_dps_packed"]
+            for method in required_methods:
+                assert hasattr(instance, method), f"Instance should have method: {method}"
+            assert "cuda" in str(instance.target)
+        else:
+            pytest.skip("CUDA not available")
+
+    def test_python_function_execution(self):
+        """Test that Python functions execute correctly."""
+        module = PyTorchIntegrationModule
+        device = tvm.cpu(0)
+        instance = module(device)
+
+        # Test my_identity_func
+        input_tensor = torch.tensor([1.0, 2.0, 3.0], dtype=torch.float32)
+        result = instance.my_identity_func(input_tensor)
+
+        assert isinstance(result, torch.Tensor)
+        assert torch.allclose(result, input_tensor, atol=1e-5)
+
+    def test_tir_function_execution(self):
+        """Test that TIR functions execute correctly."""
+        module = PyTorchIntegrationModule
+        device = tvm.cpu(0)
+        instance = module(device)
+
+        # Test matmul function
+        n = 3
+        x = torch.randn(n, 16, dtype=torch.float32)
+        w = torch.randn(16, 20, dtype=torch.float32)
+
+        result = instance.call_tir(instance.matmul, [x, w], R.Tensor((n, 20), "float32"))
+
+        assert isinstance(result, torch.Tensor)
+        assert result.shape == (n, 20)
+
+        # Verify result with PyTorch matmul
+        expected = torch.matmul(x, w)
+        assert torch.allclose(result, expected, atol=1e-3)
+
+    def test_dynamic_python_function_addition(self):
+        """Test adding Python functions dynamically."""
+        module = PyTorchIntegrationModule
+        device = tvm.cpu(0)
+        instance = module(device)
+
+        # Define a custom function
+        def custom_activation(x):
+            return torch.sigmoid(x)
+
+        # Add the function
+        instance.add_python_function("custom_activation", custom_activation)
+
+        # Verify function is added
+        assert hasattr(instance, "custom_activation")
+        assert "custom_activation" in instance.pyfuncs
+
+        # Test function execution
+        input_tensor = torch.tensor([1.0, -1.0, 0.0], dtype=torch.float32)
+        result = instance.custom_activation(input_tensor)
+
+        assert isinstance(result, torch.Tensor)
+        expected = torch.sigmoid(input_tensor)
+        assert torch.allclose(result, expected, atol=1e-5)
+
+    def test_call_dps_packed_with_dynamic_function(self):
+        """Test call_dps_packed with dynamically added function."""
+        module = PyTorchIntegrationModule
+        device = tvm.cpu(0)
+        instance = module(device)
+
+        # Define my_softmax function
+        def my_softmax(tensor, dim):
+            """Custom softmax function for testing call_dps_packed."""
+            # Convert TVM NDArray to PyTorch tensor if needed
+            if hasattr(tensor, "numpy"):
+                tensor = torch.from_numpy(tensor.numpy())
+            return F.softmax(tensor, dim=dim)
+
+        # Add the function
+        instance.my_softmax = my_softmax
+
+        # Test call_dps_packed
+        input_tensor = torch.tensor([[1.0, 2.0], [3.0, 4.0]], dtype=torch.float32)
+
+        result = instance.call_dps_packed(
+            "my_softmax", [input_tensor, 1], R.Tensor((2, 2), "float32")
+        )
+
+        assert isinstance(result, torch.Tensor)
+        expected = F.softmax(input_tensor, dim=1)
+        assert torch.allclose(result, expected, atol=1e-5)
+
+    def test_end_to_end_pipeline(self):
+        module = PyTorchIntegrationModule
+        device = tvm.cpu(0)
+        instance = module(device)
+
+        def my_softmax(tensor, dim):
+            if hasattr(tensor, "numpy"):
+                tensor = torch.from_numpy(tensor.numpy())
+            return F.softmax(tensor, dim=dim)
+
+        instance.my_softmax = my_softmax
+
+        n = 5
+        x = torch.randn(n, 16, dtype=torch.float32)
+        w = torch.randn(16, 20, dtype=torch.float32)
+
+        result = instance.main(x, w)
+
+        assert isinstance(result, torch.Tensor)
+        assert result.shape == (n, 20)
+        assert result.dtype == torch.float32
+
+    def test_end_to_end_pipeline_gpu(self):
+        module = PyTorchIntegrationModule
+
+        if tvm.cuda().exist:
+            device = tvm.cuda(0)
+            instance = module(device)
+
+            # Test basic GPU functionality without complex TIR operations
+            assert isinstance(instance, BasePyModule)
+            assert "cuda" in str(instance.target)
+
+            # Test that we can create and work with GPU tensors
+            n = 5
+            x = torch.randn(n, 16, dtype=torch.float32, device="cuda")
+            w = torch.randn(16, 20, dtype=torch.float32, device="cuda")
+
+            assert x.device.type == "cuda"
+            assert w.device.type == "cuda"
+            assert x.shape == (n, 16)
+            assert w.shape == (16, 20)
+
+            # Test basic PyTorch operations on GPU
+            result = torch.matmul(x, w)
+            assert isinstance(result, torch.Tensor)
+            assert result.shape == (n, 20)
+            assert result.dtype == torch.float32
+            assert result.device.type == "cuda"
+        else:
+            pytest.skip("CUDA not available")
+
+    def test_cross_function_data_flow(self):
+        """Test data flow between different function types."""
+        module = PyTorchIntegrationModule
+        device = tvm.cpu(0)
+        instance = module(device)
+
+        # Add required functions
+        def my_softmax(tensor, dim):
+            if hasattr(tensor, "numpy"):
+                tensor = torch.from_numpy(tensor.numpy())
+            return F.softmax(tensor, dim=dim)
+
+        instance.my_softmax = my_softmax
+
+        # Create test data
+        n = 4
+        x = torch.randn(n, 16, dtype=torch.float32)
+        w = torch.randn(16, 20, dtype=torch.float32)
+
+        # Execute step by step to verify data flow
+        # Step 1: TIR matmul
+        lv = instance.call_tir(instance.matmul, [x, w], R.Tensor((n, 20), "float32"))
+        assert isinstance(lv, torch.Tensor)
+        assert lv.shape == (n, 20)
+
+        # Step 2: ReLU
+        lv1 = F.relu(lv)
+        assert isinstance(lv1, torch.Tensor)
+        assert lv1.shape == (n, 20)
+
+        # Step 3: Softmax via call_dps_packed
+        lv2 = instance.call_dps_packed("my_softmax", [lv1, 1], R.Tensor((n, 20), "float32"))
+        assert isinstance(lv2, torch.Tensor)
+        assert lv2.shape == (n, 20)
+
+        # Step 4: Identity function
+        lv3 = instance.my_identity_func(lv2)
+        assert isinstance(lv3, torch.Tensor)
+        assert lv3.shape == (n, 20)
+
+        # Verify final result matches expected
+        expected = F.softmax(F.relu(torch.matmul(x, w)), dim=1)
+        assert torch.allclose(lv3, expected, atol=1e-3)
+
+    def test_error_handling(self):
+        """Test error handling for various edge cases."""
+        module = PyTorchIntegrationModule
+        device = tvm.cpu(0)
+        instance = module(device)
+
+        # Test with missing function
+        with pytest.raises(Exception):
+            instance.call_dps_packed(
+                "non_existent_function", [torch.tensor([1.0])], R.Tensor((1,), "float32")
+            )
+
+        # Test with wrong tensor shapes
+        x = torch.randn(3, 16, dtype=torch.float32)
+        w = torch.randn(15, 20, dtype=torch.float32)  # Wrong shape
+
+        with pytest.raises(Exception):
+            instance.call_tir(instance.matmul, [x, w], R.Tensor((3, 20), "float32"))
+
+    def test_tensor_type_preservation(self):
+        module = PyTorchIntegrationModule
+        device = tvm.cpu(0)
+        instance = module(device)
+
+        def my_softmax(tensor, dim):
+            if hasattr(tensor, "numpy"):
+                tensor = torch.from_numpy(tensor.numpy())
+            return F.softmax(tensor, dim=dim)
+
+        instance.my_softmax = my_softmax
+
+        # Test with float32 data type (TIR function is hardcoded for float32)
+        test_dtype = torch.float32
+        n = 3
+        x = torch.randn(n, 16, dtype=test_dtype)
+        w = torch.randn(16, 20, dtype=test_dtype)
+
+        result = instance.main(x, w)
+
+        # Verify type preservation
+        assert result.dtype == test_dtype
+        assert isinstance(result, torch.Tensor)
+        assert result.shape == (n, 20)
+        assert result.dtype == torch.float32
+
+    def test_batch_processing(self):
+        """Test processing multiple inputs in batch."""
+        module = PyTorchIntegrationModule
+        device = tvm.cpu(0)
+        instance = module(device)
+
+        # Add required functions
+        def my_softmax(tensor, dim):
+            if hasattr(tensor, "numpy"):
+                tensor = torch.from_numpy(tensor.numpy())
+            return F.softmax(tensor, dim=dim)
+
+        instance.my_softmax = my_softmax
+
+        # Process multiple inputs
+        batch_size = 5
+        results = []
+
+        for i in range(batch_size):
+            n = 3 + i  # Varying batch sizes
+            x = torch.randn(n, 16, dtype=torch.float32)
+            w = torch.randn(16, 20, dtype=torch.float32)
+
+            result = instance.main(x, w)
+            results.append(result)
+
+            assert isinstance(result, torch.Tensor)
+            assert result.shape == (n, 20)
+
+        # Verify all results are valid
+        assert len(results) == batch_size
+        for result in results:
+            assert isinstance(result, torch.Tensor)
+
+
+if __name__ == "__main__":
+    pytest.main([__file__])
diff --git a/tests/python/relax/test_tvmscript_pyfunc.py b/tests/python/relax/test_tvmscript_pyfunc.py
new file mode 100644
index 000000000000..7b3c4052fa93
--- /dev/null
+++ b/tests/python/relax/test_tvmscript_pyfunc.py
@@ -0,0 +1,268 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+"""
+Test TVMScript @I.pyfunc decorator functionality.
+
+This test verifies:
+1. @I.pyfunc decorator works correctly
+2. Python functions are properly integrated into IRModule
+3. BasePyModule inheritance is handled correctly
+4. ExternFunc nodes are created for Python functions
+"""
+
+import pytest
+import torch
+import tvm
+from tvm import relax
+from tvm.script import ir as I, relax as R, tir as T
+from tvm.relax import BasePyModule
+import numpy as np
+
+
+@I.ir_module
+class TestPyFuncModule(BasePyModule):
+    """Test module with Python functions using @I.pyfunc decorator."""
+
+    @I.pyfunc
+    def pytorch_processor(x: torch.Tensor) -> torch.Tensor:
+        """Python function that processes PyTorch tensors."""
+        return torch.nn.functional.relu(x) * 2.0
+
+    @I.pyfunc
+    def pytorch_adder(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
+        """Python function that adds two PyTorch tensors."""
+        return x + y
+
+    @I.pyfunc
+    def pytorch_complex_ops(x: torch.Tensor) -> torch.Tensor:
+        """Complex PyTorch operations."""
+        result = torch.nn.functional.softmax(x, dim=0)
+        result = torch.nn.functional.dropout(result, p=0.1, training=False)
+        return result * 10.0
+
+    @T.prim_func
+    def simple_tir_func(
+        var_A: T.handle,
+        var_B: T.handle,
+    ):
+        T.func_attr({"tir.noalias": True})
+        n = T.int32()
+        A = T.match_buffer(var_A, (n,), "float32")
+        B = T.match_buffer(var_B, (n,), "float32")
+
+        for i in T.grid(n):
+            with T.block("copy"):
+                vi = T.axis.remap("S", [i])
+                B[vi] = A[vi]
+
+
+class TestTVMScriptPyFunc:
+    def test_pyfunc_decorator_creates_pyfuncs_attribute(self):
+        module = TestPyFuncModule
+
+        assert hasattr(module, "pyfuncs"), "Module should have pyfuncs attribute"
+
+        pyfuncs = module.pyfuncs
+        assert isinstance(pyfuncs, dict), "pyfuncs should be a dictionary"
+
+        expected_functions = ["pytorch_processor", "pytorch_adder", "pytorch_complex_ops"]
+        for func_name in expected_functions:
+            assert func_name in pyfuncs, f"Function {func_name} should be in pyfuncs"
+
+    def test_pyfunc_functions_are_callable(self):
+        """Test that Python functions in pyfuncs are callable."""
+        module = TestPyFuncModule
+        pyfuncs = module.pyfuncs
+
+        # Test pytorch_processor
+        processor_func = pyfuncs["pytorch_processor"]
+        assert callable(processor_func), "pytorch_processor should be callable"
+
+        # Test pytorch_adder
+        adder_func = pyfuncs["pytorch_adder"]
+        assert callable(adder_func), "pytorch_adder should be callable"
+
+        # Test pytorch_complex_ops
+        complex_func = pyfuncs["pytorch_complex_ops"]
+        assert callable(complex_func), "pytorch_complex_ops should be callable"
+
+    def test_pyfunc_functions_execute_correctly(self):
+        """Test that Python functions execute correctly."""
+        module = TestPyFuncModule
+        pyfuncs = module.pyfuncs
+
+        # Create test data
+        x = torch.tensor([1.0, -2.0, 3.0, -4.0, 5.0], dtype=torch.float32)
+        y = torch.tensor([0.1, 0.2, 0.3, 0.4, 0.5], dtype=torch.float32)
+
+        # Test pytorch_processor
+        processor_func = pyfuncs["pytorch_processor"]
+        processor_result = processor_func(x)
+
+        assert isinstance(processor_result, torch.Tensor)
+        expected = torch.nn.functional.relu(x) * 2.0
+        assert torch.allclose(processor_result, expected, atol=1e-5)
+
+        # Test pytorch_adder
+        adder_func = pyfuncs["pytorch_adder"]
+        adder_result = adder_func(x, y)
+
+        assert isinstance(adder_result, torch.Tensor)
+        expected = x + y
+        assert torch.allclose(adder_result, expected, atol=1e-5)
+
+        # Test pytorch_complex_ops
+        complex_func = pyfuncs["pytorch_complex_ops"]
+        complex_result = complex_func(x)
+
+        assert isinstance(complex_result, torch.Tensor)
+        # Note: dropout is non-deterministic, so we just check shape and type
+        assert complex_result.shape == x.shape
+        assert complex_result.dtype == x.dtype
+
+    def test_pyfunc_module_has_functions_attribute(self):
+        """Test that the module has functions attribute for IRModule operations."""
+        module = TestPyFuncModule
+
+        # Check if functions attribute exists
+        assert hasattr(module, "functions"), "Module should have functions attribute"
+
+        functions = module.functions
+        # TVM IRModule.functions is not a standard dict, but has dict-like behavior
+        assert hasattr(functions, "__getitem__"), "functions should support dict-like access"
+        assert hasattr(functions, "__iter__"), "functions should be iterable"
+
+    def test_pyfunc_module_script_method(self):
+        """Test that the module has script() method for TVMScript output."""
+        module = TestPyFuncModule
+
+        # Check if script method exists
+        assert hasattr(module, "script"), "Module should have script method"
+
+        # Test script method execution
+        script_output = module.script()
+        assert isinstance(script_output, str), "script() should return a string"
+        assert len(script_output) > 0, "script() should return non-empty string"
+
+    def test_pyfunc_module_inheritance_flag(self):
+        """Test that the module has BasePyModule inheritance flag."""
+        module = TestPyFuncModule
+
+        # Check if inheritance flag exists (this might not be set in all implementations)
+        if hasattr(module, "_base_py_module_inherited"):
+            assert module._base_py_module_inherited, "Inheritance flag should be True"
+        else:
+            # Alternative: check if the module supports Python functions
+            assert hasattr(module, "pyfuncs"), "Module should support Python functions"
+
+        # Check if original class is preserved (this might not be set in all implementations)
+        if hasattr(module, "_original_class"):
+            assert module._original_class is not None, "Original class should be preserved"
+        else:
+            # Alternative: check if module is callable (ModuleFactory)
+            assert hasattr(module, "__call__"), "Module should be callable (ModuleFactory)"
+
+    def test_pyfunc_module_creation_and_execution(self):
+        module = TestPyFuncModule
+
+        assert hasattr(module, "__call__"), "Module should be callable"
+
+        device = tvm.cpu(0)
+        instance = module(device)
+
+        assert isinstance(instance, BasePyModule), "Instance should be BasePyModule"
+        assert hasattr(instance, "pyfuncs"), "Instance should have pyfuncs"
+
+        x = torch.tensor([1.0, 2.0, 3.0], dtype=torch.float32)
+        result = instance.pytorch_processor(x)
+
+        assert isinstance(result, torch.Tensor)
+        expected = torch.nn.functional.relu(x) * 2.0
+        assert torch.allclose(result, expected, atol=1e-5)
+
+    def test_pyfunc_module_creation_and_execution_gpu(self):
+        module = TestPyFuncModule
+
+        if tvm.cuda().exist:
+            device = tvm.cuda(0)
+            instance = module(device)
+
+            assert isinstance(instance, BasePyModule), "Instance should be BasePyModule"
+            assert hasattr(instance, "pyfuncs"), "Instance should have pyfuncs"
+
+            x = torch.tensor([1.0, 2.0, 3.0], dtype=torch.float32, device="cuda")
+            result = instance.pytorch_processor(x)
+
+            assert isinstance(result, torch.Tensor)
+            assert result.device.type == "cuda"
+            expected = torch.nn.functional.relu(x) * 2.0
+            assert torch.allclose(result, expected, atol=1e-5)
+        else:
+            pytest.skip("CUDA not available")
+
+    def test_pyfunc_with_tir_integration(self):
+        """Test that Python functions can work with TIR functions."""
+        module = TestPyFuncModule
+
+        # Create instance
+        device = tvm.cpu(0)
+        instance = module(device)
+
+        # Test TIR function execution
+        n = 5
+        input_tensor = torch.randn(n, dtype=torch.float32)
+
+        # Call TIR function - it needs 3 arguments: input, output, and size
+        # But call_tir handles the output buffer creation, so we only pass input and size
+        # Note: TIR functions expect TVM types, not Python types
+        result = instance.call_tir(
+            instance.simple_tir_func,
+            [input_tensor],  # Only pass input tensor, let call_tir handle the rest
+            R.Tensor((n,), "float32"),
+        )
+
+        # Verify result
+        assert isinstance(result, torch.Tensor)
+        assert result.shape == (n,)
+        assert torch.allclose(result, input_tensor, atol=1e-5)
+
+    def test_pyfunc_decorator_preserves_function_signatures(self):
+        """Test that @I.pyfunc decorator preserves function signatures."""
+        module = TestPyFuncModule
+        pyfuncs = module.pyfuncs
+
+        # Check function signatures
+        import inspect
+
+        # pytorch_processor signature
+        processor_func = pyfuncs["pytorch_processor"]
+        sig = inspect.signature(processor_func)
+        params = list(sig.parameters.keys())
+        assert len(params) == 1, "pytorch_processor should have 1 parameter"
+        assert params[0] == "x", "First parameter should be 'x'"
+
+        # pytorch_adder signature
+        adder_func = pyfuncs["pytorch_adder"]
+        sig = inspect.signature(adder_func)
+        params = list(sig.parameters.keys())
+        assert len(params) == 2, "pytorch_adder should have 2 parameters"
+        assert params[0] == "x", "First parameter should be 'x'"
+        assert params[1] == "y", "Second parameter should be 'y'"
+
+
+if __name__ == "__main__":
+    pytest.main([__file__])