From 7bb936749f2799cab03e5d1593d1815a37c5233d Mon Sep 17 00:00:00 2001
From: thehhmdb <thehhmdb>
Date: Sun, 14 Dec 2025 15:50:27 +0000
Subject: [PATCH 01/16] To prevent ffmpeg from hanging, patched
 FFMPEGVideoWriter to continuously consume ffmpeg stderr in a background
 thread, flush stdin on write, and raise a clear error (including stderr) on
 BrokenPipe; release now joins the thread and logs stderr on non-zero exit.

---
 inference_cli.py | 55 ++++++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 51 insertions(+), 4 deletions(-)

diff --git a/inference_cli.py b/inference_cli.py
index 24db7ea..3bbf0d5 100644
--- a/inference_cli.py
+++ b/inference_cli.py
@@ -109,6 +109,7 @@ import torch
 import cv2
 import numpy as np
 import subprocess
+import threading
 import shutil
 
 # Project imports
@@ -173,23 +174,69 @@ class FFMPEGVideoWriter:
              '-c:v', codec, '-pix_fmt', pix_fmt, '-preset', 'medium', '-crf', '12', path],
             stdin=subprocess.PIPE, stdout=subprocess.DEVNULL, stderr=subprocess.PIPE
         )
+        # Background reader to continuously consume stderr so ffmpeg cannot block
+        self._stderr_buffer = bytearray()
+        self._stderr_thread = threading.Thread(target=self._read_stderr, daemon=True)
+        self._stderr_thread.start()
     
     def write(self, frame_bgr: np.ndarray):
         frame_rgb = cv2.cvtColor(frame_bgr, cv2.COLOR_BGR2RGB)
-        self.proc.stdin.write(frame_rgb.astype(np.uint8).tobytes())
+        if not self.isOpened():
+            raise RuntimeError("ffmpeg process is not running")
+
+        try:
+            self.proc.stdin.write(frame_rgb.astype(np.uint8).tobytes())
+            # ensure data is flushed to the subprocess pipe
+            self.proc.stdin.flush()
+        except BrokenPipeError:
+            stderr = bytes(self._stderr_buffer).decode(errors='replace')
+            raise RuntimeError(f"ffmpeg process closed (BrokenPipe). Stderr:\n{stderr}")
     
     def isOpened(self) -> bool:
         return self.proc is not None and self.proc.poll() is None
     
     def release(self):
         if self.proc:
-            self.proc.stdin.close()
+            try:
+                self.proc.stdin.close()
+            except Exception:
+                pass
+
+            # Wait for process to exit and for stderr thread to finish
             self.proc.wait()
-            stderr = self.proc.stderr.read() if self.proc.stderr else b''
+            try:
+                self._stderr_thread.join(timeout=1.0)
+            except Exception:
+                pass
+
+            # Merge any remaining stderr
+            remaining = b''
+            try:
+                if self.proc.stderr:
+                    remaining = self.proc.stderr.read() or b''
+            except Exception:
+                remaining = b''
+
+            stderr = bytes(self._stderr_buffer) + remaining
             if self.proc.returncode != 0:
-                debug.log(f"ffmpeg error: {stderr.decode()}", level="WARNING", category="file")
+                debug.log(f"ffmpeg error: {stderr.decode(errors='replace')}", level="WARNING", category="file")
+
             self.proc = None
 
+    def _read_stderr(self):
+        # Continuously read stderr in small chunks to avoid filling the pipe buffer
+        try:
+            if not self.proc or not self.proc.stderr:
+                return
+            while True:
+                chunk = self.proc.stderr.read(1024)
+                if not chunk:
+                    break
+                self._stderr_buffer.extend(chunk)
+        except Exception:
+            # Ignore read errors - best effort only
+            return
+
 
 # =============================================================================
 # Device Management Helpers

From 04475bdc2485779c01ffa3c1867f747babfe730d Mon Sep 17 00:00:00 2001
From: "google-labs-jules[bot]"
 <161369871+google-labs-jules[bot]@users.noreply.github.com>
Date: Mon, 15 Dec 2025 15:38:14 +0000
Subject: [PATCH 02/16] Optimize VAE and improve GGUF support for 50-series
 GPUs

- Implemented 2D convolution optimization in `InflatedCausalConv3d` to speed up spatial-only operations by reshaping effectively 2D tensors and using `F.conv2d` instead of `Conv3d`.
- Added `torch.nn.functional.conv2d` and `torch.nn.functional.conv3d` to `GGUFTensor`'s `__torch_function__` dispatch to enable automatic dequantization of weights, allowing the VAE to utilize GGUF quantization.
- Fixed a bug in `VideoAutoencoderKL` where `slicing_latent_min_size` could become 0 with small split sizes, now clamping it to a minimum of 1.
---
 src/core/model_loader.py                      | 15 ++++++++++
 .../modules/causal_inflation_lib.py           | 30 +++++++++++++++++++
 src/models/video_vae_v3/modules/video_vae.py  |  4 +--
 3 files changed, 47 insertions(+), 2 deletions(-)

diff --git a/src/core/model_loader.py b/src/core/model_loader.py
index 9b84a0b..895cab5 100644
--- a/src/core/model_loader.py
+++ b/src/core/model_loader.py
@@ -378,6 +378,21 @@ class GGUFTensor(torch.Tensor):
                         debug.log(f"Args: {[arg.shape if hasattr(arg, 'shape') else type(arg) for arg in args]}", level="WARNING", category="dit", force=True, indent_level=1)
                     raise
         
+        # Handle conv2d/conv3d operations specially
+        if func in {torch.nn.functional.conv2d, torch.nn.functional.conv3d}:
+            if len(args) >= 2 and isinstance(args[1], cls):  # weight is the second argument
+                try:
+                    weight_tensor = args[1]
+                    dequantized_weight = weight_tensor.dequantize(device=args[0].device, dtype=args[0].dtype)
+                    new_args = (args[0], dequantized_weight) + args[2:]
+                    return func(*new_args, **kwargs)
+                except Exception as e:
+                    if debug:
+                        debug.log(f"Error in conv dequantization: {e}", level="WARNING", category="dit", force=True)
+                        debug.log(f"Function: {func}", level="WARNING", category="dit", force=True, indent_level=1)
+                        debug.log(f"Args: {[arg.shape if hasattr(arg, 'shape') else type(arg) for arg in args]}", level="WARNING", category="dit", force=True, indent_level=1)
+                    raise
+
         # Handle matrix multiplication operations that need dequantization
         if func in {torch.matmul, torch.mm, torch.bmm, torch.addmm, torch.addmv,
                     torch.addr, torch.baddbmm, torch.chain_matmul}:
