PyParticles3 0.4.0rc1__tar.gz → 0.4.0rc2__tar.gz

{pyparticles3-0.4.0rc1 → pyparticles3-0.4.0rc2}/CHANGELOG.md

@@ -2,9 +2,30 @@
 
 All notable changes to the modernized distribution are documented here.
 
+## 0.4.0rc2 - release candidate
+
+Follow-up release candidate based on installation and multi-ICD validation of `0.4.0rc1`.
+
+### OpenCL/OpenGL interoperability
+
+- document that `PyParticles3[opencl]` guarantees OpenCL compute support but does not guarantee a PyOpenCL build with OpenGL interoperability;
+- add an explicit runtime warning when `pyopencl.have_gl()` is `False`;
+- document rebuilding PyOpenCL from source with `PYOPENCL_ENABLE_GL=ON` and verifying `pyopencl.have_gl() is True`;
+- preserve an explicit `PYOPENCL_CTX` device selection when creating a CL/GL sharing context;
+- do not silently migrate an explicitly selected Intel CPU OpenCL workload to an NVIDIA GPU merely to obtain `cl_khr_gl_sharing`;
+- improve CL/GL failure messages so host-synchronized fallback identifies why sharing is unavailable.
+
+### Validation
+
+- validated OpenCL gravity kernels on NVIDIA GTX 1060 and Intel Xeon E5-2697 v2 OpenCL implementations;
+- validated CPU/OpenCL numerical agreement over complete Euler integration runs;
+- validated persistent X/V device residency and transfer accounting;
+- validated clean PyPI installation and all published CLI entry points;
+- validated the high-performance fountain CL/GL path with a GL-enabled PyOpenCL build.
+
 ## 0.4.0rc1 - release candidate
 
-First release candidate planned under the **PyParticles3** distribution name.
+First release candidate under the **PyParticles3** distribution name.
 
 ### Packaging
 

