wave-gpu 0.1.0__tar.gz

wave_gpu-0.1.0/PKG-INFO

@@ -0,0 +1,46 @@
+Metadata-Version: 2.4
+Name: wave-gpu
+Version: 0.1.0
+Summary: Write GPU kernels in Python, run on any GPU
+Author: Ojima Abraham
+License: Apache-2.0
+Project-URL: Homepage, https://wave.ojima.me
+Project-URL: Repository, https://github.com/Oabraham1/wave
+Keywords: gpu,cuda,metal,hip,sycl,compute
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# WAVE Python SDK
+
+Write GPU kernels in Python, run on any GPU.
+
+## Install
+
+```bash
+pip install wave-gpu
+```
+
+## Usage
+
+```python
+import wave_gpu
+
+@wave_gpu.kernel
+def vector_add(a: wave_gpu.f32[:], b: wave_gpu.f32[:], out: wave_gpu.f32[:], n: wave_gpu.u32):
+    gid = wave_gpu.thread_id()
+    if gid < n:
+        out[gid] = a[gid] + b[gid]
+
+a = wave_gpu.array([1.0, 2.0, 3.0, 4.0])
+b = wave_gpu.array([5.0, 6.0, 7.0, 8.0])
+out = wave_gpu.zeros(4)
+vector_add(a, b, out, len(a))
+print(out.to_list())  # [6.0, 8.0, 10.0, 12.0]
+```
+
+## License
+
+Apache 2.0 - see [LICENSE](../../LICENSE)

wave_gpu-0.1.0/README.md

@@ -0,0 +1,31 @@
+# WAVE Python SDK
+
+Write GPU kernels in Python, run on any GPU.
+
+## Install
+
+```bash
+pip install wave-gpu
+```
+
+## Usage
+
+```python
+import wave_gpu
+
+@wave_gpu.kernel
+def vector_add(a: wave_gpu.f32[:], b: wave_gpu.f32[:], out: wave_gpu.f32[:], n: wave_gpu.u32):
+    gid = wave_gpu.thread_id()
+    if gid < n:
+        out[gid] = a[gid] + b[gid]
+
+a = wave_gpu.array([1.0, 2.0, 3.0, 4.0])
+b = wave_gpu.array([5.0, 6.0, 7.0, 8.0])
+out = wave_gpu.zeros(4)
+vector_add(a, b, out, len(a))
+print(out.to_list())  # [6.0, 8.0, 10.0, 12.0]
+```
+
+## License
+
+Apache 2.0 - see [LICENSE](../../LICENSE)

wave_gpu-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[project]
+name = "wave-gpu"
+version = "0.1.0"
+description = "Write GPU kernels in Python, run on any GPU"
+authors = [{name = "Ojima Abraham"}]
+license = {text = "Apache-2.0"}
+requires-python = ">=3.9"
+readme = "README.md"
+dependencies = []
+keywords = ["gpu", "cuda", "metal", "hip", "sycl", "compute"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3",
+]
+
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[project.urls]
+Homepage = "https://wave.ojima.me"
+Repository = "https://github.com/Oabraham1/wave"

wave_gpu-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

wave_gpu-0.1.0/src/wave_gpu/__init__.py

@@ -0,0 +1,55 @@
+# Copyright 2026 Ojima Abraham
+# SPDX-License-Identifier: Apache-2.0
+
+"""WAVE GPU SDK for Python.
+
+Write GPU kernels in Python, run on any GPU. Supports Apple Metal,
+NVIDIA CUDA, AMD ROCm, Intel SYCL, and a built-in emulator.
+"""
+
+from .array import WaveArray, array, ones, zeros
+from .device import DeviceInfo, device
+from .kernel import kernel
+from .types import f16, f32, f64, i32, u32
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "WaveArray",
+    "array",
+    "ones",
+    "zeros",
+    "DeviceInfo",
+    "device",
+    "kernel",
+    "f16",
+    "f32",
+    "f64",
+    "i32",
+    "u32",
+]
+
+
+def thread_id() -> int:
+    """Placeholder for thread_id() intrinsic used in kernel source."""
+    raise RuntimeError("thread_id() can only be called inside a @kernel function")
+
+
+def workgroup_id() -> int:
+    """Placeholder for workgroup_id() intrinsic used in kernel source."""
+    raise RuntimeError("workgroup_id() can only be called inside a @kernel function")
+
+
+def lane_id() -> int:
+    """Placeholder for lane_id() intrinsic used in kernel source."""
+    raise RuntimeError("lane_id() can only be called inside a @kernel function")
+
+
+def wave_width() -> int:
+    """Placeholder for wave_width() intrinsic used in kernel source."""
+    raise RuntimeError("wave_width() can only be called inside a @kernel function")
+
+
+def barrier() -> None:
+    """Placeholder for barrier() intrinsic used in kernel source."""
+    raise RuntimeError("barrier() can only be called inside a @kernel function")