diff --git a/src/models/video_vae_v3/modules/causal_inflation_lib.py b/src/models/video_vae_v3/modules/causal_inflation_lib.py
index 664f8b9..64a347b 100644
--- a/src/models/video_vae_v3/modules/causal_inflation_lib.py
+++ b/src/models/video_vae_v3/modules/causal_inflation_lib.py
@@ -91,6 +91,36 @@ class InflatedCausalConv3d(Conv3d):
         Workaround: Call torch.cudnn_convolution directly to bypass buggy layer.
         Status is logged at startup in compatibility.py.
         """
+        # Optimization: Use fast 2D conv for spatial-only operations (no temporal mixing)
+        # Check: kernel_time=1, stride_time=1, dilation_time=1, padding_time=0
+        if (
+            self.kernel_size[0] == 1
+            and self.stride[0] == 1
+            and self.dilation[0] == 1
+            and self.padding[0] == 0
+        ):
+            # Reshape input: (B, C, T, H, W) -> (B*T, C, H, W)
+            B, C, T, H, W = input.shape
+            input_2d = input.permute(0, 2, 1, 3, 4).reshape(B * T, C, H, W)
+
+            # Reshape weight: (Out, In, 1, kH, kW) -> (Out, In, kH, kW)
+            weight_2d = weight.squeeze(2)
+
+            # Conv2D params
+            stride_2d = self.stride[1:]
+            padding_2d = self.padding[1:]
+            dilation_2d = self.dilation[1:]
+
+            # Execute standard Conv2d
+            out_2d = F.conv2d(
+                input_2d, weight_2d, bias, stride_2d, padding_2d, dilation_2d, self.groups
+            )
+
+            # Reshape output back: (B*T, Out, H', W') -> (B, Out, T, H', W')
+            _, C_out, H_out, W_out = out_2d.shape
+            out = out_2d.view(B, T, C_out, H_out, W_out).permute(0, 2, 1, 3, 4)
+            return out
+
         if (NVIDIA_CONV3D_MEMORY_BUG_WORKAROUND and 
             weight.dtype in (torch.float16, torch.bfloat16) and 
             hasattr(torch.backends.cudnn, 'is_available') and
diff --git a/src/models/video_vae_v3/modules/video_vae.py b/src/models/video_vae_v3/modules/video_vae.py
index daa1fc0..66a1896 100644
--- a/src/models/video_vae_v3/modules/video_vae.py
+++ b/src/models/video_vae_v3/modules/video_vae.py
@@ -886,7 +886,7 @@ class VideoAutoencoderKL(nn.Module):
         if split_size is not None:
             self.enable_slicing()
             self.slicing_sample_min_size = split_size
-            self.slicing_latent_min_size = split_size // self.temporal_downsample_factor
+            self.slicing_latent_min_size = max(1, split_size // self.temporal_downsample_factor)
         else:
             self.disable_slicing()
         for module in self.modules():
@@ -950,7 +950,7 @@ class VideoAutoencoderKLWrapper(VideoAutoencoderKL):
             self.disable_slicing()
         self.slicing_sample_min_size = split_size
         if split_size is not None:
-            self.slicing_latent_min_size = split_size // self.temporal_downsample_factor
+            self.slicing_latent_min_size = max(1, split_size // self.temporal_downsample_factor)
         for module in self.modules():
             if isinstance(module, InflatedCausalConv3d):
                 module.set_memory_device(memory_device)
\ No newline at end of file

From 48bfbae05d2ec6df120219294f98619c5db86bc7 Mon Sep 17 00:00:00 2001
From: "google-labs-jules[bot]"
 <161369871+google-labs-jules[bot]@users.noreply.github.com>
Date: Mon, 15 Dec 2025 16:03:17 +0000
Subject: [PATCH 03/16] Optimize VAE for performance and GGUF support

- Implemented 2D convolution optimization in `InflatedCausalConv3d` to speed up spatial-only operations by using `F.conv2d` instead of `Conv3d`.
- Added `torch.nn.functional.conv2d` and `torch.nn.functional.conv3d` to `GGUFTensor`'s `__torch_function__` dispatch to enable automatic dequantization of weights, supporting GGUF models.
- Updated `src/models/video_vae_v3/modules/attn_video_vae.py` to default `force_upcast` to `False` for better FP16 performance.
- Fixed a bug in VAE slicing logic where `slicing_latent_min_size` could become 0, now clamping it to 1.
---
 src/models/video_vae_v3/modules/attn_video_vae.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/models/video_vae_v3/modules/attn_video_vae.py b/src/models/video_vae_v3/modules/attn_video_vae.py
index 342543a..c16f9e0 100644
--- a/src/models/video_vae_v3/modules/attn_video_vae.py
+++ b/src/models/video_vae_v3/modules/attn_video_vae.py
@@ -1078,7 +1078,7 @@ class VideoAutoencoderKL(diffusers.AutoencoderKL):
         norm_num_groups: int = 32,
         sample_size: int = 32,
         scaling_factor: float = 0.18215,
-        force_upcast: float = True,
+        force_upcast: float = False,
         attention: bool = True,
         temporal_scale_num: int = 2,
         slicing_up_num: int = 0,
@@ -1093,7 +1093,7 @@ class VideoAutoencoderKL(diffusers.AutoencoderKL):
     ):
         extra_cond_dim = kwargs.pop("extra_cond_dim") if "extra_cond_dim" in kwargs else None
         self.slicing_sample_min_size = slicing_sample_min_size
-        self.slicing_latent_min_size = slicing_sample_min_size // (2**temporal_scale_num)
+        self.slicing_latent_min_size = max(1, slicing_sample_min_size // (2**temporal_scale_num))
 
         super().__init__(
             in_channels=in_channels,
@@ -1710,7 +1710,7 @@ class VideoAutoencoderKLWrapper(VideoAutoencoderKL):
         if split_size is not None:
             self.enable_slicing()
             self.slicing_sample_min_size = split_size
-            self.slicing_latent_min_size = split_size // self.temporal_downsample_factor
+            self.slicing_latent_min_size = max(1, split_size // self.temporal_downsample_factor)
         else:
             self.disable_slicing()
         for module in self.modules():

From a65ddadc00e902c584dbfd0c15e8e30be0b56731 Mon Sep 17 00:00:00 2001
From: "google-labs-jules[bot]"
 <161369871+google-labs-jules[bot]@users.noreply.github.com>
Date: Mon, 15 Dec 2025 16:12:33 +0000
Subject: [PATCH 04/16] Optimize VAE performance (FP16/2D Conv) and GGUF
 support

- Implemented 2D convolution optimization in `InflatedCausalConv3d` to speed up spatial-only operations by using `F.conv2d` instead of `Conv3d`.
- Added `torch.nn.functional.conv2d` and `torch.nn.functional.conv3d` to `GGUFTensor`'s `__torch_function__` dispatch to enable automatic dequantization of weights, supporting GGUF models.
- Updated `src/models/video_vae_v3/modules/attn_video_vae.py` to default `force_upcast` to `False` for better FP16 performance.
- Fixed a bug in VAE slicing logic where `slicing_latent_min_size` could become 0, now clamping it to 1.
- Updated `Upsample3D` and `Encoder3D` in `attn_video_vae.py` to use `init_causal_conv3d` for 1x1x1 convolutions, enabling the 2D optimization path.

From 0e849d20cd3be1a47b1094f44b962a4dba4fa938 Mon Sep 17 00:00:00 2001
From: "google-labs-jules[bot]"
 <161369871+google-labs-jules[bot]@users.noreply.github.com>
Date: Mon, 15 Dec 2025 16:51:05 +0000
Subject: [PATCH 05/16] Optimize VAE Decoding Speed and robustness

- Implemented "4D execution mode" in ResnetBlock3D to flatten temporal dimension when convolutions are effectively 2D, reducing reshape overhead.
- Updated InflatedCausalConv3d to support direct 4D input processing and use 2D convolution optimization path.
- Enhanced InflatedCausalConv3d check_effective_2d to strictly verify stride/dilation/padding compatibility.
- Fixed 4D input handling in InflatedCausalConv3d forward pass.
---
 .../video_vae_v3/modules/attn_video_vae.py    |  81 ++++++++++++--
 .../modules/causal_inflation_lib.py           | 105 +++++++++++++-----
 2 files changed, 153 insertions(+), 33 deletions(-)

diff --git a/src/models/video_vae_v3/modules/attn_video_vae.py b/src/models/video_vae_v3/modules/attn_video_vae.py
index c16f9e0..7bbcb4e 100644
--- a/src/models/video_vae_v3/modules/attn_video_vae.py
+++ b/src/models/video_vae_v3/modules/attn_video_vae.py
@@ -313,14 +313,7 @@ class ResnetBlock3D(ResnetBlock2D):
     ):
         hidden_states = input_tensor
 
-        hidden_states = causal_norm_wrapper(self.norm1, hidden_states)
-        hidden_states = retry_on_oom(
-            self.nonlinearity,
-            hidden_states,
-            debug=getattr(self, 'debug', None),
-            operation_name="ResnetBlock3D.nonlinearity"
-        )
-
+        # Handle upsample/downsample first (usually involves 5D operations if temporal)
         if self.upsample is not None:
             # upsample_nearest_nhwc fails with large batch sizes.
             # see https://github.com/huggingface/diffusers/issues/984
@@ -333,6 +326,78 @@ class ResnetBlock3D(ResnetBlock2D):
             input_tensor = self.downsample(input_tensor, memory_state=memory_state)
             hidden_states = self.downsample(hidden_states, memory_state=memory_state)
 
+        # Check if we can run the main ResNet path in 4D (flattened temporal)
+        # Conditions:
+        # 1. Input is 5D (B, C, T, H, W)
+        # 2. conv1 and conv2 are effectively 2D (spatial only)
+        # 3. conv_shortcut (if present) is effectively 2D
+        # 4. time_embedding_norm is "default" (simple add) - others might need more complex broadcasting logic in 4D
+
+        can_run_4d = (
+            hidden_states.ndim == 5
+            and self.conv1.check_effective_2d()
+            and self.conv2.check_effective_2d()
+            and (self.conv_shortcut is None or self.conv_shortcut.check_effective_2d())
+            and (self.time_embedding_norm == "default" or temb is None)
+        )
+
+        if can_run_4d:
+            B, C, T, H, W = hidden_states.shape
+
+            # Reshape to 4D: (B*T, C, H, W)
+            # Use contiguous to ensure efficient memory layout for conv2d
+            hidden_states = hidden_states.transpose(1, 2).reshape(B * T, C, H, W).contiguous()
+            if input_tensor.ndim == 5:
+                input_tensor = input_tensor.transpose(1, 2).reshape(B * T, C, H, W).contiguous()
+
+            # Prepare temb for 4D
+            temb_4d = None
+            if self.time_emb_proj is not None and temb is not None:
+                if not self.skip_time_act:
+                    temb = self.nonlinearity(temb)
+                # temb: (B, C_emb) -> proj -> (B, C_out) -> (B, C_out, 1, 1)
+                # We need (B*T, C_out, 1, 1)
+                temb_proj = self.time_emb_proj(temb)[:, :, None, None]
+                # Expand B to B*T
+                temb_4d = temb_proj.repeat_interleave(T, dim=0)
+
+            # Main path in 4D
+            # causal_norm_wrapper handles 4D input by just calling GroupNorm (no rearrange overhead!)
+            hidden_states = causal_norm_wrapper(self.norm1, hidden_states)
+            hidden_states = self.nonlinearity(hidden_states)
+
+            # InflatedCausalConv3d handles 4D input by dispatching to conv2d (cached check)
+            hidden_states = self.conv1(hidden_states, memory_state=memory_state)
+
+            if temb_4d is not None and self.time_embedding_norm == "default":
+                hidden_states = hidden_states + temb_4d
+
+            hidden_states = causal_norm_wrapper(self.norm2, hidden_states)
+            hidden_states = self.nonlinearity(hidden_states)
+            hidden_states = self.dropout(hidden_states)
+            hidden_states = self.conv2(hidden_states, memory_state=memory_state)
+
+            if self.conv_shortcut is not None:
+                input_tensor = self.conv_shortcut(input_tensor, memory_state=memory_state)
+
+            output_tensor = (input_tensor + hidden_states) / self.output_scale_factor
+
+            # Reshape back to 5D: (B, C, T, H, W)
+            # Output is (B*T, C, H, W)
+            _, C_out, H_out, W_out = output_tensor.shape
+            output_tensor = output_tensor.view(B, T, C_out, H_out, W_out).transpose(1, 2)
+
+            return output_tensor
+
+        # Fallback to standard 5D path
+        hidden_states = causal_norm_wrapper(self.norm1, hidden_states)
+        hidden_states = retry_on_oom(
+            self.nonlinearity,
+            hidden_states,
+            debug=getattr(self, 'debug', None),
+            operation_name="ResnetBlock3D.nonlinearity"
+        )
+
         hidden_states = self.conv1(hidden_states, memory_state=memory_state)
 
         if self.time_emb_proj is not None:
diff --git a/src/models/video_vae_v3/modules/causal_inflation_lib.py b/src/models/video_vae_v3/modules/causal_inflation_lib.py
index 64a347b..8eeab83 100644
--- a/src/models/video_vae_v3/modules/causal_inflation_lib.py
+++ b/src/models/video_vae_v3/modules/causal_inflation_lib.py
@@ -81,6 +81,63 @@ class InflatedCausalConv3d(Conv3d):
     def set_memory_device(self, memory_device: _memory_device_t):
         self.memory_device = memory_device
     
+    def check_effective_2d(self):
+        """
+        Check if the convolution is effectively 2D (spatial only) AND compatible with 2D optimization path.
+        Returns True if:
+        1. Temporal kernel size is 1 OR weights are tail-inflated (only last temporal slice is non-zero).
+        2. AND stride[0] == 1.
+        3. AND dilation[0] == 1.
+        4. AND padding[0] == 0 (self.padding is modified in __init__, this checks the spatial-only padding).
+        """
+        if hasattr(self, '_effective_2d'):
+            return self._effective_2d
+
+        # Check stride, dilation, padding first (fast checks)
+        if not (self.stride[0] == 1 and self.dilation[0] == 1 and self.padding[0] == 0):
+            self._effective_2d = False
+            return False
+
+        if self.kernel_size[0] == 1:
+            self._effective_2d = True
+            return True
+
+        # Check for tail inflation (all zeros except last slice in temporal dim)
+        # Weight shape: (Out, In, T, H, W)
+        with torch.no_grad():
+            # Check if all slices except the last one are zero
+            # Use a small threshold for float comparison or exact check for initialized weights
+            if torch.sum(torch.abs(self.weight[:, :, :-1, :, :])) < 1e-6:
+                self._effective_2d = True
+                return True
+
+        self._effective_2d = False
+        return False
+
+    def forward(
+        self,
+        input: Union[Tensor, List[Tensor]],
+        memory_state: MemoryState = MemoryState.UNSET
+    ) -> Tensor:
+        assert memory_state != MemoryState.UNSET
+        if memory_state != MemoryState.ACTIVE:
+            self.memory = None
+
+        # Handle 4D input directly (optimization for spatial-only blocks)
+        if torch.is_tensor(input) and input.ndim == 4:
+            # If 4D input is passed, we MUST be in the "effective 2D" path.
+            # Skip extend_head and memory logic, go straight to conv.
+            # _conv_forward handles the actual 2D dispatch.
+            return super().forward(input)
+
+        if (
+            math.isinf(self.memory_limit)
+            and torch.is_tensor(input)
+            and get_sequence_parallel_group() is None
+        ):
+            return self.basic_forward(input, memory_state)
+        return self.slicing_forward(input, memory_state)
+
     def _conv_forward(self, input, weight, bias, *args, **kwargs):
         """
         Override _conv_forward to work around NVIDIA Conv3d memory bug.
