Make node-ordering heuristics defensive instead of blaming available[0]

Addresses review feedback: the scheduler error path blamed available[0]
even when picking failed while inspecting a later ready node, misreporting
the node to the frontend.

Instead of threading the node id through the exception, make is_output and
is_async fully defensive. They are pure ordering heuristics, so a malformed
node (a FUNCTION typo, or schema-derived attributes that raise) just means
"not prioritized"; the node then runs through normal execution, where the
error is reported against the correct node. The stage_node_execution
try/except remains as a backstop only.

Add a test for a node whose attribute access raises during the heuristics.

.github/workflows/ci-cursor-review.yml

@@ -1,38 +0,0 @@
-name: CI - Cursor Review
-
-# Thin caller for the shared reusable cursor-review workflow in
-# Comfy-Org/github-workflows. The review logic (panel matrix, judge
-# consolidation, prompts, extract/post/notify scripts) lives there as the
-# single source of truth, so this repo only carries the repo-specific diff
-# excludes.
-
-on:
-  pull_request:
-    types: [labeled, unlabeled]
-
-concurrency:
-  group: cursor-review-pr-${{ github.event.pull_request.number }}-${{ github.event.label.name }}
-  cancel-in-progress: true
-
-jobs:
-  cursor-review:
-    if: github.event.label.name == 'cursor-review'
-    permissions:
-      contents: read
-      pull-requests: write
-    # SHA-pinned per zizmor `unpinned-uses: hash-pin`. Bump this SHA to pick up
-    # upstream changes; keep `workflows_ref` matching so prompts/scripts load
-    # from the same commit as the workflow definition.
-    uses: Comfy-Org/github-workflows/.github/workflows/cursor-review.yml@047ca48febe3a6647608ed2e0c4331b491cb9d6a # github-workflows#9
-    with:
-      workflows_ref: 047ca48febe3a6647608ed2e0c4331b491cb9d6a
-      diff_excludes: >-
-        :!**/.claude/**
-        :!**/dist/**
-        :!**/vendor/**
-        :!**/*.generated.*
-        :!**/*.min.js
-        :!**/*.min.css
-    secrets:
-      CURSOR_API_KEY: ${{ secrets.CURSOR_API_KEY }}
-      SLACK_BOT_TOKEN: ${{ secrets.SLACK_BOT_TOKEN }}

.github/workflows/cla.yml

