comfy-env 0.1.15__py3-none-any.whl → 0.1.17__py3-none-any.whl

comfy_env/packages/__init__.py

@@ -0,0 +1,60 @@
+"""
+Packages layer - Package installation with side effects.
+
+Handles pixi, CUDA wheels, apt packages, and node dependencies.
+"""
+
+from .pixi import (
+    PIXI_VERSION,
+    ensure_pixi,
+    get_pixi_path,
+    get_pixi_python,
+    pixi_install,
+    pixi_run,
+    pixi_clean,
+)
+from .cuda_wheels import (
+    CUDA_WHEELS_INDEX,
+    get_wheel_url,
+    find_available_wheels,
+    get_cuda_torch_mapping,
+)
+from .toml_generator import (
+    generate_pixi_toml,
+    config_to_pixi_dict,
+)
+from .apt import (
+    apt_install,
+    check_apt_packages,
+)
+from .node_dependencies import (
+    install_node_dependencies,
+    clone_node,
+    normalize_repo_url,
+)
+
+__all__ = [
+    # Pixi package manager
+    "PIXI_VERSION",
+    "ensure_pixi",
+    "get_pixi_path",
+    "get_pixi_python",
+    "pixi_install",
+    "pixi_run",
+    "pixi_clean",
+    # CUDA wheels
+    "CUDA_WHEELS_INDEX",
+    "get_wheel_url",
+    "find_available_wheels",
+    "get_cuda_torch_mapping",
+    # TOML generation
+    "generate_pixi_toml",
+    "config_to_pixi_dict",
+    # APT packages
+    "apt_install",
+    "check_apt_packages",
+    # Node dependencies
+    "install_node_dependencies",
+    "clone_node",
+    "normalize_repo_url",
+]

comfy_env/packages/apt.py

@@ -0,0 +1,36 @@
+"""APT package installation (Linux only)."""
+
+import subprocess
+import sys
+from typing import Callable, List
+
+
+def apt_install(packages: List[str], log: Callable[[str], None] = print) -> bool:
+    """Install system packages via apt-get. No-op on non-Linux."""
+    if not packages or sys.platform != "linux":
+        return True
+
+    log(f"Installing apt packages: {packages}")
+
+    subprocess.run(["sudo", "apt-get", "update"], capture_output=True, text=True)
+
+    result = subprocess.run(
+        ["sudo", "apt-get", "install", "-y"] + packages,
+        capture_output=True, text=True
+    )
+    if result.returncode != 0:
+        log(f"Warning: apt-get install failed: {result.stderr[:200]}")
+        return False
+
+    return True
+
+
+def check_apt_packages(packages: List[str]) -> List[str]:
+    """Return list of packages NOT installed."""
+    if sys.platform != "linux":
+        return []
+
+    return [
+        pkg for pkg in packages
+        if subprocess.run(["dpkg", "-s", pkg], capture_output=True).returncode != 0
+    ]

comfy_env/packages/cuda_wheels.py