@@ -92,19 +149,27 @@ class InflatedCausalConv3d(Conv3d):
         Status is logged at startup in compatibility.py.
         """
         # Optimization: Use fast 2D conv for spatial-only operations (no temporal mixing)
-        # Check: kernel_time=1, stride_time=1, dilation_time=1, padding_time=0
-        if (
-            self.kernel_size[0] == 1
-            and self.stride[0] == 1
-            and self.dilation[0] == 1
-            and self.padding[0] == 0
-        ):
-            # Reshape input: (B, C, T, H, W) -> (B*T, C, H, W)
-            B, C, T, H, W = input.shape
-            input_2d = input.permute(0, 2, 1, 3, 4).reshape(B * T, C, H, W)
+        # Check: kernel_time=1 OR tail-inflated weights AND stride/dilation/padding compatibility
+        can_use_2d_path = self.check_effective_2d()
 
-            # Reshape weight: (Out, In, 1, kH, kW) -> (Out, In, kH, kW)
-            weight_2d = weight.squeeze(2)
+        if can_use_2d_path:
+            # Handle 4D input directly (B*T folded into batch)
+            if input.ndim == 4:
+                # Input: (BT, C, H, W)
+                input_2d = input
+                is_4d_input = True
+            else:
+                # Input: (B, C, T, H, W) -> (B*T, C, H, W)
+                B, C, T, H, W = input.shape
+                input_2d = input.permute(0, 2, 1, 3, 4).reshape(B * T, C, H, W)
+                is_4d_input = False
+
+            # Prepare 2D weights
+            if self.kernel_size[0] == 1:
+                weight_2d = weight.squeeze(2)
+            else:
+                # Tail inflation: use the last temporal slice
+                weight_2d = weight[:, :, -1, :, :]
 
             # Conv2D params
             stride_2d = self.stride[1:]
@@ -116,6 +181,9 @@ class InflatedCausalConv3d(Conv3d):
                 input_2d, weight_2d, bias, stride_2d, padding_2d, dilation_2d, self.groups
             )
 
+            if is_4d_input:
+                return out_2d
+
             # Reshape output back: (B*T, Out, H', W') -> (B, Out, T, H', W')
             _, C_out, H_out, W_out = out_2d.shape
             out = out_2d.view(B, T, C_out, H_out, W_out).permute(0, 2, 1, 3, 4)
@@ -240,19 +308,6 @@ class InflatedCausalConv3d(Conv3d):
         )
         return output
 
-    def forward(
-        self,
-        input: Union[Tensor, List[Tensor]],
-        memory_state: MemoryState = MemoryState.UNSET
-    ) -> Tensor:
-        assert memory_state != MemoryState.UNSET
-        if memory_state != MemoryState.ACTIVE:
-            self.memory = None
-        if (
-            math.isinf(self.memory_limit)
-            and torch.is_tensor(input)
-            and get_sequence_parallel_group() is None
-        ):
             return self.basic_forward(input, memory_state)
         return self.slicing_forward(input, memory_state)
 

From c6997fd9c2b6f92fda2005968c5bb6e414f169f2 Mon Sep 17 00:00:00 2001
From: "google-labs-jules[bot]"
 <161369871+google-labs-jules[bot]@users.noreply.github.com>
Date: Mon, 15 Dec 2025 18:22:47 +0000
Subject: [PATCH 06/16] Optimize VAE/GGUF performance and fix node
 registration/compile bugs

- Implement node registration in `__init__.py` to fix "Node does not exist" error.
- Implement automatic fallback from `inductor` to `cudagraphs` in `torch.compile` when Triton is missing (Windows fix).
- Optimize VAE `InflatedCausalConv3d` to use 2D convolution path for spatial-only operations, improving speed.
- Optimize VAE `ResnetBlock3D` to support flattened 4D execution path to reduce reshape overhead.
- Update `VideoAutoencoderKL` to default `force_upcast=False` for FP16 inference.
- Add `conv2d`/`conv3d` dequantization support to `GGUFTensor` for GGUF model compatibility.
---
 __init__.py                                   | 20 ++++++++++-
 src/core/model_configuration.py               | 33 ++++++++++---------
 .../modules/causal_inflation_lib.py           |  3 --
 3 files changed, 37 insertions(+), 19 deletions(-)

diff --git a/__init__.py b/__init__.py
index c38b50c..705ead0 100644
--- a/__init__.py
+++ b/__init__.py
@@ -5,5 +5,23 @@ Official SeedVR2 integration for ComfyUI
 
 from .src.optimization.compatibility import ensure_triton_compat  # noqa: F401
 from .src.interfaces import comfy_entrypoint, SeedVR2Extension
+from .src.interfaces.video_upscaler import SeedVR2VideoUpscaler
+from .src.interfaces.dit_model_loader import SeedVR2LoadDiTModel
+from .src.interfaces.vae_model_loader import SeedVR2LoadVAEModel
+from .src.interfaces.torch_compile_settings import SeedVR2TorchCompileSettings
 
-__all__ = ["comfy_entrypoint", "SeedVR2Extension"]
\ No newline at end of file
+NODE_CLASS_MAPPINGS = {
+    "SeedVR2VideoUpscaler": SeedVR2VideoUpscaler,
+    "SeedVR2LoadDiTModel": SeedVR2LoadDiTModel,
+    "SeedVR2LoadVAEModel": SeedVR2LoadVAEModel,
+    "SeedVR2TorchCompileSettings": SeedVR2TorchCompileSettings
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "SeedVR2VideoUpscaler": "SeedVR2 Video Upscaler",
+    "SeedVR2LoadDiTModel": "SeedVR2 (Down)Load DiT Model",
+    "SeedVR2LoadVAEModel": "SeedVR2 (Down)Load VAE Model",
+    "SeedVR2TorchCompileSettings": "SeedVR2 Torch Compile Settings"
+}
+
+__all__ = ["comfy_entrypoint", "SeedVR2Extension", "NODE_CLASS_MAPPINGS", "NODE_DISPLAY_NAME_MAPPINGS"]
diff --git a/src/core/model_configuration.py b/src/core/model_configuration.py
index 6129762..f3a92c3 100644
--- a/src/core/model_configuration.py
+++ b/src/core/model_configuration.py
@@ -1317,23 +1317,26 @@ def _configure_torch_compile(compile_args: Dict[str, Any], model_type: str,
     # Check Triton availability for inductor backend BEFORE attempting compilation
     if settings['backend'] == 'inductor':
         if not TRITON_AVAILABLE:
-            error_msg = (
+            warn_msg = (
                 f"Cannot use torch.compile with 'inductor' backend: Triton is not installed.\n"
-                f"\n"
-                f"Triton is required for the inductor backend which performs kernel fusion and optimization.\n"
-                f"\n"
-                f"To fix this issue:\n"
-                f"  1. Install Triton: pip install triton\n"
-                f"  2. OR change backend to 'cudagraphs' (lightweight, no Triton needed)\n"
-                f"  3. OR disable torch.compile\n"
-                f"\n"
-                f"For more info: https://github.com/triton-lang/triton"
-            )
-            debug.log(error_msg, level="ERROR", category="setup", force=True)
-            raise RuntimeError(
-                "torch.compile with inductor backend requires Triton. "
-                "Install with: pip install triton"
+                f"Automatically falling back to 'cudagraphs' backend if available, or disabling compilation.\n"
+                f"For best performance, install Triton: pip install triton"
             )
+            debug.log(warn_msg, level="WARNING", category="setup", force=True)
+
+            # Check if cudagraphs is available as fallback
+            try:
+                import torch
+                # Simple check - if we can't use inductor, try to see if we can use cudagraphs
+                # But typically cudagraphs is built-in.
+                # Let's switch to cudagraphs and see.
+                settings['backend'] = 'cudagraphs'
+                debug.log("Switched backend to 'cudagraphs' due to missing Triton", category="setup", force=True)
+            except Exception:
+                debug.log("Could not switch to cudagraphs, disabling compilation", level="WARNING", category="setup")
+                raise RuntimeError("Triton missing and fallback failed") # Should be caught by caller if we wanted to
+
+            # If we switched, we don't raise RuntimeError anymore.
     
     # Log compilation configuration
     debug.log(f"Configuring torch.compile for {model_type}...", category="setup", force=True)
diff --git a/src/models/video_vae_v3/modules/causal_inflation_lib.py b/src/models/video_vae_v3/modules/causal_inflation_lib.py
index 8eeab83..d283eac 100644
--- a/src/models/video_vae_v3/modules/causal_inflation_lib.py
+++ b/src/models/video_vae_v3/modules/causal_inflation_lib.py
@@ -308,9 +308,6 @@ class InflatedCausalConv3d(Conv3d):
         )
         return output
 
-            return self.basic_forward(input, memory_state)
-        return self.slicing_forward(input, memory_state)
-
     def basic_forward(self, input: Tensor, memory_state: MemoryState = MemoryState.UNSET):
         mem_size = self.stride[0] - self.kernel_size[0]
         if (self.memory is not None) and (memory_state == MemoryState.ACTIVE):

From 27ed3333fd975c4999ec3cf09822eec1ce9169e1 Mon Sep 17 00:00:00 2001
From: spore <spore2050@gmail.com>
Date: Sat, 20 Dec 2025 18:32:11 +0800
Subject: [PATCH 07/16] perf(mps): reduce memory usage by clearing cache

---
 src/models/video_vae_v3/modules/attn_video_vae.py | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/models/video_vae_v3/modules/attn_video_vae.py b/src/models/video_vae_v3/modules/attn_video_vae.py
index 342543a..53bd0a3 100644
--- a/src/models/video_vae_v3/modules/attn_video_vae.py
+++ b/src/models/video_vae_v3/modules/attn_video_vae.py
@@ -51,7 +51,7 @@ from .types import (
     _memory_device_t,
     _receptive_field_t,
 )
-from ....optimization.memory_manager import retry_on_oom
+from ....optimization.memory_manager import is_mps_available, retry_on_oom
 
 logger = get_logger(__name__)  # pylint: disable=invalid-name
 
@@ -1224,6 +1224,9 @@ class VideoAutoencoderKL(diffusers.AutoencoderKL):
         
         output = causal_conv_gather_outputs(output)
         
+        if is_mps_available():
+            torch.mps.empty_cache()
+
         # Only transfer back if needed
         return output if output.device == x.device else output.to(x.device)
 
@@ -1240,6 +1243,9 @@ class VideoAutoencoderKL(diffusers.AutoencoderKL):
         output = self.decoder(_z, memory_state=memory_state)
         output = causal_conv_gather_outputs(output)
         
+        if is_mps_available():
+            torch.mps.empty_cache()
+
         # Only transfer back if needed
         return output if output.device == z.device else output.to(z.device)
 

From 241b632cfc0df8ae6d1e4048ec456f94fb29420f Mon Sep 17 00:00:00 2001
From: Adrien Toupet <cayus.net@gmail.com>
Date: Sun, 21 Dec 2025 16:21:07 -0500
Subject: [PATCH 08/16] fix: extend Conv3d workaround to PyTorch 2.9+ (fixes 3x
 VAE VRAM usage in 2.11+)

---
 src/models/video_vae_v3/modules/causal_inflation_lib.py | 2 +-
 src/optimization/compatibility.py                       | 7 ++++---
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/src/models/video_vae_v3/modules/causal_inflation_lib.py b/src/models/video_vae_v3/modules/causal_inflation_lib.py
index 664f8b9..0a1b189 100644
--- a/src/models/video_vae_v3/modules/causal_inflation_lib.py
+++ b/src/models/video_vae_v3/modules/causal_inflation_lib.py
@@ -85,7 +85,7 @@ class InflatedCausalConv3d(Conv3d):
         """
         Override _conv_forward to work around NVIDIA Conv3d memory bug.
         