@@ -1,63 +0,0 @@
-name: CLA Assistant
-
-on:
-  issue_comment:
-    types: [created]
-  pull_request_target:
-    types: [opened, synchronize, closed]
-  merge_group:
-
-permissions:
-  actions: write
-  contents: read # 'read' is enough because signatures live in a REMOTE repo
-  pull-requests: write
-  statuses: write
-
-jobs:
-  cla-assistant:
-    runs-on: ubuntu-latest
-    steps:
-      - name: CLA Assistant
-        # Run on PR events, on "recheck" comment, or when someone posts the exact signing phrase.
-        # IMPORTANT: this phrase must match `custom-pr-sign-comment` below.
-        if: >
-          github.event_name == 'pull_request_target' ||
-          github.event.comment.body == 'recheck' ||
-          github.event.comment.body == 'I have read and agree to the Contributor License Agreement'
-        uses: contributor-assistant/github-action@ca4a40a7d1004f18d9960b404b97e5f30a505a08 # v2.6.1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          # PAT required to write to the centralized signatures repo.
-          PERSONAL_ACCESS_TOKEN: ${{ secrets.PERSONAL_ACCESS_TOKEN }}
-        with:
-          # Where the CLA document lives (shown to contributors)
-          path-to-document: https://github.com/Comfy-Org/comfy-cla/blob/main/comfyui_icla.md
-
-          # Centralized signature storage
-          remote-organization-name: comfy-org
-          remote-repository-name: comfy-cla
-          path-to-signatures: signatures/cla.json
-          branch: main
-
-          # Allowlist bots so they don't need to sign (optional, comma-separated).
-          # *[bot] is a catch-all for any GitHub App bot account.
-          allowlist: action@github.com,actions-user,ampagent,claude,comfy-pr-bot,GitHub Action,github-actions,Glary Bot,Glary-Bot,*[bot]
-
-          # Custom PR comment messages
-          custom-notsigned-prcomment: |
-            🎉 Thank you for your contribution, we really appreciate it! 🎉
-
-            Like many open source projects, we require contributors to sign our [Contributor License Agreement (CLA)](https://github.com/Comfy-Org/comfy-cla/blob/main/comfyui_icla.md). A CLA makes the ownership of contributions explicit, so contributors and the project share a clear understanding of how the code can be used. By signing, you:
-
-            - Confirm that you own your contribution.
-            - Keep the right to reuse your own code.
-            - Grant us a copyright license to include and share it within our projects.
-
-            CLAs are standard practice across major open source projects including those under the Apache Software Foundation and the Linux Foundation. Ours is based on the Apache Software Foundation's CLA. Most importantly, it would enable us to relicense the project under a more permissive license in the future, giving the project and its community greater flexibility.
-
-            ✍ **To sign, please post a new comment on this PR with exactly the following text:** ✍
-
-          custom-pr-sign-comment: I have read and agree to the Contributor License Agreement
-
-          custom-allsigned-prcomment: |
-            ✅ All contributors have signed the CLA. Thank you! This PR is ready to be merged.

comfy/ops.py

@@ -256,7 +256,7 @@ def resolve_cast_module_with_vbar(s, dtype, device, bias_dtype, compute_dtype, w
             if (want_requant and len(fns) == 0 or update_weight):
                 seed = comfy.utils.string_to_seed(s.seed_key)
                 if isinstance(orig, QuantizedTensor):
-                    y = orig.requantize_from_float(x, scale="recalculate", stochastic_rounding=seed)
+                    y = QuantizedTensor.from_float(x, s.layout_type, scale="recalculate", stochastic_rounding=seed)
                 else:
                     y = comfy.float.stochastic_rounding(x, orig.dtype, seed=seed)
             if want_requant and len(fns) == 0:
@@ -1216,7 +1216,7 @@ def mixed_precision_ops(quant_config={}, compute_dtype=torch.bfloat16, full_prec
                         bias_dtype=input.dtype,
                         offloadable=True,
                         compute_dtype=compute_dtype,
-                        want_requant=True,
+                        want_requant=want_requant,
                     )
                     weight = weight.to(dtype=input.dtype)
                 else:
@@ -1306,7 +1306,8 @@ def mixed_precision_ops(quant_config={}, compute_dtype=torch.bfloat16, full_prec
 
             def set_weight(self, weight, inplace_update=False, seed=None, return_weight=False, **kwargs):
                 if getattr(self, 'layout_type', None) is not None:
-                    weight = self.weight.requantize_from_float(weight, scale="recalculate", stochastic_rounding=seed, inplace_ops=True).to(self.weight.dtype)
+                    # dtype is now implicit in the layout class
+                    weight = QuantizedTensor.from_float(weight, self.layout_type, scale="recalculate", stochastic_rounding=seed, inplace_ops=True).to(self.weight.dtype)
                 else:
                     weight = weight.to(self.weight.dtype)
                 if return_weight:

comfy_execution/graph.py

@@ -3,6 +3,7 @@ from typing import Type, Literal
 import nodes
 import asyncio
 import inspect
+import traceback
 from comfy_execution.graph_utils import is_link, ExecutionBlocker
 from comfy.comfy_types.node_typing import ComfyNodeABC, InputTypeDict, InputTypeOptions
 
@@ -263,7 +264,25 @@ class ExecutionList(TopologicalSort):
             }
             return None, error_details, ex
 
-        self.staged_node_id = self.ux_friendly_pick_node(available)
+        try:
+            self.staged_node_id = self.ux_friendly_pick_node(available)
+        except Exception as ex:
+            # Backstop: the ordering heuristics in ux_friendly_pick_node are
+            # defensive, but should anything else there fail, surface it as an
+            # execution error instead of letting it kill the prompt worker
+            # thread. Blame an available node (best effort).
+            blamed_node = self.dynprompt.get_display_node_id(available[0])
+            exception_type = type(ex).__qualname__
+            if type(ex).__module__ != "builtins":
+                exception_type = type(ex).__module__ + "." + exception_type
+            error_details = {
+                "node_id": blamed_node,
+                "exception_message": str(ex),
+                "exception_type": exception_type,
+                "traceback": traceback.format_tb(ex.__traceback__),
+                "current_inputs": []
+            }
+            return None, error_details, ex
         return self.staged_node_id, None, None
 
     def ux_friendly_pick_node(self, node_list):
@@ -271,19 +290,28 @@ class ExecutionList(TopologicalSort):
         # Technically this has no effect on the overall length of execution, but it feels better as a user
         # for a PreviewImage to display a result as soon as it can
         # Some other heuristics could probably be used here to improve the UX further.
+        # These node-ordering heuristics only affect *order*, never correctness.
+        # A malformed node (e.g. a FUNCTION typo, or a node whose schema-derived
+        # attributes raise) must not crash scheduling: failing a heuristic just
+        # means "not prioritized". The node then proceeds to normal execution,
+        # where the real error is raised and reported against the correct node.
         def is_output(node_id):
             class_type = self.dynprompt.get_node(node_id)["class_type"]
             class_def = nodes.NODE_CLASS_MAPPINGS[class_type]
-            if hasattr(class_def, 'OUTPUT_NODE') and class_def.OUTPUT_NODE == True:
-                return True
-            return False
+            try:
+                return hasattr(class_def, 'OUTPUT_NODE') and class_def.OUTPUT_NODE == True
+            except Exception:
+                return False
 
         # If an available node is async, do that first.
         # This will execute the asynchronous function earlier, reducing the overall time.
         def is_async(node_id):
             class_type = self.dynprompt.get_node(node_id)["class_type"]
             class_def = nodes.NODE_CLASS_MAPPINGS[class_type]
-            return inspect.iscoroutinefunction(getattr(class_def, class_def.FUNCTION))
+            try:
+                return inspect.iscoroutinefunction(getattr(class_def, class_def.FUNCTION))
+            except Exception:
+                return False
 
         for node_id in node_list:
             if is_output(node_id) or is_async(node_id):

comfy_extras/nodes_glsl.py

@@ -1,68 +1,85 @@
 import os
 import sys
 import re
-import ctypes
 import logging
+import ctypes.util
+import importlib.util
 from typing import TypedDict
 
 import numpy as np
 import torch
 
 import nodes
-import comfy_angle
 from comfy_api.latest import ComfyExtension, io, ui
 from typing_extensions import override
+from utils.install_util import get_missing_requirements_message
 
 logger = logging.getLogger(__name__)
 
 
-def _preload_angle():
-    egl_path = comfy_angle.get_egl_path()
-    gles_path = comfy_angle.get_glesv2_path()
+def _check_opengl_availability():
+    """Early check for OpenGL availability. Raises RuntimeError if unlikely to work."""
+    logger.debug("_check_opengl_availability: starting")
+    missing = []
 
-    if sys.platform == "win32":
-        angle_dir = comfy_angle.get_lib_dir()
-        os.add_dll_directory(angle_dir)
-        os.environ["PATH"] = angle_dir + os.pathsep + os.environ.get("PATH", "")
+    # Check Python packages (using find_spec to avoid importing)
+    logger.debug("_check_opengl_availability: checking for glfw package")
+    if importlib.util.find_spec("glfw") is None:
+        missing.append("glfw")
 
-    mode = 0 if sys.platform == "win32" else ctypes.RTLD_GLOBAL
-    ctypes.CDLL(str(egl_path), mode=mode)
-    ctypes.CDLL(str(gles_path), mode=mode)
+    logger.debug("_check_opengl_availability: checking for OpenGL package")
+    if importlib.util.find_spec("OpenGL") is None:
+        missing.append("PyOpenGL")
+
+    if missing:
+        raise RuntimeError(
+            f"OpenGL dependencies not available.\n{get_missing_requirements_message()}\n"
+        )
+
+    # On Linux without display, check if headless backends are available
+    logger.debug(f"_check_opengl_availability: platform={sys.platform}")
+    if sys.platform.startswith("linux"):
+        has_display = os.environ.get("DISPLAY") or os.environ.get("WAYLAND_DISPLAY")
+        logger.debug(f"_check_opengl_availability: has_display={bool(has_display)}")
+        if not has_display:
+            # Check for EGL or OSMesa libraries
+            logger.debug("_check_opengl_availability: checking for EGL library")
+            has_egl = ctypes.util.find_library("EGL")
+            logger.debug("_check_opengl_availability: checking for OSMesa library")
+            has_osmesa = ctypes.util.find_library("OSMesa")
+
+            # Error disabled for CI as it fails this check
+            # if not has_egl and not has_osmesa:
+            #     raise RuntimeError(
+            #         "GLSL Shader node: No display and no headless backend (EGL/OSMesa) found.\n"
+            #         "See error below for installation instructions."
+            #     )
+            logger.debug(f"Headless mode: EGL={'yes' if has_egl else 'no'}, OSMesa={'yes' if has_osmesa else 'no'}")
+
+    logger.debug("_check_opengl_availability: completed")
 
 
-# Pre-load ANGLE *before* any PyOpenGL import so that the EGL platform
-# plugin picks up ANGLE's libEGL / libGLESv2 instead of system libs.
-_preload_angle()
-os.environ.setdefault("PYOPENGL_PLATFORM", "egl")
+# Run early check at import time
+logger.debug("nodes_glsl: running _check_opengl_availability at import time")
+_check_opengl_availability()
+
+# OpenGL modules - initialized lazily when context is created
+gl = None
+glfw = None
+EGL = None
 
 
-import OpenGL
-OpenGL.USE_ACCELERATE = False
+def _import_opengl():
+    """Import OpenGL module. Called after context is created."""
+    global gl
+    if gl is None:
+        logger.debug("_import_opengl: importing OpenGL.GL")
+        import OpenGL.GL as _gl
+        gl = _gl
+        logger.debug("_import_opengl: import completed")
+    return gl
 
 
-def _patch_find_library():
-    """PyOpenGL's EGL platform looks for 'EGL' and 'GLESv2' by short name
-    via ctypes.util.find_library, but ANGLE ships as 'libEGL' and
-    'libGLESv2'.  Patch find_library to return the full ANGLE paths so
-    PyOpenGL loads the same libraries we pre-loaded."""
-    if sys.platform == "linux":
-        return
-    import ctypes.util
-    _orig = ctypes.util.find_library
-    def _patched(name):
-        if name == 'EGL':
-            return comfy_angle.get_egl_path()
-        if name == 'GLESv2':
-            return comfy_angle.get_glesv2_path()
-        return _orig(name)
-    ctypes.util.find_library = _patched
-
-
-_patch_find_library()
-
-from OpenGL import EGL
-from OpenGL import GLES3 as gl
-
 class SizeModeInput(TypedDict):
     size_mode: str
     width: int
@@ -85,7 +102,7 @@ MAX_OUTPUTS = 4     # fragColor0-3 (MRT)
 # (-1,-1)---(3,-1)
 #
 # v_texCoord is computed from clip space: * 0.5 + 0.5 maps (-1,1) -> (0,1)
-VERTEX_SHADER = """#version 300 es
+VERTEX_SHADER = """#version 330 core
 out vec2 v_texCoord;
 void main() {
     vec2 verts[3] = vec2[](vec2(-1, -1), vec2(3, -1), vec2(-1, 3));
@@ -109,99 +126,14 @@ void main() {
 """
 
 
-
-def _egl_attribs(*values):
-    """Build an EGL_NONE-terminated EGLint attribute array."""
-    vals = list(values) + [EGL.EGL_NONE]
-    return (ctypes.c_int32 * len(vals))(*vals)
-
-
-# EGL platform extension constants
-EGL_PLATFORM_ANGLE_ANGLE = 0x3202
-EGL_PLATFORM_ANGLE_TYPE_ANGLE = 0x3203
-EGL_PLATFORM_ANGLE_TYPE_VULKAN_ANGLE = 0x3450
-EGL_MESA_PLATFORM_SURFACELESS = 0x31DD
-
-
-_eglGetPlatformDisplayEXT = None
-
-def _get_egl_platform_display_ext(platform, native_display, attribs):
-    """Call eglGetPlatformDisplayEXT via ctypes (extension, not in PyOpenGL)."""
-    global _eglGetPlatformDisplayEXT
-    if _eglGetPlatformDisplayEXT is None:
-        from OpenGL import platform as _plat
-        egl_lib = _plat.PLATFORM.EGL
-        _get_proc = egl_lib.eglGetProcAddress
-        _get_proc.restype = ctypes.c_void_p
-        _get_proc.argtypes = [ctypes.c_char_p]
-        ptr = _get_proc(b"eglGetPlatformDisplayEXT")
-        if not ptr:
-            return None
-        func_type = ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_uint32, ctypes.c_void_p, ctypes.c_void_p)
-        _eglGetPlatformDisplayEXT = func_type(ptr)
-
-    raw = _eglGetPlatformDisplayEXT(platform, native_display, attribs)
-    if not raw:
-        return None
-    return ctypes.cast(raw, EGL.EGLDisplay)
-
-
-def _get_egl_display():
-    """Get an EGL display, trying the default first then ANGLE's Vulkan
-    platform for headless environments without a display server."""
-    failures = []
-
-    # Try the default display first (works when X11/Wayland is available)
-    display = EGL.eglGetDisplay(EGL.EGL_DEFAULT_DISPLAY)
-    if display:
-        major, minor = ctypes.c_int32(0), ctypes.c_int32(0)
-        try:
-            if EGL.eglInitialize(display, ctypes.byref(major), ctypes.byref(minor)):
-                return display, major.value, minor.value
-        except Exception as e:
-            failures.append(f"default: {e}")
-
-    logger.info("Default EGL display unavailable, trying headless fallbacks")
-
-    # Headless fallback strategies, tried in order:
-    headless_strategies = [
-        ("surfaceless", EGL_MESA_PLATFORM_SURFACELESS, None, None),
-        ("ANGLE Vulkan", EGL_PLATFORM_ANGLE_ANGLE, None,
-         _egl_attribs(EGL_PLATFORM_ANGLE_TYPE_ANGLE, EGL_PLATFORM_ANGLE_TYPE_VULKAN_ANGLE)),
-    ]
-
-    for name, platform, native_display, attribs in headless_strategies:
-        display = _get_egl_platform_display_ext(platform, native_display, attribs)
-        if not display:
-            failures.append(f"{name}: eglGetPlatformDisplayEXT returned no display")
-            continue
-        major, minor = ctypes.c_int32(0), ctypes.c_int32(0)
-        try:
-            if EGL.eglInitialize(display, ctypes.byref(major), ctypes.byref(minor)):
-                logger.info(f"Using EGL {name} platform (headless)")
-                return display, major.value, minor.value
-            failures.append(f"{name}: eglInitialize returned false")
-        except Exception as e:
-            failures.append(f"{name}: {e}")
-            continue
-
-    details = "\n".join(f"  - {f}" for f in failures)
-    raise RuntimeError(
-        "Failed to initialize EGL display.\n"
-        "No display server and no headless EGL platform available.\n"
-        f"Tried:\n{details}\n"
-        "Ensure GPU drivers are installed or set DISPLAY for a virtual framebuffer."
-    )
-
-
-def _gl_str(name):
-    """Get an OpenGL string parameter."""
-    v = gl.glGetString(name)
-    if not v:
-        return "Unknown"
-    if isinstance(v, bytes):
-        return v.decode(errors="replace")
-    return ctypes.string_at(v).decode(errors="replace")
+def _convert_es_to_desktop(source: str) -> str:
+    """Convert GLSL ES (WebGL) shader source to desktop GLSL 330 core."""
+    # Remove any existing #version directive
+    source = re.sub(r"#version\s+\d+(\s+es)?\s*\n?", "", source, flags=re.IGNORECASE)
+    # Remove precision qualifiers (not needed in desktop GLSL)
+    source = re.sub(r"precision\s+(lowp|mediump|highp)\s+\w+\s*;\s*\n?", "", source)
+    # Prepend desktop GLSL version
+    return "#version 330 core\n" + source
 
 
 def _detect_output_count(source: str) -> int:
@@ -227,8 +159,163 @@ def _detect_pass_count(source: str) -> int:
     return 1
 
 
+def _init_glfw():
+    """Initialize GLFW. Returns (window, glfw_module). Raises RuntimeError on failure."""
+    logger.debug("_init_glfw: starting")
+    # On macOS, glfw.init() must be called from main thread or it hangs forever
+    if sys.platform == "darwin":
+        logger.debug("_init_glfw: skipping on macOS")
+        raise RuntimeError("GLFW backend not supported on macOS")
+
+    logger.debug("_init_glfw: importing glfw module")
+    import glfw as _glfw
+
+    logger.debug("_init_glfw: calling glfw.init()")
+    if not _glfw.init():
+        raise RuntimeError("glfw.init() failed")
+
+    try:
+        logger.debug("_init_glfw: setting window hints")
+        _glfw.window_hint(_glfw.VISIBLE, _glfw.FALSE)
+        _glfw.window_hint(_glfw.CONTEXT_VERSION_MAJOR, 3)
+        _glfw.window_hint(_glfw.CONTEXT_VERSION_MINOR, 3)
+        _glfw.window_hint(_glfw.OPENGL_PROFILE, _glfw.OPENGL_CORE_PROFILE)
+
+        logger.debug("_init_glfw: calling create_window()")
+        window = _glfw.create_window(64, 64, "ComfyUI GLSL", None, None)
+        if not window:
+            raise RuntimeError("glfw.create_window() failed")
+
+        logger.debug("_init_glfw: calling make_context_current()")
+        _glfw.make_context_current(window)
+        logger.debug("_init_glfw: completed successfully")
+        return window, _glfw
+    except Exception:
+        logger.debug("_init_glfw: failed, terminating glfw")
+        _glfw.terminate()
+        raise
+
+
+def _init_egl():
+    """Initialize EGL for headless rendering. Returns (display, context, surface, EGL_module). Raises RuntimeError on failure."""
+    logger.debug("_init_egl: starting")
+    from OpenGL import EGL as _EGL
+    from OpenGL.EGL import (
+        eglGetDisplay, eglInitialize, eglChooseConfig, eglCreateContext,
+        eglMakeCurrent, eglCreatePbufferSurface, eglBindAPI,
+        eglTerminate, eglDestroyContext, eglDestroySurface,
+        EGL_DEFAULT_DISPLAY, EGL_NO_CONTEXT, EGL_NONE,
+        EGL_SURFACE_TYPE, EGL_PBUFFER_BIT, EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT,
+        EGL_RED_SIZE, EGL_GREEN_SIZE, EGL_BLUE_SIZE, EGL_ALPHA_SIZE, EGL_DEPTH_SIZE,
+        EGL_WIDTH, EGL_HEIGHT, EGL_OPENGL_API,
+    )
+    logger.debug("_init_egl: imports completed")
+
+    display = None
+    context = None
+    surface = None
+
+    try:
+        logger.debug("_init_egl: calling eglGetDisplay()")
+        display = eglGetDisplay(EGL_DEFAULT_DISPLAY)
+        if display == _EGL.EGL_NO_DISPLAY:
+            raise RuntimeError("eglGetDisplay() failed")
+
+        logger.debug("_init_egl: calling eglInitialize()")
+        major, minor = _EGL.EGLint(), _EGL.EGLint()
+        if not eglInitialize(display, major, minor):
+            display = None  # Not initialized, don't terminate
+            raise RuntimeError("eglInitialize() failed")
+        logger.debug(f"_init_egl: EGL version {major.value}.{minor.value}")
+
+        config_attribs = [
+            EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
+            EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT,
+            EGL_RED_SIZE, 8, EGL_GREEN_SIZE, 8, EGL_BLUE_SIZE, 8, EGL_ALPHA_SIZE, 8,
+            EGL_DEPTH_SIZE, 0, EGL_NONE
+        ]
+        configs = (_EGL.EGLConfig * 1)()
+        num_configs = _EGL.EGLint()
+        if not eglChooseConfig(display, config_attribs, configs, 1, num_configs) or num_configs.value == 0:
+            raise RuntimeError("eglChooseConfig() failed")
+        config = configs[0]
+        logger.debug(f"_init_egl: config chosen, num_configs={num_configs.value}")
+
+        if not eglBindAPI(EGL_OPENGL_API):
+            raise RuntimeError("eglBindAPI() failed")
+
+        logger.debug("_init_egl: calling eglCreateContext()")
+        context_attribs = [
+            _EGL.EGL_CONTEXT_MAJOR_VERSION, 3,
+            _EGL.EGL_CONTEXT_MINOR_VERSION, 3,
+            _EGL.EGL_CONTEXT_OPENGL_PROFILE_MASK, _EGL.EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT,
+            EGL_NONE
+        ]
+        context = eglCreateContext(display, config, EGL_NO_CONTEXT, context_attribs)
+        if context == EGL_NO_CONTEXT:
+            raise RuntimeError("eglCreateContext() failed")
+
+        logger.debug("_init_egl: calling eglCreatePbufferSurface()")
+        pbuffer_attribs = [EGL_WIDTH, 64, EGL_HEIGHT, 64, EGL_NONE]
+        surface = eglCreatePbufferSurface(display, config, pbuffer_attribs)
+        if surface == _EGL.EGL_NO_SURFACE:
+            raise RuntimeError("eglCreatePbufferSurface() failed")
+
+        logger.debug("_init_egl: calling eglMakeCurrent()")
+        if not eglMakeCurrent(display, surface, surface, context):
+            raise RuntimeError("eglMakeCurrent() failed")
+
+        logger.debug("_init_egl: completed successfully")
+        return display, context, surface, _EGL
+
+    except Exception:
+        logger.debug("_init_egl: failed, cleaning up")
+        # Clean up any resources on failure
+        if surface is not None:
+            eglDestroySurface(display, surface)
+        if context is not None:
+            eglDestroyContext(display, context)
+        if display is not None:
+            eglTerminate(display)
+        raise
+
+
+def _init_osmesa():
+    """Initialize OSMesa for software rendering. Returns (context, buffer). Raises RuntimeError on failure."""
+    import ctypes
+
+    logger.debug("_init_osmesa: starting")
+    os.environ["PYOPENGL_PLATFORM"] = "osmesa"
+
+    logger.debug("_init_osmesa: importing OpenGL.osmesa")
+    from OpenGL import GL as _gl
+    from OpenGL.osmesa import (
+        OSMesaCreateContextExt, OSMesaMakeCurrent, OSMesaDestroyContext,
+        OSMESA_RGBA,
+    )
+    logger.debug("_init_osmesa: imports completed")
+
+    ctx = OSMesaCreateContextExt(OSMESA_RGBA, 24, 0, 0, None)
+    if not ctx:
+        raise RuntimeError("OSMesaCreateContextExt() failed")
+
+    width, height = 64, 64
+    buffer = (ctypes.c_ubyte * (width * height * 4))()
+
+    logger.debug("_init_osmesa: calling OSMesaMakeCurrent()")
+    if not OSMesaMakeCurrent(ctx, buffer, _gl.GL_UNSIGNED_BYTE, width, height):
+        OSMesaDestroyContext(ctx)
+        raise RuntimeError("OSMesaMakeCurrent() failed")
+
+    logger.debug("_init_osmesa: completed successfully")
+    return ctx, buffer
+
+
 class GLContext:
-    """Manages an OpenGL ES 3.0 context via EGL/ANGLE (singleton)."""
+    """Manages OpenGL context and resources for shader execution.
+
+    Tries backends in order: GLFW (desktop) → EGL (headless GPU) → OSMesa (software).
+    """
 
     _instance = None
     _initialized = False
@@ -240,105 +327,131 @@ class GLContext:
 
     def __init__(self):
         if GLContext._initialized:
+            logger.debug("GLContext.__init__: already initialized, skipping")
             return
 
+        logger.debug("GLContext.__init__: starting initialization")
+
+        global glfw, EGL
+
         import time
         start = time.perf_counter()
 
-        self._display = None
-        self._surface = None
-        self._context = None
+        self._backend = None
+        self._window = None
+        self._egl_display = None
+        self._egl_context = None
+        self._egl_surface = None
+        self._osmesa_ctx = None
+        self._osmesa_buffer = None
         self._vao = None
 
+        # Try backends in order: GLFW → EGL → OSMesa
+        errors = []
+
+        logger.debug("GLContext.__init__: trying GLFW backend")
         try:
-            self._display, self._egl_major, self._egl_minor = _get_egl_display()
+            self._window, glfw = _init_glfw()
+            self._backend = "glfw"
+            logger.debug("GLContext.__init__: GLFW backend succeeded")
+        except Exception as e:
+            logger.debug(f"GLContext.__init__: GLFW backend failed: {e}")
+            errors.append(("GLFW", e))
 
-            if not EGL.eglBindAPI(EGL.EGL_OPENGL_ES_API):
-                raise RuntimeError("eglBindAPI(EGL_OPENGL_ES_API) failed")
+        if self._backend is None:
+            logger.debug("GLContext.__init__: trying EGL backend")
+            try:
+                self._egl_display, self._egl_context, self._egl_surface, EGL = _init_egl()
+                self._backend = "egl"
+                logger.debug("GLContext.__init__: EGL backend succeeded")
+            except Exception as e:
+                logger.debug(f"GLContext.__init__: EGL backend failed: {e}")
+                errors.append(("EGL", e))
 
-            config = EGL.EGLConfig()
-            n_configs = ctypes.c_int32(0)
-            if not EGL.eglChooseConfig(
-                self._display,
-                _egl_attribs(
-                    EGL.EGL_RENDERABLE_TYPE, EGL.EGL_OPENGL_ES3_BIT,
-                    EGL.EGL_SURFACE_TYPE, EGL.EGL_PBUFFER_BIT,
-                    EGL.EGL_RED_SIZE, 8, EGL.EGL_GREEN_SIZE, 8,
-                    EGL.EGL_BLUE_SIZE, 8, EGL.EGL_ALPHA_SIZE, 8,
-                ),
-                ctypes.byref(config), 1, ctypes.byref(n_configs),
-            ) or n_configs.value == 0:
-                raise RuntimeError("eglChooseConfig() failed")
+        if self._backend is None:
+            logger.debug("GLContext.__init__: trying OSMesa backend")
+            try:
+                self._osmesa_ctx, self._osmesa_buffer = _init_osmesa()
+                self._backend = "osmesa"
+                logger.debug("GLContext.__init__: OSMesa backend succeeded")
+            except Exception as e:
+                logger.debug(f"GLContext.__init__: OSMesa backend failed: {e}")
+                errors.append(("OSMesa", e))
 
-            self._surface = EGL.eglCreatePbufferSurface(
-                self._display, config,
-                _egl_attribs(EGL.EGL_WIDTH, 64, EGL.EGL_HEIGHT, 64),
+        if self._backend is None:
+            if sys.platform == "win32":
+                platform_help = (
+                    "Windows: Ensure GPU drivers are installed and display is available.\n"
+                    "         CPU-only/headless mode is not supported on Windows."
+                )
+            elif sys.platform == "darwin":
+                platform_help = (
+                    "macOS: GLFW is not supported.\n"
+                    "  Install OSMesa via Homebrew: brew install mesa\n"
+                    "  Then: pip install PyOpenGL PyOpenGL-accelerate"
+                )
+            else:
+                platform_help = (
+                    "Linux: Install one of these backends:\n"
+                    "  Desktop:           sudo apt install libgl1-mesa-glx libglfw3\n"
+                    "  Headless with GPU: sudo apt install libegl1-mesa libgl1-mesa-dri\n"
+                    "  Headless (CPU):    sudo apt install libosmesa6"
+                )
+
+            error_details = "\n".join(f"  {name}: {err}" for name, err in errors)
+            raise RuntimeError(
+                f"Failed to create OpenGL context.\n\n"
+                f"Backend errors:\n{error_details}\n\n"
+                f"{platform_help}"
             )
-            if not self._surface:
-                raise RuntimeError("eglCreatePbufferSurface() failed")
 
-            self._context = EGL.eglCreateContext(
-                self._display, config, EGL.EGL_NO_CONTEXT,
-                _egl_attribs(EGL.EGL_CONTEXT_CLIENT_VERSION, 3),
-            )
-            if not self._context:
-                raise RuntimeError("eglCreateContext() failed")
+        # Now import OpenGL.GL (after context is current)
+        logger.debug("GLContext.__init__: importing OpenGL.GL")
+        _import_opengl()
 
-            if not EGL.eglMakeCurrent(self._display, self._surface, self._surface, self._context):
-                raise RuntimeError("eglMakeCurrent() failed")
-
-            self._vao = gl.glGenVertexArrays(1)
-            gl.glBindVertexArray(self._vao)
-
-        except Exception:
-            self._cleanup()
-            raise
+        # Create VAO (required for core profile, but OSMesa may use compat profile)
+        logger.debug("GLContext.__init__: creating VAO")
+        try:
+            vao = gl.glGenVertexArrays(1)
+            gl.glBindVertexArray(vao)
+            self._vao = vao  # Only store after successful bind
+            logger.debug("GLContext.__init__: VAO created successfully")
+        except Exception as e:
+            logger.debug(f"GLContext.__init__: VAO creation failed (may be expected for OSMesa): {e}")
+            # OSMesa with older Mesa may not support VAOs
+            # Clean up if we created but couldn't bind
+            if vao:
+                try:
+                    gl.glDeleteVertexArrays(1, [vao])
+                except Exception:
+                    pass
 
         elapsed = (time.perf_counter() - start) * 1000
 
-        renderer = _gl_str(gl.GL_RENDERER)
-        vendor = _gl_str(gl.GL_VENDOR)
-        version = _gl_str(gl.GL_VERSION)
+        # Log device info
+        renderer = gl.glGetString(gl.GL_RENDERER)
+        vendor = gl.glGetString(gl.GL_VENDOR)
+        version = gl.glGetString(gl.GL_VERSION)
+        renderer = renderer.decode() if renderer else "Unknown"
+        vendor = vendor.decode() if vendor else "Unknown"
+        version = version.decode() if version else "Unknown"
 
         GLContext._initialized = True
-        logger.info(f"GLSL context initialized in {elapsed:.1f}ms - EGL {self._egl_major}.{self._egl_minor}, {renderer} ({vendor}), GL {version}")
+        logger.info(f"GLSL context initialized in {elapsed:.1f}ms ({self._backend}) - {renderer} ({vendor}), GL {version}")
 
     def make_current(self):
-        if not EGL.eglMakeCurrent(self._display, self._surface, self._surface, self._context):
-            err = EGL.eglGetError()
-            raise RuntimeError(f"eglMakeCurrent() failed (EGL error: 0x{err:04X})")
+        if self._backend == "glfw":
+            glfw.make_context_current(self._window)
+        elif self._backend == "egl":
+            from OpenGL.EGL import eglMakeCurrent
+            eglMakeCurrent(self._egl_display, self._egl_surface, self._egl_surface, self._egl_context)
+        elif self._backend == "osmesa":
+            from OpenGL.osmesa import OSMesaMakeCurrent
+            OSMesaMakeCurrent(self._osmesa_ctx, self._osmesa_buffer, gl.GL_UNSIGNED_BYTE, 64, 64)
+
         if self._vao is not None:
             gl.glBindVertexArray(self._vao)
 
-    def _cleanup(self):
-        if not self._display:
-            return
-        try:
-            if self._vao is not None:
-                gl.glDeleteVertexArrays(1, [self._vao])
-                self._vao = None
-        except Exception:
-            pass
-        try:
-            EGL.eglMakeCurrent(self._display, EGL.EGL_NO_SURFACE, EGL.EGL_NO_SURFACE, EGL.EGL_NO_CONTEXT)
-        except Exception:
-            pass
-        try:
-            if self._context:
-                EGL.eglDestroyContext(self._display, self._context)
-        except Exception:
-            pass
-        try:
-            if self._surface:
-                EGL.eglDestroySurface(self._display, self._surface)
-        except Exception:
-            pass
-        try:
-            EGL.eglTerminate(self._display)
-        except Exception:
-            pass
-        self._display = None
-
 
 def _compile_shader(source: str, shader_type: int) -> int:
     """Compile a shader and return its ID."""
@@ -346,10 +459,8 @@ def _compile_shader(source: str, shader_type: int) -> int:
     gl.glShaderSource(shader, source)
     gl.glCompileShader(shader)
 
-    if not gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS):
-        error = gl.glGetShaderInfoLog(shader)
-        if isinstance(error, bytes):
-            error = error.decode(errors="replace")
+    if gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS) != gl.GL_TRUE:
+        error = gl.glGetShaderInfoLog(shader).decode()
         gl.glDeleteShader(shader)
         raise RuntimeError(f"Shader compilation failed:\n{error}")
 
@@ -373,10 +484,8 @@ def _create_program(vertex_source: str, fragment_source: str) -> int:
     gl.glDeleteShader(vertex_shader)
     gl.glDeleteShader(fragment_shader)
 
-    if not gl.glGetProgramiv(program, gl.GL_LINK_STATUS):
-        error = gl.glGetProgramInfoLog(program)
-        if isinstance(error, bytes):
-            error = error.decode(errors="replace")
+    if gl.glGetProgramiv(program, gl.GL_LINK_STATUS) != gl.GL_TRUE:
+        error = gl.glGetProgramInfoLog(program).decode()
         gl.glDeleteProgram(program)
         raise RuntimeError(f"Program linking failed:\n{error}")
 
@@ -421,6 +530,9 @@ def _render_shader_batch(
     ctx = GLContext()
     ctx.make_current()
 
+    # Convert from GLSL ES to desktop GLSL 330
+    fragment_source = _convert_es_to_desktop(fragment_code)
+
     # Detect how many outputs the shader actually uses
     num_outputs = _detect_output_count(fragment_code)
 
@@ -446,9 +558,9 @@ def _render_shader_batch(
     try:
         # Compile shaders (once for all batches)
         try:
-            program = _create_program(VERTEX_SHADER, fragment_code)
+            program = _create_program(VERTEX_SHADER, fragment_source)
         except RuntimeError:
-            logger.error(f"Fragment shader:\n{fragment_code}")
+            logger.error(f"Fragment shader:\n{fragment_source}")
             raise
 
         gl.glUseProgram(program)
@@ -611,13 +723,13 @@ def _render_shader_batch(
                     gl.glDrawArrays(gl.GL_TRIANGLES, 0, 3)
 
             # Read back outputs for this batch
-            gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, fbo)
+            # (glGetTexImage is synchronous, implicitly waits for rendering)
             batch_outputs = []
-            for i in range(num_outputs):
-                gl.glReadBuffer(gl.GL_COLOR_ATTACHMENT0 + i)
-                buf = np.empty((height, width, 4), dtype=np.float32)
-                gl.glReadPixels(0, 0, width, height, gl.GL_RGBA, gl.GL_FLOAT, buf)
-                batch_outputs.append(buf[::-1, :, :].copy())
+            for tex in output_textures:
+                gl.glBindTexture(gl.GL_TEXTURE_2D, tex)
+                data = gl.glGetTexImage(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA, gl.GL_FLOAT)
+                img = np.frombuffer(data, dtype=np.float32).reshape(height, width, 4)
+                batch_outputs.append(img[::-1, :, :].copy())
 
             # Pad with black images for unused outputs
             black_img = np.zeros((height, width, 4), dtype=np.float32)
@@ -638,18 +750,18 @@ def _render_shader_batch(
         gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
         gl.glUseProgram(0)
 
-        if input_textures:
-            gl.glDeleteTextures(len(input_textures), input_textures)
-        if curve_textures:
-            gl.glDeleteTextures(len(curve_textures), curve_textures)
-        if output_textures:
-            gl.glDeleteTextures(len(output_textures), output_textures)
-        if ping_pong_textures:
-            gl.glDeleteTextures(len(ping_pong_textures), ping_pong_textures)
+        for tex in input_textures:
+            gl.glDeleteTextures(int(tex))
+        for tex in curve_textures:
+            gl.glDeleteTextures(int(tex))
+        for tex in output_textures:
+            gl.glDeleteTextures(int(tex))
+        for tex in ping_pong_textures:
+            gl.glDeleteTextures(int(tex))
         if fbo is not None:
             gl.glDeleteFramebuffers(1, [fbo])
-        if ping_pong_fbos:
-            gl.glDeleteFramebuffers(len(ping_pong_fbos), ping_pong_fbos)
+        for pp_fbo in ping_pong_fbos:
+            gl.glDeleteFramebuffers(1, [pp_fbo])
         if program is not None:
             gl.glDeleteProgram(program)
 

requirements.txt

@@ -22,7 +22,7 @@ alembic
 SQLAlchemy>=2.0.0
 filelock
 av>=16.0.0
-comfy-kitchen==0.2.14
+comfy-kitchen==0.2.12
 comfy-aimdo==0.4.10
 requests
 simpleeval>=1.0.0
@@ -33,5 +33,5 @@ kornia>=0.7.1
 spandrel
 pydantic~=2.0
 pydantic-settings~=2.0
-PyOpenGL>=3.1.8
-comfy-angle
+PyOpenGL
+glfw

tests-unit/execution_test/scheduler_malformed_node_test.py

@@ -0,0 +1,97 @@
+"""Regression tests for scheduler resilience to malformed nodes.
+
+A node whose FUNCTION points at a method that does not exist (e.g. a typo in a
+custom node) used to raise inside the scheduling heuristic, escaping the prompt
+worker's error handling and silently killing the worker thread. Scheduling must
+instead either proceed (so the error surfaces through normal execution) or report
+the failure as an execution error.
+"""
+import asyncio
+
+import nodes
+from comfy_execution.graph import DynamicPrompt, ExecutionList
+
+
+class _MalformedV1Node:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {"required": {}}
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "invert"  # the actual method below is misspelled
+    OUTPUT_NODE = True
+    CATEGORY = "Test"
+
+    def invvert(self):
+        return (None,)
+
+
+class _RaisingDescriptor:
+    def __get__(self, obj, owner):
+        raise RuntimeError("schema error")
+
+
+class _SchemaRaisesNode:
+    """A node whose schema-derived attribute access raises, as a broken V3 node would."""
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {"required": {}}
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "run"
+    OUTPUT_NODE = _RaisingDescriptor()
+    CATEGORY = "Test"
+
+    def run(self):
+        return (None,)
+
+
+class _FakeOutputCache:
+    def all_node_ids(self):
+        return set()
+
+    async def get(self, node_id):
+        return None
+
+
+def _make_execution_list(class_type, class_def):
+    nodes.NODE_CLASS_MAPPINGS[class_type] = class_def
+    prompt = {"1": {"class_type": class_type, "inputs": {}}}
+    execution_list = ExecutionList(DynamicPrompt(prompt), _FakeOutputCache())
+    execution_list.add_node("1")
+    return execution_list
+
+
+def test_malformed_function_does_not_crash_scheduler():
+    """A FUNCTION-typo node schedules without raising; the error surfaces later."""
+    execution_list = _make_execution_list("MalformedV1Node", _MalformedV1Node)
+    node_id, error, ex = asyncio.run(execution_list.stage_node_execution())
+    assert ex is None
+    assert error is None
+    assert node_id == "1"
+
+
+def test_schema_attribute_error_does_not_crash_scheduler():
+    """A node whose attribute access raises during heuristics still schedules."""
+    execution_list = _make_execution_list("SchemaRaisesNode", _SchemaRaisesNode)
+    node_id, error, ex = asyncio.run(execution_list.stage_node_execution())
+    assert ex is None
+    assert error is None
+    assert node_id == "1"
+
+
+def test_pick_node_failure_is_reported_not_raised():
+    """An unexpected scheduling error is returned as an error, not raised."""
+    execution_list = _make_execution_list("MalformedV1Node", _MalformedV1Node)
+
+    def raise_on_pick(_available):
+        raise RuntimeError("boom")
+
+    execution_list.ux_friendly_pick_node = raise_on_pick
+    node_id, error, ex = asyncio.run(execution_list.stage_node_execution())
+    assert node_id is None
+    assert isinstance(ex, RuntimeError)
+    assert error["node_id"] == "1"
+    assert error["exception_type"] == "RuntimeError"
+    assert error["exception_message"] == "boom"
+    assert error["traceback"]