{pyparticles3-0.4.0rc1/PyParticles3.egg-info → pyparticles3-0.4.0rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyParticles3
-Version: 0.4.0rc1
+Version: 0.4.0rc2
 Summary: Modern educational particle simulation toolbox with OpenCL/OpenGL acceleration
 Author: Simone Riva
 Maintainer: jamaj69
@@ -64,15 +64,13 @@ The goal is to preserve the original project's unusually clear, educational arch
 
 ## Installation
 
-The first PyPI release is planned as `PyParticles3 0.4.0rc1`.
-
-Once published:
+The current release candidate is `PyParticles3 0.4.0rc2`.
 
 ```bash
 python -m pip install PyParticles3
 ```
 
-For OpenCL support:
+For OpenCL compute support:
 
 ```bash
 python -m pip install 'PyParticles3[opencl]'
@@ -80,6 +78,66 @@ python -m pip install 'PyParticles3[opencl]'
 
 The OpenCL runtime/ICD and an OpenGL/FreeGLUT implementation are system-level dependencies and are not installed by pip.
 
+### OpenCL/OpenGL interoperability requires a GL-enabled PyOpenCL build
+
+`PyParticles3[opencl]` installs PyOpenCL and is sufficient for OpenCL **compute**. It does **not** guarantee that the installed PyOpenCL binary was compiled with OpenGL interoperability enabled.
+
+Check the installed build with:
+
+```bash
+python - <<'PY'
+import pyopencl as cl
+print("PyOpenCL:", cl.VERSION_TEXT)
+print("have_gl :", cl.have_gl())
+PY
+```
+
+For the fast OpenCL/OpenGL shared-buffer path used by the `fountain` demo, the required result is:
+
+```text
+have_gl : True
+```
+
+If a PyPI wheel reports `have_gl : False`, OpenCL compute still works, but PyParticles3 cannot create `GLBuffer` objects and high-particle-count rendering must fall back to host synchronization. That fallback can be dramatically slower.
+
+PyOpenCL's source-build documentation requires `PYOPENCL_ENABLE_GL=ON` to enable GL interoperability. A typical pip rebuild is:
+
+```bash
+python -m pip uninstall -y pyopencl
+
+PYOPENCL_ENABLE_GL=ON \
+python -m pip install \
+    --no-binary=pyopencl \
+    --no-cache-dir \
+    -v \
+    'pyopencl>=2026.1'
+```
+
+Then verify again:
+
+```bash
+python - <<'PY'
+import pyopencl as cl
+assert cl.have_gl(), "PyOpenCL was built without OpenGL interoperability"
+print("PyOpenCL GL interoperability: enabled")
+PY
+```
+
+Building PyOpenCL from source also requires a C++17 compiler, Python/build dependencies, OpenCL headers and loader libraries, and OpenGL development headers appropriate to the operating system.
+
+## Selecting an OpenCL device
+
+PyParticles3 follows PyOpenCL's `PYOPENCL_CTX` selection for compute contexts. For example, on a system where platform 0 is an NVIDIA GPU and platform 1 is an Intel CPU:
+
+```bash
+PYOPENCL_CTX=0:0 pyparticles3 --demo fountain
+PYOPENCL_CTX=1:0 pyparticles3 --demo fountain
+```
+
+As of `0.4.0rc2`, an explicit `PYOPENCL_CTX` selection is also honored when PyParticles3 attempts to create a CL/GL sharing context. PyParticles3 will not silently move the simulation to another OpenCL device just because that other device supports `cl_khr_gl_sharing`.
+
+This matters on mixed systems. An Intel Xeon CPU OpenCL device can execute the simulation kernels but may not advertise or support `cl_khr_gl_sharing` with the active NVIDIA OpenGL context. In that case PyParticles3 keeps the selected Intel compute device and falls back to host-synchronized rendering instead of silently switching compute to the NVIDIA GPU.
+
 ## Current import namespace
 
 The initial PyParticles3 packaging release intentionally keeps the historical Python import namespace:

pyparticles3-0.4.0rc2/PUBLISHING.md

@@ -0,0 +1,179 @@
+# Publishing PyParticles3 to PyPI
+
+This repository is prepared to publish the `PyParticles3` distribution through PyPI Trusted Publishing.
+
+## Why Trusted Publishing
+
+The release workflow uses GitHub Actions OIDC instead of storing a long-lived PyPI API token in the repository. PyPI issues a short-lived credential to the trusted workflow at publication time.
+
+## PyPI publisher configuration
+
+The PyPI project is published from this GitHub repository with these values:
+
+```text
+PyPI project name : PyParticles3
+GitHub owner      : jamaj69
+Repository        : pyparticles
+Workflow          : release.yml
+Environment       : pypi
+```
+
+## GitHub environment
+
+The release workflow uses the GitHub Actions environment:
+
+```text
+pypi
+```
+
+For a public release project, required reviewers on this environment are recommended so a tag cannot publish without an explicit approval step.
+
+## Release candidates
+
+The first published candidate was:
+
+```text
+PyParticles3 0.4.0rc1
+```
+
+The current candidate is:
+
+```text
+PyParticles3 0.4.0rc2
+```
+
+`0.4.0rc2` adds explicit diagnostics for PyOpenCL builds without GL interoperability and ensures that an explicit `PYOPENCL_CTX` selection is not silently replaced by another device when CL/GL sharing is attempted.
+
+After CI is green, publish the candidate with:
+
+```bash
+git tag -a v0.4.0rc2 -m "PyParticles3 0.4.0rc2"
+git push origin v0.4.0rc2
+```
+
+`.github/workflows/release.yml` will:
+
+1. build the wheel and source distribution;
+2. run `twine check`;
+3. pass the artifacts to a separate publish job;
+4. request an OIDC publishing credential;
+5. upload the release to PyPI.
+
+## Repository references shown by PyPI
+
+`pyproject.toml` declares:
+
+```text
+Homepage       https://github.com/jamaj69/pyparticles
+Source         https://github.com/jamaj69/pyparticles
+Documentation  https://github.com/jamaj69/pyparticles#readme
+Issues         https://github.com/jamaj69/pyparticles/issues
+Original       https://github.com/simon-r/PyParticles
+```
+
+Because releases are uploaded through GitHub Trusted Publishing from `jamaj69/pyparticles`, PyPI can verify links belonging to that GitHub repository.
+
+## Release discipline
+
+Do not reuse a version already uploaded to PyPI. If a release artifact must change, increment the version first.
+
+Recommended sequence:
+
+```text
+0.4.0rc1
+0.4.0rc2
+0.4.0rc3   (only if another release candidate is needed)
+0.4.0
+```
+
+## Local verification before tagging
+
+```bash
+python -m pip install -U build twine
+rm -rf build dist *.egg-info
+python -m build
+python -m twine check dist/*
+```
+
+Then test the wheel in a clean environment, outside the source tree:
+
+```bash
+python -m venv /tmp/pyparticles3-release-test
+source /tmp/pyparticles3-release-test/bin/activate
+cd /tmp
+unset PYTHONPATH
+python -m pip install '/path/to/dist/PyParticles3-0.4.0rc2-py3-none-any.whl[opencl]'
+python -m pip check
+pyparticles3 --version
+```
+
+## OpenCL compute validation
+
+List available platforms/devices and test each desired ICD explicitly. For example:
+
+```bash
+python - <<'PY'
+import pyopencl as cl
+for pi, platform in enumerate(cl.get_platforms()):
+    for di, device in enumerate(platform.get_devices()):
+        print(f"{pi}:{di}  {platform.name}  {device.name}")
+PY
+```
+
+Then select devices with `PYOPENCL_CTX`, for example:
+
+```bash
+PYOPENCL_CTX=0:0 pyparticles3 --demo fountain
+PYOPENCL_CTX=1:0 pyparticles3 --demo fountain
+```
+
+The selected device must remain the selected compute device. `0.4.0rc2` must not silently migrate an explicit Intel CPU selection to an NVIDIA GPU merely to obtain CL/GL sharing.
+
+## CL/GL release validation
+
+The optional `opencl` extra guarantees PyOpenCL compute support only. A PyOpenCL wheel may report:
+
+```text
+have_gl : False
+```
+
+For CL/GL validation, verify:
+
+```bash
+python - <<'PY'
+import pyopencl as cl
+print("PyOpenCL:", cl.VERSION_TEXT)
+print("have_gl :", cl.have_gl())
+PY
+```
+
+The shared-buffer fountain path requires:
+
+```text
+have_gl : True
+```
+
+If necessary, rebuild PyOpenCL from source with GL support:
+
+```bash
+python -m pip uninstall -y pyopencl
+
+PYOPENCL_ENABLE_GL=ON \
+python -m pip install \
+    --no-binary=pyopencl \
+    --no-cache-dir \
+    -v \
+    'pyopencl>=2026.1'
+```
+
+Then require the result programmatically:
+
+```bash
+python - <<'PY'
+import pyopencl as cl
+assert cl.have_gl(), "PyOpenCL was built without OpenGL interoperability"
+print("PyOpenCL GL interoperability: enabled")
+PY
+```
+
+A selected OpenCL device that cannot share the active OpenGL context is allowed to fall back to host-synchronized rendering, but the fallback must be explicit and the compute device must not silently change.

{pyparticles3-0.4.0rc1 → pyparticles3-0.4.0rc2/PyParticles3.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyParticles3
-Version: 0.4.0rc1
+Version: 0.4.0rc2
 Summary: Modern educational particle simulation toolbox with OpenCL/OpenGL acceleration
 Author: Simone Riva
 Maintainer: jamaj69
@@ -64,15 +64,13 @@ The goal is to preserve the original project's unusually clear, educational arch
 
 ## Installation
 
-The first PyPI release is planned as `PyParticles3 0.4.0rc1`.
-
-Once published:
+The current release candidate is `PyParticles3 0.4.0rc2`.
 
 ```bash
 python -m pip install PyParticles3
 ```
 
-For OpenCL support:
+For OpenCL compute support:
 
 ```bash
 python -m pip install 'PyParticles3[opencl]'
@@ -80,6 +78,66 @@ python -m pip install 'PyParticles3[opencl]'
 
 The OpenCL runtime/ICD and an OpenGL/FreeGLUT implementation are system-level dependencies and are not installed by pip.
 
+### OpenCL/OpenGL interoperability requires a GL-enabled PyOpenCL build
+
+`PyParticles3[opencl]` installs PyOpenCL and is sufficient for OpenCL **compute**. It does **not** guarantee that the installed PyOpenCL binary was compiled with OpenGL interoperability enabled.
+
+Check the installed build with:
+
+```bash
+python - <<'PY'
+import pyopencl as cl
+print("PyOpenCL:", cl.VERSION_TEXT)
+print("have_gl :", cl.have_gl())
+PY
+```
+
+For the fast OpenCL/OpenGL shared-buffer path used by the `fountain` demo, the required result is:
+
+```text
+have_gl : True
+```
+
+If a PyPI wheel reports `have_gl : False`, OpenCL compute still works, but PyParticles3 cannot create `GLBuffer` objects and high-particle-count rendering must fall back to host synchronization. That fallback can be dramatically slower.
+
+PyOpenCL's source-build documentation requires `PYOPENCL_ENABLE_GL=ON` to enable GL interoperability. A typical pip rebuild is:
+
+```bash
+python -m pip uninstall -y pyopencl
+
+PYOPENCL_ENABLE_GL=ON \
+python -m pip install \
+    --no-binary=pyopencl \
+    --no-cache-dir \
+    -v \
+    'pyopencl>=2026.1'
+```
+
+Then verify again:
+
+```bash
+python - <<'PY'
+import pyopencl as cl
+assert cl.have_gl(), "PyOpenCL was built without OpenGL interoperability"
+print("PyOpenCL GL interoperability: enabled")
+PY
+```
+
+Building PyOpenCL from source also requires a C++17 compiler, Python/build dependencies, OpenCL headers and loader libraries, and OpenGL development headers appropriate to the operating system.
+
+## Selecting an OpenCL device
+
+PyParticles3 follows PyOpenCL's `PYOPENCL_CTX` selection for compute contexts. For example, on a system where platform 0 is an NVIDIA GPU and platform 1 is an Intel CPU:
+
+```bash
+PYOPENCL_CTX=0:0 pyparticles3 --demo fountain
+PYOPENCL_CTX=1:0 pyparticles3 --demo fountain
+```
+
+As of `0.4.0rc2`, an explicit `PYOPENCL_CTX` selection is also honored when PyParticles3 attempts to create a CL/GL sharing context. PyParticles3 will not silently move the simulation to another OpenCL device just because that other device supports `cl_khr_gl_sharing`.
+
+This matters on mixed systems. An Intel Xeon CPU OpenCL device can execute the simulation kernels but may not advertise or support `cl_khr_gl_sharing` with the active NVIDIA OpenGL context. In that case PyParticles3 keeps the selected Intel compute device and falls back to host-synchronized rendering instead of silently switching compute to the NVIDIA GPU.
+
 ## Current import namespace
 
 The initial PyParticles3 packaging release intentionally keeps the historical Python import namespace:

{pyparticles3-0.4.0rc1 → pyparticles3-0.4.0rc2}/PyParticles3.egg-info/SOURCES.txt

@@ -144,6 +144,7 @@ pyparticles/utils/pypart_global.py
 pyparticles/utils/time_formatter.py
 tests/test_demo_compat.py
 tests/test_opencl_compute_only.py
+tests/test_opencl_device_selection.py
 tests/test_opencl_regression.py
 tests/test_opencl_residency.py
 tests/test_particles_set_compat.py

{pyparticles3-0.4.0rc1 → pyparticles3-0.4.0rc2}/README.md

@@ -23,15 +23,13 @@ The goal is to preserve the original project's unusually clear, educational arch
 
 ## Installation
 
-The first PyPI release is planned as `PyParticles3 0.4.0rc1`.
-
-Once published:
+The current release candidate is `PyParticles3 0.4.0rc2`.
 
 ```bash
 python -m pip install PyParticles3
 ```
 
-For OpenCL support:
+For OpenCL compute support:
 
 ```bash
 python -m pip install 'PyParticles3[opencl]'
@@ -39,6 +37,66 @@ python -m pip install 'PyParticles3[opencl]'
 
 The OpenCL runtime/ICD and an OpenGL/FreeGLUT implementation are system-level dependencies and are not installed by pip.
 
+### OpenCL/OpenGL interoperability requires a GL-enabled PyOpenCL build
+
+`PyParticles3[opencl]` installs PyOpenCL and is sufficient for OpenCL **compute**. It does **not** guarantee that the installed PyOpenCL binary was compiled with OpenGL interoperability enabled.
+
+Check the installed build with:
+
+```bash
+python - <<'PY'
+import pyopencl as cl
+print("PyOpenCL:", cl.VERSION_TEXT)
+print("have_gl :", cl.have_gl())
+PY
+```
+
+For the fast OpenCL/OpenGL shared-buffer path used by the `fountain` demo, the required result is:
+
+```text
+have_gl : True
+```
+
+If a PyPI wheel reports `have_gl : False`, OpenCL compute still works, but PyParticles3 cannot create `GLBuffer` objects and high-particle-count rendering must fall back to host synchronization. That fallback can be dramatically slower.
+
+PyOpenCL's source-build documentation requires `PYOPENCL_ENABLE_GL=ON` to enable GL interoperability. A typical pip rebuild is:
+
+```bash
+python -m pip uninstall -y pyopencl
+
+PYOPENCL_ENABLE_GL=ON \
+python -m pip install \
+    --no-binary=pyopencl \
+    --no-cache-dir \
+    -v \
+    'pyopencl>=2026.1'
+```
+
+Then verify again:
+
+```bash
+python - <<'PY'
+import pyopencl as cl
+assert cl.have_gl(), "PyOpenCL was built without OpenGL interoperability"
+print("PyOpenCL GL interoperability: enabled")
+PY
+```
+
+Building PyOpenCL from source also requires a C++17 compiler, Python/build dependencies, OpenCL headers and loader libraries, and OpenGL development headers appropriate to the operating system.
+
+## Selecting an OpenCL device
+
+PyParticles3 follows PyOpenCL's `PYOPENCL_CTX` selection for compute contexts. For example, on a system where platform 0 is an NVIDIA GPU and platform 1 is an Intel CPU:
+
+```bash
+PYOPENCL_CTX=0:0 pyparticles3 --demo fountain
+PYOPENCL_CTX=1:0 pyparticles3 --demo fountain
+```
+
+As of `0.4.0rc2`, an explicit `PYOPENCL_CTX` selection is also honored when PyParticles3 attempts to create a CL/GL sharing context. PyParticles3 will not silently move the simulation to another OpenCL device just because that other device supports `cl_khr_gl_sharing`.
+
+This matters on mixed systems. An Intel Xeon CPU OpenCL device can execute the simulation kernels but may not advertise or support `cl_khr_gl_sharing` with the active NVIDIA OpenGL context. In that case PyParticles3 keeps the selected Intel compute device and falls back to host-synchronized rendering instead of silently switching compute to the NVIDIA GPU.
+
 ## Current import namespace
 
 The initial PyParticles3 packaging release intentionally keeps the historical Python import namespace:

{pyparticles3-0.4.0rc1 → pyparticles3-0.4.0rc2}/pyparticles/pset/opencl_context.py

@@ -6,6 +6,8 @@
 # the Free Software Foundation, either version 3 of the License, or
 # (at your option) any later version.
 
+import os
+
 import numpy as np
 
 
@@ -50,6 +52,11 @@ class OpenCLcontext(object):
     context.  In GL-sharing mode normal particle arrays remain ordinary OpenCL
     buffers; a renderer may create :class:`pyopencl.GLBuffer` objects in the
     same context and copy positions VRAM-to-VRAM without crossing PCIe.
+
+    When ``PYOPENCL_CTX`` explicitly selects a device, GL-sharing context
+    creation honors that same selection.  PyParticles3 will not silently move
+    the simulation to a different OpenCL device merely because another device
+    supports ``cl_khr_gl_sharing``.
     """
 
     _VALID_NAMES = ("X", "V", "A", "M")
@@ -88,7 +95,8 @@ class OpenCLcontext(object):
         except Exception as exc:
             if self.__gl_sharing:
                 raise RuntimeError(
-                    "No OpenCL context could share the active OpenGL context"
+                    "No OpenCL context could share the active OpenGL context: %s"
+                    % exc
                 ) from exc
             raise RuntimeError("No usable OpenCL context could be created") from exc
 
@@ -110,30 +118,61 @@ class OpenCLcontext(object):
         }
         self.reset_transfer_stats()
 
+    def _gl_sharing_candidate_devices(self):
+        """Return candidate devices without overriding an explicit selection."""
+        selector = os.environ.get("PYOPENCL_CTX", "").strip()
+        if selector:
+            selected_context = cl.create_some_context(interactive=False)
+            devices = list(selected_context.devices)
+            if not devices:
+                raise RuntimeError(
+                    "PYOPENCL_CTX=%r did not select an OpenCL device" % selector
+                )
+            return devices, selector
+
+        devices = []
+        for platform in cl.get_platforms():
+            devices.extend(platform.get_devices())
+        return devices, None
+
     def _create_gl_sharing_context(self):
         if not hasattr(cl, "have_gl") or not cl.have_gl():
             raise RuntimeError("PyOpenCL was built without OpenGL interoperability")
 
         sharing = get_gl_sharing_context_properties()
+        candidates, selector = self._gl_sharing_candidate_devices()
         last_error = None
-        for platform in cl.get_platforms():
-            for device in platform.get_devices():
-                if "cl_khr_gl_sharing" not in device.extensions.split():
-                    continue
-
-                properties = [
-                    (cl.context_properties.PLATFORM, platform),
-                    *sharing,
-                ]
-                try:
-                    context = cl.Context(devices=[device], properties=properties)
-                except Exception as exc:
-                    last_error = exc
-                    continue
-
-                self.__platform = platform
-                self.__device = device
-                return context
+
+        for device in candidates:
+            platform = device.platform
+            if "cl_khr_gl_sharing" not in device.extensions.split():
+                if selector is not None:
+                    raise RuntimeError(
+                        "PYOPENCL_CTX=%s selected %s, which does not advertise "
+                        "cl_khr_gl_sharing"
+                        % (selector, device.name.strip())
+                    )
+                continue
+
+            properties = [
+                (cl.context_properties.PLATFORM, platform),
+                *sharing,
+            ]
+            try:
+                context = cl.Context(devices=[device], properties=properties)
+            except Exception as exc:
+                last_error = exc
+                if selector is not None:
+                    raise RuntimeError(
+                        "PYOPENCL_CTX=%s selected %s, but that device could not "
+                        "share the active OpenGL context: %s"
+                        % (selector, device.name.strip(), exc)
+                    ) from exc
+                continue
+
+            self.__platform = platform
+            self.__device = device
+            return context
 
         if last_error is not None:
             raise RuntimeError("No CL/GL sharing device accepted the active GL context") from last_error

{pyparticles3-0.4.0rc1 → pyparticles3-0.4.0rc2}/pyparticles/utils/pypart_global.py

@@ -22,7 +22,9 @@ import zlib
 v_major = 0
 v_minor = 4
 v_revision = 0
-v_prerelease = "rc1"
+v_prerelease = "rc2"
+
+_GL_INTEROP_WARNING_EMITTED = False
 
 
 def py_particle_version(r="s"):
@@ -37,6 +39,35 @@ def py_particle_version(r="s"):
     return (v_major, v_minor, v_revision)
 
 
+def _warn_if_pyopencl_lacks_gl(cl):
+    """Emit a one-time explanation when only compute OpenCL is available."""
+    global _GL_INTEROP_WARNING_EMITTED
+
+    if _GL_INTEROP_WARNING_EMITTED:
+        return
+
+    have_gl = getattr(cl, "have_gl", None)
+    if have_gl is None:
+        return
+
+    try:
+        gl_enabled = bool(have_gl())
+    except Exception:
+        return
+
+    if gl_enabled:
+        return
+
+    _GL_INTEROP_WARNING_EMITTED = True
+    print("")
+    print("WARNING: PyOpenCL was built without OpenGL interoperability (have_gl=False).")
+    print("OpenCL compute remains available, but CL/GL rendering will use host")
+    print("synchronization and can be much slower for large particle counts.")
+    print("For CL/GL interoperability, rebuild PyOpenCL from source with")
+    print("PYOPENCL_ENABLE_GL=ON and verify that pyopencl.have_gl() is True.")
+    print("")
+
+
 def test_pyopencl():
     """Return True only when PyOpenCL has at least one usable device."""
     try:
@@ -45,12 +76,16 @@ def test_pyopencl():
         return False
 
     try:
-        return any(platform.get_devices() for platform in cl.get_platforms())
+        usable = any(platform.get_devices() for platform in cl.get_platforms())
     except Exception:
         # Broken/missing ICDs may allow importing pyopencl while still making
         # every OpenCL operation unusable.
         return False
 
+    if usable:
+        _warn_if_pyopencl_lacks_gl(cl)
+    return usable
+
 
 def about():
     mail = zlib.decompress(

{pyparticles3-0.4.0rc1 → pyparticles3-0.4.0rc2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "PyParticles3"
-version = "0.4.0rc1"
+version = "0.4.0rc2"
 description = "Modern educational particle simulation toolbox with OpenCL/OpenGL acceleration"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.11"