@@ -0,0 +1,97 @@
+"""CUDA wheels index integration. See: https://pozzettiandrea.github.io/cuda-wheels/"""
+
+import re
+import sys
+import urllib.request
+from typing import List, Optional
+
+CUDA_WHEELS_INDEX = "https://pozzettiandrea.github.io/cuda-wheels/"
+CUDA_TORCH_MAP = {"12.8": "2.8", "12.4": "2.4"}
+
+
+def get_cuda_torch_mapping() -> dict:
+    return CUDA_TORCH_MAP.copy()
+
+
+def get_torch_version_for_cuda(cuda_version: str) -> Optional[str]:
+    return CUDA_TORCH_MAP.get(".".join(cuda_version.split(".")[:2]))
+
+
+def _pkg_variants(package: str) -> List[str]:
+    return [package, package.replace("-", "_"), package.replace("_", "-")]
+
+
+def _platform_tag() -> Optional[str]:
+    if sys.platform.startswith("linux"): return "linux_x86_64"
+    if sys.platform == "win32": return "win_amd64"
+    return None
+
+
+def get_wheel_url(package: str, torch_version: str, cuda_version: str, python_version: str) -> Optional[str]:
+    """Get direct URL to matching wheel from cuda-wheels index."""
+    cuda_short = cuda_version.replace(".", "")[:3]
+    torch_short = torch_version.replace(".", "")[:2]
+    py_tag = f"cp{python_version.replace('.', '')}"
+    platform_tag = _platform_tag()
+
+    local_patterns = [f"+cu{cuda_short}torch{torch_short}", f"+pt{torch_short}cu{cuda_short}"]
+    link_pattern = re.compile(r'href="([^"]+\.whl)"[^>]*>([^<]+)</a>', re.IGNORECASE)
+
+    for pkg_dir in _pkg_variants(package):
+        try:
+            with urllib.request.urlopen(f"{CUDA_WHEELS_INDEX}{pkg_dir}/", timeout=10) as resp:
+                html = resp.read().decode("utf-8")
+        except Exception: continue
+
+        for match in link_pattern.finditer(html):
+            wheel_url, display = match.group(1), match.group(2)
+            if any(p in display for p in local_patterns) and py_tag in display:
+                if platform_tag is None or platform_tag in display:
+                    return wheel_url if wheel_url.startswith("http") else f"{CUDA_WHEELS_INDEX}{pkg_dir}/{wheel_url}"
+    return None
+
+
+def find_available_wheels(package: str) -> List[str]:
+    """List all available wheels for a package."""
+    wheels = []
+    link_pattern = re.compile(r'href="[^"]*?([^"/]+\.whl)"', re.IGNORECASE)
+    for pkg_dir in _pkg_variants(package):
+        try:
+            with urllib.request.urlopen(f"{CUDA_WHEELS_INDEX}{pkg_dir}/", timeout=10) as resp:
+                html = resp.read().decode("utf-8")
+            for match in link_pattern.finditer(html):
+                name = match.group(1).replace("%2B", "+")
+                if name not in wheels: wheels.append(name)
+        except Exception: continue
+    return wheels
+
+
+def find_matching_wheel(package: str, torch_version: str, cuda_version: str) -> Optional[str]:
+    """Find wheel matching CUDA/torch version, return version spec."""
+    cuda_short = cuda_version.replace(".", "")[:3]
+    torch_short = torch_version.replace(".", "")[:2]
+    local_patterns = [f"+cu{cuda_short}torch{torch_short}", f"+pt{torch_short}cu{cuda_short}"]
+    wheel_pattern = re.compile(r'href="[^"]*?([^"/]+\.whl)"', re.IGNORECASE)
+
+    for pkg_dir in _pkg_variants(package):
+        try:
+            with urllib.request.urlopen(f"{CUDA_WHEELS_INDEX}{pkg_dir}/", timeout=10) as resp:
+                html = resp.read().decode("utf-8")
+        except Exception: continue
+
+        best_match = best_version = None
+        for match in wheel_pattern.finditer(html):
+            wheel_name = match.group(1).replace("%2B", "+")
+            for local in local_patterns:
+                if local in wheel_name:
+                    parts = wheel_name.split("-")
+                    if len(parts) >= 2 and (best_version is None or parts[1] > best_version):
+                        best_version = parts[1]
+                        best_match = f"{package}==={parts[1]}"
+                    break
+        if best_match: return best_match
+    return None
+
+
+def get_find_links_urls(package: str) -> List[str]:
+    return [f"{CUDA_WHEELS_INDEX}{p}/" for p in _pkg_variants(package)]

comfy_env/packages/node_dependencies.py