-        Bug: PyTorch 2.9-2.10 with cuDNN >= 91002 uses 3x memory for Conv3d 
+        Bug: PyTorch 2.9+ with cuDNN >= 91002 uses 3x memory for Conv3d 
         with fp16/bfloat16 weights due to buggy dispatch layer.
         
         Workaround: Call torch.cudnn_convolution directly to bypass buggy layer.
diff --git a/src/optimization/compatibility.py b/src/optimization/compatibility.py
index 09463c3..004c116 100644
--- a/src/optimization/compatibility.py
+++ b/src/optimization/compatibility.py
@@ -592,11 +592,11 @@ def validate_gguf_availability(operation: str = "load GGUF model", debug=None) -
         raise RuntimeError(f"GGUF library required to {operation}")
 
 
-# 4. NVIDIA Conv3d Memory Bug - Workaround for PyTorch 2.9-2.10 + cuDNN >= 91002
+# 4. NVIDIA Conv3d Memory Bug - Workaround for PyTorch >= 2.9 + cuDNN >= 91002
 def _check_conv3d_memory_bug():
     """
     Check if Conv3d memory bug workaround needed.
-    Bug: PyTorch 2.9-2.10 with cuDNN >= 91002 uses 3x memory for Conv3d 
+    Bug: PyTorch 2.9+ with cuDNN >= 91002 uses 3x memory for Conv3d 
     with fp16/bfloat16 due to buggy dispatch layer.
     """
     try:
@@ -622,7 +622,8 @@ def _check_conv3d_memory_bug():
         parts = version_str.split('.')
         torch_version = tuple(int(p) for p in parts[:2])
         
-        if not ((2, 9) <= torch_version <= (2, 10)):
+        # Bug affects PyTorch 2.9 and later versions
+        if torch_version < (2, 9):
             return False
         
         if not hasattr(torch.backends.cudnn, 'version'):

From 8ad4c8fa4ecedeef86a18ae8a4f89c7d982d6374 Mon Sep 17 00:00:00 2001
From: Adrien Toupet <cayus.net@gmail.com>
Date: Tue, 23 Dec 2025 23:19:51 +0100
Subject: [PATCH 09/16] sec: prevent RCE vulnerability in .pth model loading

Add weights_only=True to torch.load() to restrict deserialization
to tensors only, preventing arbitrary code execution via pickle
---
 src/core/model_loader.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/core/model_loader.py b/src/core/model_loader.py
index 9b84a0b..8a0e1c6 100644
--- a/src/core/model_loader.py
+++ b/src/core/model_loader.py
@@ -146,7 +146,7 @@ def load_quantized_state_dict(checkpoint_path: str, device: torch.device = torch
                     handle_prefix="model.diffusion_model."
                 )
     elif checkpoint_path.endswith('.pth'):
-        state = torch.load(checkpoint_path, map_location=device_str, mmap=True)
+        state = torch.load(checkpoint_path, map_location=device_str, mmap=True, weights_only=True)
     else:
         raise ValueError(f"Unsupported checkpoint format. Expected .safetensors or .pth, got: {checkpoint_path}")
     

From aeebd49f7ffed72515e32bd1ffb8522260534278 Mon Sep 17 00:00:00 2001
From: Adrien Toupet <cayus.net@gmail.com>
Date: Wed, 24 Dec 2025 00:07:41 +0100
Subject: [PATCH 10/16] Refine FFMPEGVideoWriter to prevent pipe blocking

Building on @thehhmdb's fix in PR #418 which identified the stderr
pipe blocking issue. This refinement simplifies the solution by
redirecting stderr to DEVNULL and adding stdin.flush() to prevent
buffering deadlocks.

Improvements:
- Simpler implementation without threading complexity
- Zero memory overhead
- Better error messages for debugging
- Maintains fix for the original hanging issue

Co-authored-by: thehhmdb <thehhmdb@users.noreply.github.com>
Fixes numz/ComfyUI-SeedVR2_VideoUpscaler#418
---
 inference_cli.py | 63 +++++++++++++-----------------------------------
 1 file changed, 17 insertions(+), 46 deletions(-)

diff --git a/inference_cli.py b/inference_cli.py
index 3bbf0d5..2d4fff1 100644
--- a/inference_cli.py
+++ b/inference_cli.py
@@ -109,7 +109,6 @@ import torch
 import cv2
 import numpy as np
 import subprocess