wave_gpu-0.1.0/src/wave_gpu/array.py

@@ -0,0 +1,42 @@
+# Copyright 2026 Ojima Abraham
+# SPDX-License-Identifier: Apache-2.0
+
+"""Array types for WAVE GPU kernel data."""
+
+from typing import List, Sequence, Union
+
+
+class WaveArray:
+    """CPU-side array that can be passed to WAVE GPU kernels."""
+
+    def __init__(self, data: Sequence[Union[int, float]], dtype: str = "f32") -> None:
+        self.data: List[float] = [float(x) for x in data]
+        self.dtype: str = dtype
+
+    def to_list(self) -> List[float]:
+        """Return the array contents as a Python list."""
+        return list(self.data)
+
+    def __len__(self) -> int:
+        return len(self.data)
+
+    def __getitem__(self, idx: int) -> float:
+        return self.data[idx]
+
+    def __repr__(self) -> str:
+        return f"WaveArray({self.data}, dtype='{self.dtype}')"
+
+
+def array(data: Sequence[Union[int, float]], dtype: str = "f32") -> WaveArray:
+    """Create a WAVE array from a Python sequence."""
+    return WaveArray(data, dtype)
+
+
+def zeros(n: int, dtype: str = "f32") -> WaveArray:
+    """Create a zero-filled WAVE array."""
+    return WaveArray([0.0] * n, dtype)
+
+
+def ones(n: int, dtype: str = "f32") -> WaveArray:
+    """Create a WAVE array filled with ones."""
+    return WaveArray([1.0] * n, dtype)

wave_gpu-0.1.0/src/wave_gpu/device.py

@@ -0,0 +1,69 @@
+# Copyright 2026 Ojima Abraham
+# SPDX-License-Identifier: Apache-2.0
+
+"""GPU detection for the WAVE Python SDK."""
+
+import platform
+import subprocess
+from typing import Tuple
+
+
+class DeviceInfo:
+    """Detected GPU device information."""
+
+    def __init__(self, vendor: str, name: str) -> None:
+        self.vendor: str = vendor
+        self.name: str = name
+
+    def __repr__(self) -> str:
+        return self.name
+
+
+def detect_gpu() -> Tuple[str, str]:
+    """Detect the best available GPU.
+
+    Returns a (vendor, name) tuple. Vendor is one of: 'apple', 'nvidia',
+    'amd', 'intel', 'emulator'.
+    """
+    if platform.system() == "Darwin":
+        return ("apple", "Apple GPU (Metal)")
+
+    try:
+        result = subprocess.run(
+            ["nvidia-smi", "--query-gpu=name", "--format=csv,noheader"],
+            capture_output=True,
+            check=True,
+            text=True,
+        )
+        name = result.stdout.strip().split("\n")[0]
+        return ("nvidia", f"{name} (CUDA)")
+    except (FileNotFoundError, subprocess.CalledProcessError):
+        pass
+
+    try:
+        result = subprocess.run(
+            ["rocminfo"], capture_output=True, check=True, text=True
+        )
+        if "gfx" in result.stdout:
+            for line in result.stdout.splitlines():
+                if "Marketing Name" in line:
+                    name = line.split(":", 1)[1].strip()
+                    return ("amd", f"{name} (ROCm)")
+            return ("amd", "AMD GPU (ROCm)")
+    except (FileNotFoundError, subprocess.CalledProcessError):
+        pass
+
+    try:
+        result = subprocess.run(["sycl-ls"], capture_output=True, check=True, text=True)
+        if "level_zero:gpu" in result.stdout or "opencl:gpu" in result.stdout:
+            return ("intel", "Intel GPU (SYCL)")
+    except (FileNotFoundError, subprocess.CalledProcessError):
+        pass
+
+    return ("emulator", "WAVE Emulator (no GPU)")
+
+
+def device() -> DeviceInfo:
+    """Detect and return the best available GPU device."""
+    vendor, name = detect_gpu()
+    return DeviceInfo(vendor, name)