@@ -0,0 +1,77 @@
+"""Node dependency installation - clone ComfyUI nodes from [node_reqs] section."""
+
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+from typing import Callable, List, Set, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..config import NodeDependency
+
+
+def normalize_repo_url(repo: str) -> str:
+    if repo.startswith("http"): return repo
+    return f"https://github.com/{repo}"
+
+
+def clone_node(repo: str, name: str, target_dir: Path, log: Callable[[str], None] = print) -> Path:
+    node_path = target_dir / name
+    url = normalize_repo_url(repo)
+    log(f"  Cloning {name}...")
+    result = subprocess.run(["git", "clone", "--depth", "1", url, str(node_path)], capture_output=True, text=True)
+    if result.returncode != 0:
+        raise RuntimeError(f"Failed to clone {url}: {result.stderr.strip()}")
+    return node_path
+
+
+def install_requirements(node_dir: Path, log: Callable[[str], None] = print) -> None:
+    req_file = node_dir / "requirements.txt"
+    if not req_file.exists(): return
+    log(f"  Installing requirements for {node_dir.name}...")
+    cmd = ["uv", "pip", "install", "-r", str(req_file), "--python", sys.executable] if shutil.which("uv") else [sys.executable, "-m", "pip", "install", "-r", str(req_file)]
+    result = subprocess.run(cmd, cwd=node_dir, capture_output=True, text=True)
+    if result.returncode != 0:
+        log(f"  Warning: requirements failed: {result.stderr.strip()[:200]}")
+
+
+def run_install_script(node_dir: Path, log: Callable[[str], None] = print) -> None:
+    install_script = node_dir / "install.py"
+    if install_script.exists():
+        log(f"  Running install.py for {node_dir.name}...")
+        result = subprocess.run([sys.executable, str(install_script)], cwd=node_dir, capture_output=True, text=True)
+        if result.returncode != 0:
+            log(f"  Warning: install.py failed: {result.stderr.strip()[:200]}")
+
+
+def install_node_dependencies(
+    node_deps: "List[NodeDependency]",
+    custom_nodes_dir: Path,
+    log: Callable[[str], None] = print,
+    visited: Set[str] = None,
+) -> None:
+    """Install node dependencies recursively."""
+    from ..config import discover_config
+
+    visited = visited or set()
+    for dep in node_deps:
+        if dep.name in visited:
+            log(f"  {dep.name}: cycle, skipping")
+            continue
+        visited.add(dep.name)
+
+        node_path = custom_nodes_dir / dep.name
+        if node_path.exists():
+            log(f"  {dep.name}: exists")
+            continue
+
+        try:
+            clone_node(dep.repo, dep.name, custom_nodes_dir, log)
+            install_requirements(node_path, log)
+            run_install_script(node_path, log)
+
+            nested_config = discover_config(node_path)
+            if nested_config and nested_config.node_reqs:
+                install_node_dependencies(nested_config.node_reqs, custom_nodes_dir, log, visited)
+        except Exception as e:
+            log(f"  Warning: {dep.name} failed: {e}")

comfy_env/packages/pixi.py