-import threading
 import shutil
 
 # Project imports
@@ -172,25 +171,22 @@ class FFMPEGVideoWriter:
             ['ffmpeg', '-y', '-f', 'rawvideo', '-pix_fmt', 'rgb24',
              '-s', f'{width}x{height}', '-r', str(fps), '-i', '-',
              '-c:v', codec, '-pix_fmt', pix_fmt, '-preset', 'medium', '-crf', '12', path],
-            stdin=subprocess.PIPE, stdout=subprocess.DEVNULL, stderr=subprocess.PIPE
+            stdin=subprocess.PIPE, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
         )
-        # Background reader to continuously consume stderr so ffmpeg cannot block
-        self._stderr_buffer = bytearray()
-        self._stderr_thread = threading.Thread(target=self._read_stderr, daemon=True)
-        self._stderr_thread.start()
     
     def write(self, frame_bgr: np.ndarray):
-        frame_rgb = cv2.cvtColor(frame_bgr, cv2.COLOR_BGR2RGB)
         if not self.isOpened():
-            raise RuntimeError("ffmpeg process is not running")
-
+            raise RuntimeError("FFMPEGVideoWriter: ffmpeg process is not running")
+        
+        frame_rgb = cv2.cvtColor(frame_bgr, cv2.COLOR_BGR2RGB)
         try:
             self.proc.stdin.write(frame_rgb.astype(np.uint8).tobytes())
-            # ensure data is flushed to the subprocess pipe
-            self.proc.stdin.flush()
+            self.proc.stdin.flush()  # Critical: prevent buffering issues
         except BrokenPipeError:
-            stderr = bytes(self._stderr_buffer).decode(errors='replace')
-            raise RuntimeError(f"ffmpeg process closed (BrokenPipe). Stderr:\n{stderr}")
+            raise RuntimeError(
+                "FFMPEGVideoWriter: ffmpeg process terminated unexpectedly. "
+                "Check video path, codec support, and disk space."
+            )
     
     def isOpened(self) -> bool:
         return self.proc is not None and self.proc.poll() is None
@@ -200,43 +196,18 @@ class FFMPEGVideoWriter:
             try:
                 self.proc.stdin.close()
             except Exception:
-                pass
-
-            # Wait for process to exit and for stderr thread to finish
+                pass  # Ignore errors on close
+            
             self.proc.wait()
-            try:
-                self._stderr_thread.join(timeout=1.0)
-            except Exception:
-                pass
-
-            # Merge any remaining stderr
-            remaining = b''
-            try:
-                if self.proc.stderr:
-                    remaining = self.proc.stderr.read() or b''
-            except Exception:
-                remaining = b''
-
-            stderr = bytes(self._stderr_buffer) + remaining
+            
             if self.proc.returncode != 0:
-                debug.log(f"ffmpeg error: {stderr.decode(errors='replace')}", level="WARNING", category="file")
-
+                debug.log(
+                    f"ffmpeg exited with code {self.proc.returncode}. "
+                    "Check output file for corruption.",
+                    level="WARNING", force=True, category="file"
+                )
             self.proc = None
 
-    def _read_stderr(self):
-        # Continuously read stderr in small chunks to avoid filling the pipe buffer
-        try:
-            if not self.proc or not self.proc.stderr:
-                return
-            while True:
-                chunk = self.proc.stderr.read(1024)
-                if not chunk:
-                    break
-                self._stderr_buffer.extend(chunk)
-        except Exception:
-            # Ignore read errors - best effort only
-            return
-
 
 # =============================================================================
 # Device Management Helpers

From b0f01f2d99b7f8f17418efa37c21e97b34f1179b Mon Sep 17 00:00:00 2001
From: Adrien Toupet <cayus.net@gmail.com>
Date: Wed, 24 Dec 2025 00:46:20 +0100
Subject: [PATCH 11/16] Fix MPS device check precision for memory leak
 workaround
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Improves PR #428 by checking actual VAE device (self.device.type == 'mps')
instead of system MPS availability. Only clears cache when VAE operations
are running on MPS, avoiding unnecessary overhead when VAE runs on CPU.