wave_gpu-0.1.0/src/wave_gpu/kernel.py

@@ -0,0 +1,64 @@
+# Copyright 2026 Ojima Abraham
+# SPDX-License-Identifier: Apache-2.0
+
+"""Kernel decorator and compilation for the WAVE Python SDK."""
+
+import inspect
+import textwrap
+from typing import Any, Callable, List, Optional
+
+from .array import WaveArray
+from .runtime import CompiledKernel
+
+
+class KernelWrapper:
+    """Wraps a Python function as a WAVE GPU kernel."""
+
+    def __init__(self, func: Callable[..., Any]) -> None:
+        self._func = func
+        self._source = textwrap.dedent(inspect.getsource(func))
+        self._compiled: Optional[CompiledKernel] = None
+
+    def _ensure_compiled(self) -> CompiledKernel:
+        if self._compiled is None:
+            self._compiled = CompiledKernel(self._source, "python")
+        return self._compiled
+
+    def __call__(self, *args: Any, **kwargs: Any) -> None:
+        """Launch the kernel with the given arguments.
+
+        Buffer arguments (WaveArray) are passed as device buffers.
+        Scalar arguments (int) are passed as kernel parameters.
+        """
+        grid = kwargs.get("grid", (1, 1, 1))
+        workgroup = kwargs.get("workgroup", (256, 1, 1))
+
+        buffers: List[WaveArray] = []
+        scalars: List[int] = []
+
+        for arg in args:
+            if isinstance(arg, WaveArray):
+                buffers.append(arg)
+            elif isinstance(arg, (int, float)):
+                scalars.append(int(arg))
+            else:
+                raise TypeError(
+                    f"Unsupported argument type: {type(arg).__name__}. "
+                    "Expected WaveArray or int."
+                )
+
+        compiled = self._ensure_compiled()
+
+        n_threads = max(len(b) for b in buffers) if buffers else 1
+        if grid == (1, 1, 1) and workgroup == (256, 1, 1):
+            wg_size = min(256, n_threads)
+            n_groups = (n_threads + wg_size - 1) // wg_size
+            grid = (n_groups, 1, 1)
+            workgroup = (wg_size, 1, 1)
+
+        compiled.launch(buffers, scalars, grid, workgroup)
+
+
+def kernel(func: Callable[..., Any]) -> KernelWrapper:
+    """Decorator that marks a Python function as a WAVE GPU kernel."""
+    return KernelWrapper(func)

wave_gpu-0.1.0/src/wave_gpu/runtime.py