@@ -0,0 +1,85 @@
+"""Pixi package manager integration. See: https://pixi.sh/"""
+
+import platform as platform_mod
+import shutil
+import stat
+import subprocess
+import sys
+import urllib.request
+from pathlib import Path
+from typing import Callable, List, Optional
+
+PIXI_URLS = {
+    ("Linux", "x86_64"): "https://github.com/prefix-dev/pixi/releases/latest/download/pixi-x86_64-unknown-linux-musl",
+    ("Linux", "aarch64"): "https://github.com/prefix-dev/pixi/releases/latest/download/pixi-aarch64-unknown-linux-musl",
+    ("Darwin", "x86_64"): "https://github.com/prefix-dev/pixi/releases/latest/download/pixi-x86_64-apple-darwin",
+    ("Darwin", "arm64"): "https://github.com/prefix-dev/pixi/releases/latest/download/pixi-aarch64-apple-darwin",
+    ("Windows", "AMD64"): "https://github.com/prefix-dev/pixi/releases/latest/download/pixi-x86_64-pc-windows-msvc.exe",
+}
+
+
+def get_pixi_path() -> Optional[Path]:
+    """Find pixi in PATH or common locations."""
+    if cmd := shutil.which("pixi"): return Path(cmd)
+    home = Path.home()
+    for p in [home / ".pixi/bin/pixi", home / ".local/bin/pixi"]:
+        candidate = p.with_suffix(".exe") if sys.platform == "win32" else p
+        if candidate.exists(): return candidate
+    return None
+
+
+def ensure_pixi(install_dir: Optional[Path] = None, log: Callable[[str], None] = print) -> Path:
+    """Ensure pixi is installed, downloading if necessary."""
+    if existing := get_pixi_path(): return existing
+
+    log("Pixi not found, downloading...")
+    install_dir = install_dir or Path.home() / ".local/bin"
+    install_dir.mkdir(parents=True, exist_ok=True)
+
+    system, machine = platform_mod.system(), platform_mod.machine()
+    if machine in ("x86_64", "AMD64"): machine = "x86_64" if system != "Windows" else "AMD64"
+    elif machine in ("arm64", "aarch64"): machine = "arm64" if system == "Darwin" else "aarch64"
+
+    if (system, machine) not in PIXI_URLS:
+        raise RuntimeError(f"No pixi for {system}/{machine}")
+
+    pixi_path = install_dir / ("pixi.exe" if system == "Windows" else "pixi")
+    try:
+        urllib.request.urlretrieve(PIXI_URLS[(system, machine)], pixi_path)
+    except Exception as e:
+        result = subprocess.run(["curl", "-fsSL", "-o", str(pixi_path), PIXI_URLS[(system, machine)]], capture_output=True, text=True)
+        if result.returncode != 0: raise RuntimeError(f"Failed to download pixi") from e
+
+    if system != "Windows":
+        pixi_path.chmod(pixi_path.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+
+    log(f"Installed pixi: {pixi_path}")
+    return pixi_path
+
+
+def get_pixi_python(node_dir: Path) -> Optional[Path]:
+    """Get Python path from pixi environment."""
+    from ..environment.cache import resolve_env_path
+    env_path, _, _ = resolve_env_path(node_dir)
+    if not env_path: return None
+    python_path = env_path / ("python.exe" if sys.platform == "win32" else "bin/python")
+    return python_path if python_path.exists() else None
+
+
+def pixi_install(node_dir: Path, log: Callable[[str], None] = print) -> subprocess.CompletedProcess:
+    pixi_path = get_pixi_path()
+    if not pixi_path: raise RuntimeError("Pixi not found")
+    return subprocess.run([str(pixi_path), "install"], cwd=node_dir, capture_output=True, text=True)
+
+
+def pixi_run(command: List[str], node_dir: Path, log: Callable[[str], None] = print) -> subprocess.CompletedProcess:
+    pixi_path = get_pixi_path()
+    if not pixi_path: raise RuntimeError("Pixi not found")
+    return subprocess.run([str(pixi_path), "run"] + command, cwd=node_dir, capture_output=True, text=True)
+
+
+def pixi_clean(node_dir: Path, log: Callable[[str], None] = print) -> None:
+    """Remove pixi artifacts (pixi.toml, pixi.lock, .pixi/)."""
+    for path in [node_dir / "pixi.toml", node_dir / "pixi.lock"]:
+        if path.exists(): path.unlink()
+    if (node_dir / ".pixi").exists(): shutil.rmtree(node_dir / ".pixi")

comfy_env/packages/toml_generator.py

@@ -0,0 +1,88 @@
+"""Generate pixi.toml from ComfyEnvConfig."""
+
+import copy
+import sys
+from pathlib import Path
+from typing import Any, Callable, Dict
+
+from ..config import ComfyEnvConfig
+from ..detection import get_recommended_cuda_version, get_pixi_platform
+from .cuda_wheels import CUDA_TORCH_MAP
+
+
+def _require_tomli_w():
+    try:
+        import tomli_w
+        return tomli_w
+    except ImportError:
+        raise ImportError("tomli-w required: pip install tomli-w")
+
+
+def generate_pixi_toml(cfg: ComfyEnvConfig, node_dir: Path, log: Callable[[str], None] = print) -> str:
+    return _require_tomli_w().dumps(config_to_pixi_dict(cfg, node_dir, log))
+
+
+def write_pixi_toml(cfg: ComfyEnvConfig, node_dir: Path, log: Callable[[str], None] = print) -> Path:
+    tomli_w = _require_tomli_w()
+    pixi_toml = node_dir / "pixi.toml"
+    with open(pixi_toml, "wb") as f:
+        tomli_w.dump(config_to_pixi_dict(cfg, node_dir, log), f)
+    log(f"Generated {pixi_toml}")
+    return pixi_toml
+
+
+def config_to_pixi_dict(cfg: ComfyEnvConfig, node_dir: Path, log: Callable[[str], None] = print) -> Dict[str, Any]:
+    pixi_data = copy.deepcopy(cfg.pixi_passthrough)
+
+    cuda_version = torch_version = None
+    if cfg.has_cuda and sys.platform != "darwin":
+        cuda_version = get_recommended_cuda_version()
+        if cuda_version:
+            torch_version = CUDA_TORCH_MAP.get(".".join(cuda_version.split(".")[:2]), "2.8")
+            log(f"CUDA {cuda_version} -> PyTorch {torch_version}")
+
+    # Workspace
+    workspace = pixi_data.setdefault("workspace", {})
+    workspace.setdefault("name", node_dir.name)
+    workspace.setdefault("version", "0.1.0")
+    workspace.setdefault("channels", ["conda-forge"])
+    workspace.setdefault("platforms", [get_pixi_platform()])
+
+    # System requirements
+    if sys.platform.startswith("linux") or cuda_version:
+        system_reqs = pixi_data.setdefault("system-requirements", {})
+        if sys.platform.startswith("linux"):
+            system_reqs.setdefault("libc", {"family": "glibc", "version": "2.35"})
+        if cuda_version:
+            system_reqs["cuda"] = cuda_version.split(".")[0]
+
+    # Dependencies
+    dependencies = pixi_data.setdefault("dependencies", {})
+    py_version = cfg.python or f"{sys.version_info.major}.{sys.version_info.minor}"
+    dependencies.setdefault("python", f"{py_version}.*")
+    dependencies.setdefault("pip", "*")
+
+    # PyTorch CUDA index
+    if cfg.has_cuda and cuda_version:
+        pypi_options = pixi_data.setdefault("pypi-options", {})
+        pytorch_index = f"https://download.pytorch.org/whl/cu{cuda_version.replace('.', '')[:3]}"
+        extra_urls = pypi_options.setdefault("extra-index-urls", [])
+        if pytorch_index not in extra_urls: extra_urls.append(pytorch_index)
+
+    # Enforce torch version
+    if cfg.has_cuda and torch_version:
+        pypi_deps = pixi_data.setdefault("pypi-dependencies", {})
+        torch_minor = int(torch_version.split(".")[1])
+        pypi_deps["torch"] = f">={torch_version},<{torch_version.split('.')[0]}.{torch_minor + 1}"
+
+    return pixi_data
+
+
+def deep_merge(base: Dict[str, Any], override: Dict[str, Any]) -> Dict[str, Any]:
+    result = copy.deepcopy(base)
+    for k, v in override.items():
+        if k in result and isinstance(result[k], dict) and isinstance(v, dict):
+            result[k] = deep_merge(result[k], v)
+        else:
+            result[k] = copy.deepcopy(v)
+    return result

comfy_env-0.1.17.dist-info/METADATA

@@ -0,0 +1,225 @@
+Metadata-Version: 2.4
+Name: comfy-env
+Version: 0.1.17
+Summary: Environment management for ComfyUI custom nodes - CUDA wheel resolution and process isolation
+Project-URL: Homepage, https://github.com/PozzettiAndrea/comfy-env
+Project-URL: Repository, https://github.com/PozzettiAndrea/comfy-env
+Project-URL: Issues, https://github.com/PozzettiAndrea/comfy-env/issues
+Author: Andrea Pozzetti
+License: MIT
+License-File: LICENSE
+Keywords: comfyui,cuda,environment,isolation,process,venv,wheels
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Requires-Dist: pip>=21.0
+Requires-Dist: tomli-w>=1.0.0
+Requires-Dist: tomli>=2.0.0
+Requires-Dist: uv>=0.4.0
+Provides-Extra: dev
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# comfy-env
+
+Environment management for ComfyUI custom nodes.
+
+## Quick Start
+
+```bash
+pip install comfy-env
+```
+
+**1. Create `comfy-env-root.toml` in your node directory:**
+
+```toml
+[cuda]
+packages = ["nvdiffrast", "pytorch3d"]
+
+[apt]
+packages = ["libgl1-mesa-glx"]
+
+[node_reqs]
+ComfyUI_essentials = "cubiq/ComfyUI_essentials"
+```
+
+PyPI deps go in `requirements.txt` (standard ComfyUI pattern).
+
+**2. In `install.py`:**
+
+```python
+from comfy_env import install
+install()
+```
+
+**3. In `prestartup_script.py`:**
+
+```python
+from comfy_env import setup_env
+setup_env()
+```
+
+---
+
+## Two Config Files
+
+| File | Purpose |
+|------|---------|
+| `comfy-env-root.toml` | Main node config (root level) |
+| `comfy-env.toml` | Isolated subfolder config |
+
+### comfy-env-root.toml (main node)
+
+```toml
+[cuda]
+packages = ["nvdiffrast", "pytorch3d"]
+
+[apt]
+packages = ["libgl1-mesa-glx"]
+
+[dependencies]
+cgal = "*"
+
+[env_vars]
+KMP_DUPLICATE_LIB_OK = "TRUE"
+
+[node_reqs]
+ComfyUI_essentials = "cubiq/ComfyUI_essentials"
+```
+
+PyPI deps → `requirements.txt`
+
+### comfy-env.toml (isolated folder)
+
+```toml
+python = "3.11"
+
+[dependencies]
+cgal = "*"
+
+[pypi-dependencies]
+trimesh = { version = "*", extras = ["easy"] }
+
+[env_vars]
+SOME_VAR = "value"
+```
+
+### What goes where?
+
+| Section | Root | Isolated |
+|---------|------|----------|
+| `[cuda]` | ✓ | ✓ |
+| `[apt]` | ✓ | ✓ |
+| `[dependencies]` | ✓ | ✓ |
+| `[env_vars]` | ✓ | ✓ |
+| `[node_reqs]` | ✓ | ✗ |
+| `python = "X.Y"` | ✗ | ✓ |
+| `[pypi-dependencies]` | ✗ | ✓ |
+
+---
+
+## Process Isolation
+
+For nodes with conflicting dependencies:
+
+```python
+# In nodes/__init__.py
+from pathlib import Path
+from comfy_env import wrap_isolated_nodes
+
+from .cgal import NODE_CLASS_MAPPINGS as cgal_mappings
+
+NODE_CLASS_MAPPINGS = wrap_isolated_nodes(
+    cgal_mappings,
+    Path(__file__).parent / "cgal"  # Has comfy-env.toml
+)
+```
+
+Each wrapped node runs in a subprocess with its own Python environment.
+
+---
+
+## CLI
+
+```bash
+comfy-env init              # Create comfy-env-root.toml
+comfy-env init --isolated   # Create comfy-env.toml (for subfolders)
+comfy-env install           # Install dependencies
+comfy-env install --dry-run # Preview
+comfy-env info              # Show runtime info
+comfy-env doctor            # Verify packages
+comfy-env apt-install       # Install system packages
+```
+
+---
+
+## API
+
+### install()
+
+```python
+from comfy_env import install
+install()
+```
+
+### setup_env()
+
+```python
+from comfy_env import setup_env
+setup_env()  # Call in prestartup_script.py
+```
+
+### wrap_isolated_nodes()
+
+```python
+from comfy_env import wrap_isolated_nodes
+wrapped = wrap_isolated_nodes(NODE_CLASS_MAPPINGS, node_dir)
+```
+
+### Detection
+
+```python
+from comfy_env import RuntimeEnv, detect_cuda_version, detect_gpu
+
+env = RuntimeEnv.detect()
+print(env)  # Python 3.11, CUDA 12.8, PyTorch 2.8.0, GPU: RTX 4090
+```
+
+---
+
+## Example
+
+See [ComfyUI-GeometryPack](https://github.com/PozzettiAndrea/ComfyUI-GeometryPack):
+
+- Multiple isolated environments (CGAL, Blender, GPU)
+- Per-subdirectory `comfy-env.toml`
+- Different Python versions
+
+---
+
+## Why?
+
+**Why isolation?** ComfyUI nodes share one Python. Conflicts happen when:
+- Node A needs torch 2.4, Node B needs torch 2.8
+- Two packages bundle incompatible libomp
+- Blender API requires Python 3.11
+
+**Why CUDA wheels?** Installing nvdiffrast normally needs CUDA toolkit + C++ compiler + 30 min compilation. [cuda-wheels](https://pozzettiandrea.github.io/cuda-wheels/) provides pre-built wheels.
+
+**How envs work:**
+- Central cache: `~/.comfy-env/envs/`
+- Marker files link nodes → cached envs
+- Config hash in name → changes create new envs
+
+---
+
+## License
+
+MIT