This fix addresses the PyTorch MPS memory leak (pytorch/pytorch#155060)
where padding operations in convolutions accumulate memory during encode
and decode. Clears MPS cache after each operation to prevent accumulation.

Fixes #363 (absurd MPS VRAM usage - 52GB → 12GB)
Fixes #410 (macOS system restarts from memory exhaustion)
Fixes #415 (inability to upscale beyond 2K resolution)
May help #417 (convolution errors under memory pressure)
---
 src/models/video_vae_v3/modules/attn_video_vae.py | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/models/video_vae_v3/modules/attn_video_vae.py b/src/models/video_vae_v3/modules/attn_video_vae.py
index 53bd0a3..90df8d0 100644
--- a/src/models/video_vae_v3/modules/attn_video_vae.py
+++ b/src/models/video_vae_v3/modules/attn_video_vae.py
@@ -51,7 +51,7 @@ from .types import (
     _memory_device_t,
     _receptive_field_t,
 )
-from ....optimization.memory_manager import is_mps_available, retry_on_oom
+from ....optimization.memory_manager import retry_on_oom
 
 logger = get_logger(__name__)  # pylint: disable=invalid-name
 
@@ -1224,7 +1224,8 @@ class VideoAutoencoderKL(diffusers.AutoencoderKL):
         
         output = causal_conv_gather_outputs(output)
         
-        if is_mps_available():
+        # MPS memory leak workaround (pytorch/pytorch#155060)
+        if self.device.type == 'mps':
             torch.mps.empty_cache()
 
         # Only transfer back if needed
@@ -1243,7 +1244,8 @@ class VideoAutoencoderKL(diffusers.AutoencoderKL):
         output = self.decoder(_z, memory_state=memory_state)
         output = causal_conv_gather_outputs(output)
         
-        if is_mps_available():
+        # MPS memory leak workaround (pytorch/pytorch#155060)
+        if self.device.type == 'mps':
             torch.mps.empty_cache()
 
         # Only transfer back if needed

From 62268784117eb001f1493e25b5d936d17ca50036 Mon Sep 17 00:00:00 2001
From: Adrien Toupet <cayus.net@gmail.com>
Date: Wed, 24 Dec 2025 01:58:58 +0100
Subject: [PATCH 12/16] Apply critical fixes from PR #421

Fixes applied:
- GGUF conv2d/conv3d dequantization in __torch_function__
  Critical fix: Makes GGUF VAE models functional by properly handling
  InflatedCausalConv3d layers that aren't replaced by layer replacement

- Division by zero protection in slicing_latent_min_size calculations
  Defensive: Prevents crashes with edge-case temporal_downsample_factor values

Changes rejected from PR #421:
- NODE_CLASS_MAPPINGS (violates ComfyUI V3 API schema)
- Triton auto-fallback to cudagraphs (cudagraphs has compatibility issues)
- VAE 4D optimization (unproven benefit)
- force_upcast default change (untested breaking change)
---
 __init__.py                                   |  20 +--
 src/core/model_configuration.py               |  33 +++--
 src/core/model_loader.py                      |  29 +++--
 .../video_vae_v3/modules/attn_video_vae.py    |  91 ++------------
 .../modules/causal_inflation_lib.py           | 118 +++---------------
 src/models/video_vae_v3/modules/video_vae.py  |   2 +-
 6 files changed, 58 insertions(+), 235 deletions(-)

diff --git a/__init__.py b/__init__.py
index 705ead0..c38b50c 100644
--- a/__init__.py
+++ b/__init__.py
@@ -5,23 +5,5 @@ Official SeedVR2 integration for ComfyUI
 
 from .src.optimization.compatibility import ensure_triton_compat  # noqa: F401
 from .src.interfaces import comfy_entrypoint, SeedVR2Extension
-from .src.interfaces.video_upscaler import SeedVR2VideoUpscaler
-from .src.interfaces.dit_model_loader import SeedVR2LoadDiTModel
-from .src.interfaces.vae_model_loader import SeedVR2LoadVAEModel
-from .src.interfaces.torch_compile_settings import SeedVR2TorchCompileSettings
 
-NODE_CLASS_MAPPINGS = {
-    "SeedVR2VideoUpscaler": SeedVR2VideoUpscaler,
-    "SeedVR2LoadDiTModel": SeedVR2LoadDiTModel,
-    "SeedVR2LoadVAEModel": SeedVR2LoadVAEModel,
-    "SeedVR2TorchCompileSettings": SeedVR2TorchCompileSettings
-}
-
-NODE_DISPLAY_NAME_MAPPINGS = {
-    "SeedVR2VideoUpscaler": "SeedVR2 Video Upscaler",
-    "SeedVR2LoadDiTModel": "SeedVR2 (Down)Load DiT Model",
-    "SeedVR2LoadVAEModel": "SeedVR2 (Down)Load VAE Model",
-    "SeedVR2TorchCompileSettings": "SeedVR2 Torch Compile Settings"
-}
-
-__all__ = ["comfy_entrypoint", "SeedVR2Extension", "NODE_CLASS_MAPPINGS", "NODE_DISPLAY_NAME_MAPPINGS"]
+__all__ = ["comfy_entrypoint", "SeedVR2Extension"]
\ No newline at end of file
diff --git a/src/core/model_configuration.py b/src/core/model_configuration.py
index f3a92c3..6129762 100644
--- a/src/core/model_configuration.py
+++ b/src/core/model_configuration.py
@@ -1317,26 +1317,23 @@ def _configure_torch_compile(compile_args: Dict[str, Any], model_type: str,
     # Check Triton availability for inductor backend BEFORE attempting compilation
     if settings['backend'] == 'inductor':
         if not TRITON_AVAILABLE:
-            warn_msg = (
+            error_msg = (
                 f"Cannot use torch.compile with 'inductor' backend: Triton is not installed.\n"
-                f"Automatically falling back to 'cudagraphs' backend if available, or disabling compilation.\n"
-                f"For best performance, install Triton: pip install triton"
+                f"\n"
+                f"Triton is required for the inductor backend which performs kernel fusion and optimization.\n"
+                f"\n"
+                f"To fix this issue:\n"
+                f"  1. Install Triton: pip install triton\n"
+                f"  2. OR change backend to 'cudagraphs' (lightweight, no Triton needed)\n"
+                f"  3. OR disable torch.compile\n"
+                f"\n"
+                f"For more info: https://github.com/triton-lang/triton"
+            )
+            debug.log(error_msg, level="ERROR", category="setup", force=True)
+            raise RuntimeError(
+                "torch.compile with inductor backend requires Triton. "
+                "Install with: pip install triton"
             )
-            debug.log(warn_msg, level="WARNING", category="setup", force=True)
-
-            # Check if cudagraphs is available as fallback
-            try:
-                import torch
-                # Simple check - if we can't use inductor, try to see if we can use cudagraphs
-                # But typically cudagraphs is built-in.
-                # Let's switch to cudagraphs and see.
-                settings['backend'] = 'cudagraphs'
-                debug.log("Switched backend to 'cudagraphs' due to missing Triton", category="setup", force=True)
-            except Exception:
-                debug.log("Could not switch to cudagraphs, disabling compilation", level="WARNING", category="setup")
-                raise RuntimeError("Triton missing and fallback failed") # Should be caught by caller if we wanted to
-
-            # If we switched, we don't raise RuntimeError anymore.
     
     # Log compilation configuration
     debug.log(f"Configuring torch.compile for {model_type}...", category="setup", force=True)
diff --git a/src/core/model_loader.py b/src/core/model_loader.py
index 705ee83..3ce1078 100644
--- a/src/core/model_loader.py
+++ b/src/core/model_loader.py
@@ -378,21 +378,6 @@ class GGUFTensor(torch.Tensor):
                         debug.log(f"Args: {[arg.shape if hasattr(arg, 'shape') else type(arg) for arg in args]}", level="WARNING", category="dit", force=True, indent_level=1)
                     raise
         
-        # Handle conv2d/conv3d operations specially
-        if func in {torch.nn.functional.conv2d, torch.nn.functional.conv3d}:
-            if len(args) >= 2 and isinstance(args[1], cls):  # weight is the second argument
-                try:
-                    weight_tensor = args[1]
-                    dequantized_weight = weight_tensor.dequantize(device=args[0].device, dtype=args[0].dtype)
-                    new_args = (args[0], dequantized_weight) + args[2:]
-                    return func(*new_args, **kwargs)
-                except Exception as e:
-                    if debug:
-                        debug.log(f"Error in conv dequantization: {e}", level="WARNING", category="dit", force=True)
-                        debug.log(f"Function: {func}", level="WARNING", category="dit", force=True, indent_level=1)
-                        debug.log(f"Args: {[arg.shape if hasattr(arg, 'shape') else type(arg) for arg in args]}", level="WARNING", category="dit", force=True, indent_level=1)
-                    raise
-
         # Handle matrix multiplication operations that need dequantization
         if func in {torch.matmul, torch.mm, torch.bmm, torch.addmm, torch.addmv,
                     torch.addr, torch.baddbmm, torch.chain_matmul}:
@@ -408,6 +393,20 @@ class GGUFTensor(torch.Tensor):
                 if debug:
                     debug.log(f"Error in {func.__name__} dequantization: {e}", level="WARNING", category="dit", force=True)
                 raise
+
+        # Handle conv2d/conv3d operations (critical for GGUF VAE models)
+        # Conv3d layers (InflatedCausalConv3d) are not replaced by layer replacement
+        if func in {torch.nn.functional.conv2d, torch.nn.functional.conv3d}:
+            if len(args) >= 2 and isinstance(args[1], cls):  # weight is second arg
+                try:
+                    weight_tensor = args[1]
+                    dequantized_weight = weight_tensor.dequantize(device=args[0].device, dtype=args[0].dtype)
+                    new_args = (args[0], dequantized_weight) + args[2:]
+                    return func(*new_args, **kwargs)
+                except Exception as e:
+                    if debug:
+                        debug.log(f"Error in conv dequantization: {e}", level="WARNING", category="dit", force=True)
+                    raise
         
         # For ALL other operations, delegate to parent WITHOUT dequantization
         # This includes .cpu(), .to(), .device, .dtype, .shape, etc.
diff --git a/src/models/video_vae_v3/modules/attn_video_vae.py b/src/models/video_vae_v3/modules/attn_video_vae.py
index dbe452e..de83771 100644
--- a/src/models/video_vae_v3/modules/attn_video_vae.py
+++ b/src/models/video_vae_v3/modules/attn_video_vae.py
@@ -313,7 +313,14 @@ class ResnetBlock3D(ResnetBlock2D):
     ):
         hidden_states = input_tensor
 
-        # Handle upsample/downsample first (usually involves 5D operations if temporal)
+        hidden_states = causal_norm_wrapper(self.norm1, hidden_states)
+        hidden_states = retry_on_oom(
+            self.nonlinearity,
+            hidden_states,
+            debug=getattr(self, 'debug', None),
+            operation_name="ResnetBlock3D.nonlinearity"
+        )
+
         if self.upsample is not None:
             # upsample_nearest_nhwc fails with large batch sizes.
             # see https://github.com/huggingface/diffusers/issues/984
@@ -326,78 +333,6 @@ class ResnetBlock3D(ResnetBlock2D):
             input_tensor = self.downsample(input_tensor, memory_state=memory_state)
             hidden_states = self.downsample(hidden_states, memory_state=memory_state)
 
-        # Check if we can run the main ResNet path in 4D (flattened temporal)
-        # Conditions:
-        # 1. Input is 5D (B, C, T, H, W)
-        # 2. conv1 and conv2 are effectively 2D (spatial only)
-        # 3. conv_shortcut (if present) is effectively 2D
-        # 4. time_embedding_norm is "default" (simple add) - others might need more complex broadcasting logic in 4D
-
-        can_run_4d = (
-            hidden_states.ndim == 5
-            and self.conv1.check_effective_2d()
-            and self.conv2.check_effective_2d()
-            and (self.conv_shortcut is None or self.conv_shortcut.check_effective_2d())
-            and (self.time_embedding_norm == "default" or temb is None)
-        )
-
-        if can_run_4d:
-            B, C, T, H, W = hidden_states.shape
-
-            # Reshape to 4D: (B*T, C, H, W)
-            # Use contiguous to ensure efficient memory layout for conv2d
-            hidden_states = hidden_states.transpose(1, 2).reshape(B * T, C, H, W).contiguous()
-            if input_tensor.ndim == 5:
-                input_tensor = input_tensor.transpose(1, 2).reshape(B * T, C, H, W).contiguous()
-
-            # Prepare temb for 4D
-            temb_4d = None
-            if self.time_emb_proj is not None and temb is not None:
-                if not self.skip_time_act:
-                    temb = self.nonlinearity(temb)
-                # temb: (B, C_emb) -> proj -> (B, C_out) -> (B, C_out, 1, 1)
-                # We need (B*T, C_out, 1, 1)
-                temb_proj = self.time_emb_proj(temb)[:, :, None, None]
-                # Expand B to B*T
-                temb_4d = temb_proj.repeat_interleave(T, dim=0)
-
-            # Main path in 4D
-            # causal_norm_wrapper handles 4D input by just calling GroupNorm (no rearrange overhead!)
-            hidden_states = causal_norm_wrapper(self.norm1, hidden_states)
-            hidden_states = self.nonlinearity(hidden_states)
-
-            # InflatedCausalConv3d handles 4D input by dispatching to conv2d (cached check)
-            hidden_states = self.conv1(hidden_states, memory_state=memory_state)
-
-            if temb_4d is not None and self.time_embedding_norm == "default":
-                hidden_states = hidden_states + temb_4d
-
-            hidden_states = causal_norm_wrapper(self.norm2, hidden_states)
-            hidden_states = self.nonlinearity(hidden_states)
-            hidden_states = self.dropout(hidden_states)
-            hidden_states = self.conv2(hidden_states, memory_state=memory_state)
-
-            if self.conv_shortcut is not None:
-                input_tensor = self.conv_shortcut(input_tensor, memory_state=memory_state)
-
-            output_tensor = (input_tensor + hidden_states) / self.output_scale_factor
-
-            # Reshape back to 5D: (B, C, T, H, W)
-            # Output is (B*T, C, H, W)
-            _, C_out, H_out, W_out = output_tensor.shape
-            output_tensor = output_tensor.view(B, T, C_out, H_out, W_out).transpose(1, 2)
-
-            return output_tensor
-
-        # Fallback to standard 5D path
-        hidden_states = causal_norm_wrapper(self.norm1, hidden_states)
-        hidden_states = retry_on_oom(
-            self.nonlinearity,
-            hidden_states,
-            debug=getattr(self, 'debug', None),
-            operation_name="ResnetBlock3D.nonlinearity"
-        )
-
         hidden_states = self.conv1(hidden_states, memory_state=memory_state)
 
         if self.time_emb_proj is not None:
@@ -1143,7 +1078,7 @@ class VideoAutoencoderKL(diffusers.AutoencoderKL):
         norm_num_groups: int = 32,
         sample_size: int = 32,
         scaling_factor: float = 0.18215,
-        force_upcast: float = False,
+        force_upcast: float = True,
         attention: bool = True,
         temporal_scale_num: int = 2,
         slicing_up_num: int = 0,
@@ -1289,10 +1224,6 @@ class VideoAutoencoderKL(diffusers.AutoencoderKL):
         
         output = causal_conv_gather_outputs(output)
         
-        # MPS memory leak workaround (pytorch/pytorch#155060)
-        if self.device.type == 'mps':
-            torch.mps.empty_cache()
-
         # Only transfer back if needed
         return output if output.device == x.device else output.to(x.device)
 
@@ -1309,10 +1240,6 @@ class VideoAutoencoderKL(diffusers.AutoencoderKL):
         output = self.decoder(_z, memory_state=memory_state)
         output = causal_conv_gather_outputs(output)
         
-        # MPS memory leak workaround (pytorch/pytorch#155060)
-        if self.device.type == 'mps':
-            torch.mps.empty_cache()
-
         # Only transfer back if needed
         return output if output.device == z.device else output.to(z.device)
 
diff --git a/src/models/video_vae_v3/modules/causal_inflation_lib.py b/src/models/video_vae_v3/modules/causal_inflation_lib.py
index 5071a5a..3dd7574 100644
--- a/src/models/video_vae_v3/modules/causal_inflation_lib.py
+++ b/src/models/video_vae_v3/modules/causal_inflation_lib.py
@@ -81,114 +81,16 @@ class InflatedCausalConv3d(Conv3d):
     def set_memory_device(self, memory_device: _memory_device_t):
         self.memory_device = memory_device
     
-    def check_effective_2d(self):
-        """
-        Check if the convolution is effectively 2D (spatial only) AND compatible with 2D optimization path.
-        Returns True if:
-        1. Temporal kernel size is 1 OR weights are tail-inflated (only last temporal slice is non-zero).
-        2. AND stride[0] == 1.
-        3. AND dilation[0] == 1.
-        4. AND padding[0] == 0 (self.padding is modified in __init__, this checks the spatial-only padding).
-        """
-        if hasattr(self, '_effective_2d'):
-            return self._effective_2d
-
-        # Check stride, dilation, padding first (fast checks)
-        if not (self.stride[0] == 1 and self.dilation[0] == 1 and self.padding[0] == 0):
-            self._effective_2d = False
-            return False
-
-        if self.kernel_size[0] == 1:
-            self._effective_2d = True
-            return True
-
-        # Check for tail inflation (all zeros except last slice in temporal dim)
-        # Weight shape: (Out, In, T, H, W)
-        with torch.no_grad():
-            # Check if all slices except the last one are zero
-            # Use a small threshold for float comparison or exact check for initialized weights
-            if torch.sum(torch.abs(self.weight[:, :, :-1, :, :])) < 1e-6:
-                self._effective_2d = True
-                return True
-
-        self._effective_2d = False
-        return False
-
-    def forward(
-        self,
-        input: Union[Tensor, List[Tensor]],
-        memory_state: MemoryState = MemoryState.UNSET
-    ) -> Tensor:
-        assert memory_state != MemoryState.UNSET
-        if memory_state != MemoryState.ACTIVE:
-            self.memory = None
-
-        # Handle 4D input directly (optimization for spatial-only blocks)
-        if torch.is_tensor(input) and input.ndim == 4:
-            # If 4D input is passed, we MUST be in the "effective 2D" path.
-            # Skip extend_head and memory logic, go straight to conv.
-            # _conv_forward handles the actual 2D dispatch.
-            return super().forward(input)
-
-        if (
-            math.isinf(self.memory_limit)
-            and torch.is_tensor(input)
-            and get_sequence_parallel_group() is None
-        ):
-            return self.basic_forward(input, memory_state)
-        return self.slicing_forward(input, memory_state)
-
     def _conv_forward(self, input, weight, bias, *args, **kwargs):
         """
         Override _conv_forward to work around NVIDIA Conv3d memory bug.
         
-        Bug: PyTorch 2.9+ with cuDNN >= 91002 uses 3x memory for Conv3d 
+        Bug: PyTorch 2.9-2.10 with cuDNN >= 91002 uses 3x memory for Conv3d 
         with fp16/bfloat16 weights due to buggy dispatch layer.
         
         Workaround: Call torch.cudnn_convolution directly to bypass buggy layer.
         Status is logged at startup in compatibility.py.
         """
-        # Optimization: Use fast 2D conv for spatial-only operations (no temporal mixing)
-        # Check: kernel_time=1 OR tail-inflated weights AND stride/dilation/padding compatibility
-        can_use_2d_path = self.check_effective_2d()
-
-        if can_use_2d_path:
-            # Handle 4D input directly (B*T folded into batch)
-            if input.ndim == 4:
-                # Input: (BT, C, H, W)
-                input_2d = input
-                is_4d_input = True
-            else:
-                # Input: (B, C, T, H, W) -> (B*T, C, H, W)
-                B, C, T, H, W = input.shape
-                input_2d = input.permute(0, 2, 1, 3, 4).reshape(B * T, C, H, W)
-                is_4d_input = False
-
-            # Prepare 2D weights
-            if self.kernel_size[0] == 1:
-                weight_2d = weight.squeeze(2)
-            else:
-                # Tail inflation: use the last temporal slice
-                weight_2d = weight[:, :, -1, :, :]
-
-            # Conv2D params
-            stride_2d = self.stride[1:]
-            padding_2d = self.padding[1:]
-            dilation_2d = self.dilation[1:]
-
-            # Execute standard Conv2d
-            out_2d = F.conv2d(
-                input_2d, weight_2d, bias, stride_2d, padding_2d, dilation_2d, self.groups
-            )
-
-            if is_4d_input:
-                return out_2d
-
-            # Reshape output back: (B*T, Out, H', W') -> (B, Out, T, H', W')
-            _, C_out, H_out, W_out = out_2d.shape
-            out = out_2d.view(B, T, C_out, H_out, W_out).permute(0, 2, 1, 3, 4)
-            return out
-
         if (NVIDIA_CONV3D_MEMORY_BUG_WORKAROUND and 
             weight.dtype in (torch.float16, torch.bfloat16) and 
             hasattr(torch.backends.cudnn, 'is_available') and
@@ -308,6 +210,22 @@ class InflatedCausalConv3d(Conv3d):
         )
         return output
 
+    def forward(
+        self,
+        input: Union[Tensor, List[Tensor]],
+        memory_state: MemoryState = MemoryState.UNSET
+    ) -> Tensor:
+        assert memory_state != MemoryState.UNSET
+        if memory_state != MemoryState.ACTIVE:
+            self.memory = None
+        if (
+            math.isinf(self.memory_limit)
+            and torch.is_tensor(input)
+            and get_sequence_parallel_group() is None
+        ):
+            return self.basic_forward(input, memory_state)
+        return self.slicing_forward(input, memory_state)
+
     def basic_forward(self, input: Tensor, memory_state: MemoryState = MemoryState.UNSET):
         mem_size = self.stride[0] - self.kernel_size[0]
         if (self.memory is not None) and (memory_state == MemoryState.ACTIVE):
@@ -582,4 +500,4 @@ def modify_state_dict(layer, state_dict, prefix, inflate_weight_fn, inflate_bias
                 inflation_mode=layer.inflation_mode,
             )
             state_dict[bias_name] = bias_3d
-    return state_dict
+    return state_dict
\ No newline at end of file
diff --git a/src/models/video_vae_v3/modules/video_vae.py b/src/models/video_vae_v3/modules/video_vae.py
index 66a1896..0823901 100644
--- a/src/models/video_vae_v3/modules/video_vae.py
+++ b/src/models/video_vae_v3/modules/video_vae.py
@@ -733,7 +733,7 @@ class VideoAutoencoderKL(nn.Module):
         if slicing_sample_min_size is None:
             slicing_sample_min_size = temporal_downsample_factor
         self.slicing_sample_min_size = slicing_sample_min_size
-        self.slicing_latent_min_size = slicing_sample_min_size // (2**temporal_scale_num)
+        self.slicing_latent_min_size = max(1, slicing_sample_min_size // (2**temporal_scale_num))
 
         # pass init params to Encoder
         self.encoder = Encoder3D(

From 396f323eae6537932c5a186ec687da9ba4409960 Mon Sep 17 00:00:00 2001
From: Adrien Toupet <cayus.net@gmail.com>
Date: Wed, 24 Dec 2025 02:14:33 +0100
Subject: [PATCH 13/16] Fix #437: Catch ValueError in bitsandbytes
 compatibility shim

Add ValueError to exception handling to catch packaging.InvalidVersion
errors during Intel Gaudi version detection on non-Gaudi systems.
---
 src/models/video_vae_v3/modules/causal_inflation_lib.py | 2 +-
 src/optimization/compatibility.py                       | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/models/video_vae_v3/modules/causal_inflation_lib.py b/src/models/video_vae_v3/modules/causal_inflation_lib.py
index 3dd7574..664f8b9 100644
--- a/src/models/video_vae_v3/modules/causal_inflation_lib.py
+++ b/src/models/video_vae_v3/modules/causal_inflation_lib.py
@@ -500,4 +500,4 @@ def modify_state_dict(layer, state_dict, prefix, inflate_weight_fn, inflate_bias
                 inflation_mode=layer.inflation_mode,
             )
             state_dict[bias_name] = bias_3d
-    return state_dict
\ No newline at end of file
+    return state_dict
diff --git a/src/optimization/compatibility.py b/src/optimization/compatibility.py
index 004c116..c462022 100644
--- a/src/optimization/compatibility.py
+++ b/src/optimization/compatibility.py
@@ -98,8 +98,8 @@ def ensure_bitsandbytes_safe():
     try:
         import bitsandbytes
         # Success - bitsandbytes works, other nodes can use it
-    except (ImportError, OSError, RuntimeError):
-        # Installation broken or not present - create stub
+    except (ImportError, OSError, RuntimeError, ValueError):
+        # Installation broken, not present, or version detection failed - create stub
         stub = types.ModuleType('bitsandbytes')
         stub.__spec__ = importlib.machinery.ModuleSpec('bitsandbytes', None)
         stub.__file__ = None

From f5617430549fa2db5d45cbd226e55e011d67e09f Mon Sep 17 00:00:00 2001
From: Adrien Toupet <cayus.net@gmail.com>
Date: Wed, 24 Dec 2025 02:22:46 +0100
Subject: [PATCH 14/16] Fix #434: Resolve dtype mismatch in LAB color transfer
 during video upscaling

Add explicit dtype alignment before matrix multiplication in _rgb_to_lab_batch
and _lab_to_rgb_batch to prevent float64 promotion from torch.pow operations.
Fixes RuntimeError: expected mat1 and mat2 to have the same dtype.
---
 src/utils/color_fix.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/utils/color_fix.py b/src/utils/color_fix.py
index 880b9b9..32ea943 100644
--- a/src/utils/color_fix.py
+++ b/src/utils/color_fix.py
@@ -381,6 +381,8 @@ def _rgb_to_lab_batch(rgb: Tensor, device: torch.device, matrix: Tensor, epsilon
     rgb_flat = rgb_linear.permute(0, 2, 3, 1).reshape(-1, 3)
     del rgb_linear
     
+    # Ensure dtype consistency for matrix multiplication
+    rgb_flat = rgb_flat.to(dtype=matrix.dtype)
     xyz_flat = torch.matmul(rgb_flat, matrix.T)
     del rgb_flat
     
@@ -452,6 +454,8 @@ def _lab_to_rgb_batch(lab: Tensor, device: torch.device, matrix_inv: Tensor, eps
     xyz_flat = xyz.permute(0, 2, 3, 1).reshape(-1, 3)
     del xyz
     
+    # Ensure dtype consistency for matrix multiplication
+    xyz_flat = xyz_flat.to(dtype=matrix_inv.dtype)
     rgb_linear_flat = torch.matmul(xyz_flat, matrix_inv.T)
     del xyz_flat
     

From 855f8b91b38f028a826cbe725864c92a0b13c5fd Mon Sep 17 00:00:00 2001
From: Adrien Toupet <cayus.net@gmail.com>
Date: Wed, 24 Dec 2025 02:49:42 +0100
Subject: [PATCH 15/16] Add sponsor call-to-action to footer

---
 src/utils/debug.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/utils/debug.py b/src/utils/debug.py
index 716c3da..f5059de 100644
--- a/src/utils/debug.py
+++ b/src/utils/debug.py
@@ -78,7 +78,7 @@ class Debug:
         "device": "🖥️",       # Device info
         "file": "📂",         # File operations
         "alpha": "👻",        # Alpha operations
-        "star": "⭐",         # Star
+        "starlove": "⭐💝",   # Star + love
         "dialogue": "💬",     # Dialogue
         "none" : "",
     }
@@ -259,9 +259,9 @@ class Debug:
         """Print the footer with links - always displayed"""
         self.log("", category="none", force=True)
         self.log("────────────────────────", category="none", force=True)
-        self.log("Questions? Updates? Watch the videos, star the repo & join us!", category="dialogue", force=True)
+        self.log("Questions? Updates? Watch, star & sponsor if you can!", category="dialogue", force=True)
         self.log("https://www.youtube.com/@AInVFX", category="generation", force=True)
-        self.log("https://github.com/numz/ComfyUI-SeedVR2_VideoUpscaler", category="star", force=True)
+        self.log("https://github.com/numz/ComfyUI-SeedVR2_VideoUpscaler", category="starlove", force=True)
     
     @torch._dynamo.disable  # Skip tracing to avoid time.time() warnings
     def start_timer(self, name: str, force: bool = False) -> None:

From 43e70bf63729dde7c653f965e9e4afbe2b7ffc9c Mon Sep 17 00:00:00 2001
From: Adrien Toupet <cayus.net@gmail.com>
Date: Wed, 24 Dec 2025 03:02:34 +0100
Subject: [PATCH 16/16] Release v2.5.23: Security & stability improvements

- Add security protection against malicious .pth files
- Fix FFmpeg video writer hanging issues (thanks @thehhmdb)
- Enable GGUF VAE model support via conv dequantization (thanks @naxci1)
- Fix VAE slicing division by zero edge cases (thanks @naxci1)
- Resolve LAB color transfer dtype mismatch errors
- Extend Conv3d memory workaround to PyTorch 2.9+
- Fix bitsandbytes compatibility on non-Gaudi systems
- Optimize MPS memory usage (thanks @s-cerevisiae)
---
 README.md              | 14 +++++++++++++-
 pyproject.toml         |  2 +-
 src/utils/constants.py |  2 +-
 3 files changed, 15 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 07fd9b3..e26bf35 100644
--- a/README.md
+++ b/README.md
@@ -36,6 +36,18 @@ We're actively working on improvements and new features. To stay informed:
 
 ## 🚀 Release Notes
 
+**2025.12.24 - Version 2.5.23**
+
+- **🔒 Security: Prevent code execution in model loading** - Added protection against malicious .pth files by restricting deserialization to tensors only
+- **🎥 Fix: FFmpeg video writer reliability** - Resolved ffmpeg process hanging issues by redirecting stderr and adding buffer flush, with improved error messages for debugging *(thanks [@thehhmdb](https://github.com/thehhmdb))*
+- **⚡ Fix: GGUF VAE model support** - Enabled automatic weight dequantization for convolution operations, making GGUF-quantized VAE models fully functional *(thanks [@naxci1](https://github.com/naxci1))*
+- **🛡️ Fix: VAE slicing edge cases** - Protected against division by zero crashes when using small split sizes with high temporal downsampling *(thanks [@naxci1](https://github.com/naxci1))*
+- **🎨 Fix: LAB color transfer precision** - Resolved dtype mismatch errors during video upscaling by ensuring consistent float types before matrix operations
+- **🔧 Fix: PyTorch 2.9+ compatibility** - Extended Conv3d memory workaround to all PyTorch 2.9+ versions, fixing 3x VRAM usage on newer PyTorch releases
+- **📦 Fix: Bitsandbytes compatibility** - Added ValueError exception handling for Intel Gaudi version detection failures on non-Gaudi systems
+- **🍎 MPS: Memory optimization** - Reduced memory usage during encode/decode operations on Apple Silicon *(thanks [@s-cerevisiae](https://github.com/s-cerevisiae))*
+
+
 **2025.12.13 - Version 2.5.22**
 
 - **🎬 CLI: FFmpeg video backend with 10-bit support** - New `--video_backend ffmpeg` and `--10bit` flags enable x265 encoding with 10-bit color depth, reducing banding artifacts in gradients compared to 8-bit OpenCV output *(based on PR by [@thehhmdb](https://github.com/thehhmdb) - thank you!)*
@@ -1030,7 +1042,7 @@ For detailed contribution guidelines, see [CONTRIBUTING.md](CONTRIBUTING.md).
 
 This ComfyUI implementation is a collaborative project by **[NumZ](https://github.com/numz)** and **[AInVFX](https://www.youtube.com/@AInVFX)** (Adrien Toupet), based on the original [SeedVR2](https://github.com/ByteDance-Seed/SeedVR) by ByteDance Seed Team.
 
-Special thanks to our community contributors including [naxci1](https://github.com/naxci1), [benjaminherb](https://github.com/benjaminherb), [cmeka](https://github.com/cmeka), [FurkanGozukara](https://github.com/FurkanGozukara), [JohnAlcatraz](https://github.com/JohnAlcatraz), [lihaoyun6](https://github.com/lihaoyun6), [Luchuanzhao](https://github.com/Luchuanzhao), [Luke2642](https://github.com/Luke2642), [proxyid](https://github.com/proxyid), [q5sys](https://github.com/q5sys), and many others for their improvements, bug fixes, and testing.
+Special thanks to our community contributors including [naxci1](https://github.com/naxci1), [thehhmdb](https://github.com/thehhmdb), [s-cerevisiae](https://github.com/s-cerevisiae), [benjaminherb](https://github.com/benjaminherb), [cmeka](https://github.com/cmeka), [FurkanGozukara](https://github.com/FurkanGozukara), [JohnAlcatraz](https://github.com/JohnAlcatraz), [lihaoyun6](https://github.com/lihaoyun6), [Luchuanzhao](https://github.com/Luchuanzhao), [Luke2642](https://github.com/Luke2642), [proxyid](https://github.com/proxyid), [q5sys](https://github.com/q5sys), and many others for their improvements, bug fixes, and testing.
 
 ## 📜 License
 
diff --git a/pyproject.toml b/pyproject.toml
index ff2ca79..aab7f49 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,7 +1,7 @@
 [project]
 name = "seedvr2_videoupscaler"
 description = "SeedVR2 official ComfyUI integration: ByteDance-Seed's one-step diffusion-based video/image upscaling with memory-efficient inference"
-version = "2.5.22"
+version = "2.5.23"
 authors = [
     {name = "numz"},
     {name = "adrientoupet"}
diff --git a/src/utils/constants.py b/src/utils/constants.py
index 1b3882f..4e2a287 100644
--- a/src/utils/constants.py
+++ b/src/utils/constants.py
@@ -4,7 +4,7 @@ Only includes constants actually used in the codebase
 """
 
 # Version information
-__version__ = "2.5.22"
+__version__ = "2.5.23"
 
 import os
 import warnings