@@ -0,0 +1,210 @@
+# Copyright 2026 Ojima Abraham
+# SPDX-License-Identifier: Apache-2.0
+
+"""Full pipeline orchestration for the WAVE Python SDK.
+
+Handles compilation, backend translation, and kernel launch by calling
+the WAVE tool chain via subprocess.
+"""
+
+import os
+import struct
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+from .array import WaveArray
+from .device import detect_gpu
+
+_VENDOR_TO_LANG = {
+    "apple": "metal",
+    "nvidia": "ptx",
+    "amd": "hip",
+    "intel": "sycl",
+}
+
+
+def _find_tool(name: str) -> str:
+    """Find a WAVE tool binary, checking target/release/ first, then PATH."""
+    repo_root = Path(__file__).resolve().parents[5]
+    release_path = repo_root / "target" / "release" / name
+    if release_path.exists():
+        return str(release_path)
+
+    debug_path = repo_root / "target" / "debug" / name
+    if debug_path.exists():
+        return str(debug_path)
+
+    for crate_dir in repo_root.iterdir():
+        if crate_dir.name.startswith("wave-") and crate_dir.is_dir():
+            candidate = crate_dir / "target" / "release" / name
+            if candidate.exists():
+                return str(candidate)
+            candidate = crate_dir / "target" / "debug" / name
+            if candidate.exists():
+                return str(candidate)
+
+    return name
+
+
+def compile_kernel(source: str, language: str = "python") -> bytes:
+    """Compile kernel source to WAVE binary (.wbin) bytes."""
+    compiler = _find_tool("wave-compiler")
+
+    ext_map = {"python": ".py", "rust": ".rs", "cpp": ".cpp", "typescript": ".ts"}
+    ext = ext_map.get(language, ".py")
+
+    with tempfile.NamedTemporaryFile(suffix=ext, mode="w", delete=False) as f:
+        f.write(source)
+        src_path = f.name
+
+    wbin_path = src_path + ".wbin"
+
+    try:
+        result = subprocess.run(
+            [compiler, src_path, "-o", wbin_path, "-l", language],
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode != 0:
+            raise RuntimeError(f"Compilation failed:\n{result.stderr}\n{result.stdout}")
+        with open(wbin_path, "rb") as f:
+            return f.read()
+    finally:
+        for p in [src_path, wbin_path]:
+            try:
+                os.unlink(p)
+            except OSError:
+                pass
+
+
+def translate_wbin(wbin: bytes, vendor: str) -> str:
+    """Translate .wbin to vendor-specific source code."""
+    if vendor == "emulator":
+        raise ValueError("Emulator does not need backend translation")
+
+    backend_name = f"wave-{_VENDOR_TO_LANG[vendor]}"
+    backend = _find_tool(backend_name)
+
+    with tempfile.NamedTemporaryFile(suffix=".wbin", delete=False) as f:
+        f.write(wbin)
+        wbin_path = f.name
+
+    try:
+        result = subprocess.run(
+            [backend, wbin_path],
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode != 0:
+            raise RuntimeError(
+                f"Backend translation failed:\n{result.stderr}\n{result.stdout}"
+            )
+        return result.stdout
+    finally:
+        try:
+            os.unlink(wbin_path)
+        except OSError:
+            pass
+
+
+def launch_emulator(
+    wbin: bytes,
+    buffers: List[WaveArray],
+    scalars: List[int],
+    grid: Tuple[int, int, int],
+    workgroup: Tuple[int, int, int],
+) -> None:
+    """Launch a kernel on the WAVE emulator."""
+    emulator = _find_tool("wave-emu")
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        wbin_path = os.path.join(tmpdir, "kernel.wbin")
+        with open(wbin_path, "wb") as f:
+            f.write(wbin)
+
+        mem_path = os.path.join(tmpdir, "memory.bin")
+        offsets: List[int] = []
+        offset = 0
+
+        mem_data = bytearray()
+        for buf in buffers:
+            offsets.append(offset)
+            for val in buf.data:
+                mem_data.extend(struct.pack("<f", val))
+            offset += len(buf.data) * 4
+
+        with open(mem_path, "wb") as f:
+            f.write(mem_data)
+
+        cmd = [
+            emulator,
+            wbin_path,
+            "--memory-file",
+            mem_path,
+            "--grid",
+            f"{grid[0]},{grid[1]},{grid[2]}",
+            "--workgroup",
+            f"{workgroup[0]},{workgroup[1]},{workgroup[2]}",
+        ]
+
+        for i, off in enumerate(offsets):
+            cmd.extend(["--reg", f"{i}={off}"])
+        for i, scalar in enumerate(scalars):
+            cmd.extend(["--reg", f"{len(buffers) + i}={scalar}"])
+
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        if result.returncode != 0:
+            raise RuntimeError(
+                f"Emulator execution failed:\n{result.stderr}\n{result.stdout}"
+            )
+
+        with open(mem_path, "rb") as f:
+            mem_data = bytearray(f.read())
+
+        offset = 0
+        for buf in buffers:
+            size = len(buf.data) * 4
+            chunk = mem_data[offset : offset + size]
+            buf.data = [
+                struct.unpack("<f", chunk[j : j + 4])[0]
+                for j in range(0, len(chunk), 4)
+            ]
+            offset += size
+
+
+class CompiledKernel:
+    """A compiled WAVE kernel ready for launch."""
+
+    def __init__(self, source: str, language: str = "python") -> None:
+        self._source = source
+        self._language = language
+        self._wbin: Optional[bytes] = None
+        self._vendor_cache: Dict[str, str] = {}
+
+    def _ensure_compiled(self) -> bytes:
+        if self._wbin is None:
+            self._wbin = compile_kernel(self._source, self._language)
+        return self._wbin
+
+    def launch(
+        self,
+        buffers: List[WaveArray],
+        scalars: List[int],
+        grid: Tuple[int, int, int] = (1, 1, 1),
+        workgroup: Tuple[int, int, int] = (256, 1, 1),
+    ) -> None:
+        """Launch the kernel with the given arguments."""
+        wbin = self._ensure_compiled()
+        vendor, _ = detect_gpu()
+
+        if vendor == "emulator":
+            launch_emulator(wbin, buffers, scalars, grid, workgroup)
+        else:
+            if vendor not in self._vendor_cache:
+                self._vendor_cache[vendor] = translate_wbin(wbin, vendor)
+            raise NotImplementedError(
+                f"Direct {vendor} launch not yet implemented in Python SDK. "
+                "Use the emulator or the Rust SDK."
+            )

wave_gpu-0.1.0/src/wave_gpu/types.py

@@ -0,0 +1,26 @@
+# Copyright 2026 Ojima Abraham
+# SPDX-License-Identifier: Apache-2.0
+
+"""Type annotations for WAVE GPU kernel parameters."""
+
+from typing import Any
+
+
+class _TypeDescriptor:
+    """Base class for WAVE type annotations used in kernel signatures."""
+
+    def __init__(self, name: str) -> None:
+        self._name = name
+
+    def __repr__(self) -> str:
+        return self._name
+
+    def __getitem__(self, _key: Any) -> "_TypeDescriptor":
+        return _TypeDescriptor(f"{self._name}[]")
+
+
+f32 = _TypeDescriptor("f32")
+f64 = _TypeDescriptor("f64")
+f16 = _TypeDescriptor("f16")
+u32 = _TypeDescriptor("u32")
+i32 = _TypeDescriptor("i32")

wave_gpu-0.1.0/src/wave_gpu.egg-info/PKG-INFO

@@ -0,0 +1,46 @@
+Metadata-Version: 2.4
+Name: wave-gpu
+Version: 0.1.0
+Summary: Write GPU kernels in Python, run on any GPU
+Author: Ojima Abraham
+License: Apache-2.0
+Project-URL: Homepage, https://wave.ojima.me
+Project-URL: Repository, https://github.com/Oabraham1/wave
+Keywords: gpu,cuda,metal,hip,sycl,compute
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# WAVE Python SDK
+
+Write GPU kernels in Python, run on any GPU.
+
+## Install
+
+```bash
+pip install wave-gpu
+```
+
+## Usage
+
+```python
+import wave_gpu
+
+@wave_gpu.kernel
+def vector_add(a: wave_gpu.f32[:], b: wave_gpu.f32[:], out: wave_gpu.f32[:], n: wave_gpu.u32):
+    gid = wave_gpu.thread_id()
+    if gid < n:
+        out[gid] = a[gid] + b[gid]
+
+a = wave_gpu.array([1.0, 2.0, 3.0, 4.0])
+b = wave_gpu.array([5.0, 6.0, 7.0, 8.0])
+out = wave_gpu.zeros(4)
+vector_add(a, b, out, len(a))
+print(out.to_list())  # [6.0, 8.0, 10.0, 12.0]
+```
+
+## License
+
+Apache 2.0 - see [LICENSE](../../LICENSE)

wave_gpu-0.1.0/src/wave_gpu.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+README.md
+pyproject.toml
+src/wave_gpu/__init__.py
+src/wave_gpu/array.py
+src/wave_gpu/device.py
+src/wave_gpu/kernel.py
+src/wave_gpu/runtime.py
+src/wave_gpu/types.py
+src/wave_gpu.egg-info/PKG-INFO
+src/wave_gpu.egg-info/SOURCES.txt
+src/wave_gpu.egg-info/dependency_links.txt
+src/wave_gpu.egg-info/top_level.txt
+tests/test_array.py
+tests/test_device.py
+tests/test_kernel.py
+tests/test_vector_add.py

wave_gpu-0.1.0/src/wave_gpu.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

wave_gpu-0.1.0/src/wave_gpu.egg-info/top_level.txt

@@ -0,0 +1 @@
+wave_gpu

wave_gpu-0.1.0/tests/test_array.py

@@ -0,0 +1,47 @@
+# Copyright 2026 Ojima Abraham
+# SPDX-License-Identifier: Apache-2.0
+
+"""Tests for the WaveArray type."""
+
+import wave_gpu
+
+
+def test_array_creation():
+    a = wave_gpu.array([1.0, 2.0, 3.0])
+    assert len(a) == 3
+    assert a[0] == 1.0
+    assert a[1] == 2.0
+    assert a[2] == 3.0
+
+
+def test_array_to_list():
+    a = wave_gpu.array([1.0, 2.0, 3.0, 4.0])
+    assert a.to_list() == [1.0, 2.0, 3.0, 4.0]
+
+
+def test_zeros():
+    a = wave_gpu.zeros(5)
+    assert len(a) == 5
+    assert a.to_list() == [0.0, 0.0, 0.0, 0.0, 0.0]
+
+
+def test_ones():
+    a = wave_gpu.ones(3)
+    assert len(a) == 3
+    assert a.to_list() == [1.0, 1.0, 1.0]
+
+
+def test_array_dtype():
+    a = wave_gpu.array([1, 2, 3], dtype="u32")
+    assert a.dtype == "u32"
+    assert a.to_list() == [1.0, 2.0, 3.0]
+
+
+def test_array_from_integers():
+    a = wave_gpu.array([1, 2, 3])
+    assert a.to_list() == [1.0, 2.0, 3.0]
+
+
+def test_array_repr():
+    a = wave_gpu.array([1.0, 2.0])
+    assert "WaveArray" in repr(a)

wave_gpu-0.1.0/tests/test_device.py

@@ -0,0 +1,17 @@
+# Copyright 2026 Ojima Abraham
+# SPDX-License-Identifier: Apache-2.0
+
+"""Tests for GPU device detection."""
+
+import wave_gpu
+
+
+def test_device_returns_info():
+    dev = wave_gpu.device()
+    assert dev.vendor in ("apple", "nvidia", "amd", "intel", "emulator")
+    assert len(dev.name) > 0
+
+
+def test_device_repr():
+    dev = wave_gpu.device()
+    assert len(repr(dev)) > 0

wave_gpu-0.1.0/tests/test_kernel.py

@@ -0,0 +1,38 @@
+# Copyright 2026 Ojima Abraham
+# SPDX-License-Identifier: Apache-2.0
+
+"""Tests for kernel compilation and the @kernel decorator."""
+
+import pytest
+
+import wave_gpu
+
+
+def test_kernel_decorator():
+    @wave_gpu.kernel
+    def vector_add(a, b, out, n):
+        gid = wave_gpu.thread_id()
+        if gid < n:
+            out[gid] = a[gid] + b[gid]
+
+    assert hasattr(vector_add, "_source")
+    assert "vector_add" in vector_add._source
+
+
+def test_thread_id_outside_kernel():
+    with pytest.raises(RuntimeError, match="inside a @kernel"):
+        wave_gpu.thread_id()
+
+
+def test_barrier_outside_kernel():
+    with pytest.raises(RuntimeError, match="inside a @kernel"):
+        wave_gpu.barrier()
+
+
+def test_kernel_bad_arg_type():
+    @wave_gpu.kernel
+    def noop(x):
+        pass
+
+    with pytest.raises(TypeError, match="Unsupported argument type"):
+        noop("not a valid arg")

wave_gpu-0.1.0/tests/test_vector_add.py

@@ -0,0 +1,39 @@
+# Copyright 2026 Ojima Abraham
+# SPDX-License-Identifier: Apache-2.0
+
+"""End-to-end vector addition test using the runtime compilation pipeline."""
+
+import pytest
+
+import wave_gpu
+from wave_gpu.runtime import compile_kernel
+
+
+@pytest.mark.skipif(
+    True,
+    reason="Requires wave-compiler binary on PATH or in target/",
+)
+def test_vector_add_e2e():
+    """Full end-to-end: compile + launch vector_add on emulator."""
+    a = wave_gpu.array([1.0, 2.0, 3.0, 4.0])
+    b = wave_gpu.array([5.0, 6.0, 7.0, 8.0])
+    out = wave_gpu.zeros(4)
+
+    @wave_gpu.kernel
+    def vector_add(
+        a: wave_gpu.f32[:],
+        b: wave_gpu.f32[:],
+        out: wave_gpu.f32[:],
+        n: wave_gpu.u32,
+    ):
+        gid = wave_gpu.thread_id()
+        if gid < n:
+            out[gid] = a[gid] + b[gid]
+
+    vector_add(a, b, out, len(a))
+    assert out.to_list() == [6.0, 8.0, 10.0, 12.0]
+
+
+def test_compile_kernel_source():
+    """Test that compile_kernel function exists and has correct signature."""
+    assert callable(compile_kernel)