Memory Management Regression in ComfyUI (Update 13)

[intervisionlord]

Custom Node Testing

• I have tried disabling custom nodes and the issue persists (see how to disable custom nodes if you need help)

Expected Behavior

• Models should load into RAM first, then offload to VRAM for inference, and subsequently be unloaded from RAM (proper memory offloading).
• Example workflow: Running "qwen image edit" with 4 reference images and generating up to 2K resolution should consume no more than 20GB RAM total.
• Memory should be efficiently managed across all models (e.g., Ace Step 1.5 after cold boot: ~8-10GB RAM usage, rest in VRAM).

Actual Behavior

• Memory is not being offloaded from RAM after models are moved to VRAM.
• Constant swapping/pagefile activity occurs between RAM and disk, potentially reducing SSD lifespan due to excessive writes.
• RAM consumption spikes to full capacity (32GB) during a single generation.
• Even after cold boot, Ace Step 1.5 now consumes up to 20GB RAM (vs. previous 8-10GB).
• System performance degraded significantly; workflows that previously ran smoothly are now nearly impossible to execute.

Steps to Reproduce

• Install ComfyUI Update 13 (with all associated updates).
• Load a model (e.g., qwen image edit or Ace Step 1.5) with moderate resource settings.
• Attempt a generation with multiple reference images (e.g., 4 references, up to 2K resolution).
• Monitor RAM usage, VRAM allocation, and pagefile activity.

Debug Logs

** ComfyUI startup time: 2026-02-20 08:30:23.426
[2026-02-20 08:30:23.427] ** Platform: Windows
[2026-02-20 08:30:23.427] ** Python version: 3.12.9 (main, Feb 12 2025, 14:52:31) [MSC v.1942 64 bit (AMD64)]
[2026-02-20 08:30:23.427] ** Python executable: D:\NEURO\FILES\.venv\Scripts\python.exe
[2026-02-20 08:30:23.427] ** ComfyUI Path: D:\NEURO\ComfyUI\resources\ComfyUI
[2026-02-20 08:30:23.427] ** ComfyUI Base Folder Path: D:\NEURO\ComfyUI\resources\ComfyUI
[2026-02-20 08:30:23.427] ** User directory: D:\NEURO\FILES\user
[2026-02-20 08:30:23.427] ** ComfyUI-Manager config path: D:\NEURO\FILES\user\__manager\config.ini
[2026-02-20 08:30:23.428] ** Log path: D:\NEURO\FILES\user\comfyui.log
[ComfyUI-Manager] Skipped fixing the 'comfyui-frontend-package' dependency because the ComfyUI is outdated.
[2026-02-20 08:30:24.892] [PRE] ComfyUI-Manager
[2026-02-20 08:30:25.547] D:\NEURO\FILES\.venv\Lib\site-packages\torch\cuda\__init__.py:63: FutureWarning: The pynvml package is deprecated. Please install nvidia-ml-py instead. If you did not install pynvml directly, please report this to the maintainers of the package that installed pynvml for you.
  import pynvml  # type: ignore[import]
[2026-02-20 08:30:28.034] WARNING: You need pytorch with cu130 or higher to use optimized CUDA operations.
[2026-02-20 08:30:28.035] Found comfy_kitchen backend eager: {'available': True, 'disabled': False, 'unavailable_reason': None, 'capabilities': ['apply_rope', 'apply_rope1', 'dequantize_nvfp4', 'dequantize_per_tensor_fp8', 'quantize_nvfp4', 'quantize_per_tensor_fp8', 'scaled_mm_nvfp4']}
[2026-02-20 08:30:28.035] Found comfy_kitchen backend cuda: {'available': True, 'disabled': True, 'unavailable_reason': None, 'capabilities': ['apply_rope', 'apply_rope1', 'dequantize_nvfp4', 'dequantize_per_tensor_fp8', 'quantize_nvfp4', 'quantize_per_tensor_fp8']}
[2026-02-20 08:30:28.035] Found comfy_kitchen backend triton: {'available': False, 'disabled': True, 'unavailable_reason': "ImportError: No module named 'triton'", 'capabilities': []}
[2026-02-20 08:30:28.046] Checkpoint files will always be loaded safely.
[2026-02-20 08:30:28.135] Total VRAM 16310 MB, total RAM 32690 MB
[2026-02-20 08:30:28.135] pytorch version: 2.8.0+cu129
[2026-02-20 08:30:28.137] Set vram state to: NORMAL_VRAM
[2026-02-20 08:30:28.138] Device: cuda:0 NVIDIA GeForce RTX 5060 Ti : cudaMallocAsync
[2026-02-20 08:30:28.155] Using async weight offloading with 2 streams
[2026-02-20 08:30:28.155] Enabled pinned memory 14710.0
[2026-02-20 08:30:28.679] Using pytorch attention
[2026-02-20 08:30:37.586] Python version: 3.12.9 (main, Feb 12 2025, 14:52:31) [MSC v.1942 64 bit (AMD64)]
[2026-02-20 08:30:37.586] ComfyUI version: 0.14.1
[2026-02-20 08:30:37.622] [Prompt Server] web root: D:\NEURO\ComfyUI\resources\ComfyUI\web_custom_versions\desktop_app
[2026-02-20 08:30:37.624] [START] ComfyUI-Manager
[2026-02-20 08:30:37.811] [ComfyUI-Manager] network_mode: public
[2026-02-20 08:30:37.843] [ComfyUI-Manager] The matrix sharing feature has been disabled because the `matrix-nio` dependency is not installed.
	To use this feature, please run the following command:
	D:\NEURO\FILES\.venv\Scripts\python.exe -m pip install matrix-nio

[2026-02-20 08:30:41.118] [Crystools �[0;32mINFO�[0m] Crystools version: 1.27.4
[2026-02-20 08:30:41.157] [Crystools �[0;32mINFO�[0m] Platform release: 11
[2026-02-20 08:30:41.157] [Crystools �[0;32mINFO�[0m] JETSON: Not detected.
[2026-02-20 08:30:41.158] [Crystools �[0;32mINFO�[0m] CPU: AMD Ryzen 5 3600 6-Core Processor - Arch: AMD64 - OS: Windows 11
[2026-02-20 08:30:41.170] [Crystools �[0;32mINFO�[0m] pynvml (NVIDIA) initialized.
[2026-02-20 08:30:41.170] [Crystools �[0;32mINFO�[0m] GPU/s:
[2026-02-20 08:30:41.181] [Crystools �[0;32mINFO�[0m] 0) NVIDIA GeForce RTX 5060 Ti
[2026-02-20 08:30:41.182] [Crystools �[0;32mINFO�[0m] NVIDIA Driver: 591.86
[2026-02-20 08:30:41.230] ### Loading: ComfyUI-Impact-Pack (V8.28.2)
[2026-02-20 08:30:41.445] [Impact Pack] Wildcard total size (0.00 MB) is within cache limit (50.00 MB). Using full cache mode.
[2026-02-20 08:30:41.446] [Impact Pack] Wildcards loading done.
[2026-02-20 08:30:43.134] (pysssss:WD14Tagger) [DEBUG] Available ORT providers: AzureExecutionProvider, CPUExecutionProvider
[2026-02-20 08:30:43.134] (pysssss:WD14Tagger) [DEBUG] Using ORT providers: CUDAExecutionProvider, CPUExecutionProvider
[2026-02-20 08:30:43.171] [D:\NEURO\FILES\custom_nodes\comfyui_controlnet_aux] | INFO -> Using ckpts path: D:\NEURO\FILES\custom_nodes\comfyui_controlnet_aux\ckpts
[2026-02-20 08:30:43.172] [D:\NEURO\FILES\custom_nodes\comfyui_controlnet_aux] | INFO -> Using symlinks: False
[2026-02-20 08:30:43.174] [D:\NEURO\FILES\custom_nodes\comfyui_controlnet_aux] | INFO -> Using ort providers: ['CUDAExecutionProvider', 'DirectMLExecutionProvider', 'OpenVINOExecutionProvider', 'ROCMExecutionProvider', 'CPUExecutionProvider', 'CoreMLExecutionProvider']
[2026-02-20 08:30:43.204] D:\NEURO\FILES\custom_nodes\comfyui_controlnet_aux\node_wrappers\dwpose.py:26: UserWarning: DWPose: Onnxruntime not found or doesn't come with acceleration providers, switch to OpenCV with CPU device. DWPose might run very slowly
  warnings.warn("DWPose: Onnxruntime not found or doesn't come with acceleration providers, switch to OpenCV with CPU device. DWPose might run very slowly")
[2026-02-20 08:30:43.364] USDU batch patches applied successfully.
[2026-02-20 08:30:43.364] USDU batch patches applied successfully.
[2026-02-20 08:30:45.564] 
********
Warning: flash-attn is not installed. Will only run the manual PyTorch version. Please install flash-attn for faster inference.
********
 
[2026-02-20 08:30:45.704] Training node missing dependencies: No module named 'qwen_tts.finetuning'
[2026-02-20 08:30:45.704] ✅ ComfyUI-Qwen-TTS v1.0.6 loaded
[2026-02-20 08:30:45.737] 
[2026-02-20 08:30:45.737] [rgthree-comfy] Loaded 48 epic nodes. 🎉
[2026-02-20 08:30:45.737] 
[2026-02-20 08:30:45.737] [rgthree-comfy] ComfyUI's new Node 2.0 rendering may be incompatible with some rgthree-comfy nodes and features, breaking some rendering as well as losing the ability to access a node's properties (a vital part of many nodes). It also appears to run MUCH more slowly spiking CPU usage and causing jankiness and unresponsiveness, especially with large workflows. Personally I am not planning to use the new Nodes 2.0 and, unfortunately, am not able to invest the time to investigate and overhaul rgthree-comfy where needed. If you have issues when Nodes 2.0 is enabled, I'd urge you to switch it off as well and join me in hoping ComfyUI is not planning to deprecate the existing, stable canvas rendering all together.
[2026-02-20 08:30:45.737] 
[2026-02-20 08:30:45.768] Blocked by policy: D:\NEURO\ComfyUI\resources\ComfyUI\custom_nodes\ComfyUI-Manager
[2026-02-20 08:30:45.782] [D:\NEURO\ComfyUI\resources\ComfyUI\custom_nodes\comfyui_controlnet_aux] | INFO -> Using ckpts path: D:\NEURO\ComfyUI\resources\ComfyUI\custom_nodes\comfyui_controlnet_aux\ckpts
[2026-02-20 08:30:45.783] [D:\NEURO\ComfyUI\resources\ComfyUI\custom_nodes\comfyui_controlnet_aux] | INFO -> Using symlinks: False
[2026-02-20 08:30:45.783] [D:\NEURO\ComfyUI\resources\ComfyUI\custom_nodes\comfyui_controlnet_aux] | INFO -> Using ort providers: ['CUDAExecutionProvider', 'DirectMLExecutionProvider', 'OpenVINOExecutionProvider', 'ROCMExecutionProvider', 'CPUExecutionProvider', 'CoreMLExecutionProvider']
[2026-02-20 08:30:45.836] 
Import times for custom nodes:
[2026-02-20 08:30:45.836]    0.0 seconds: D:\NEURO\ComfyUI\resources\ComfyUI\custom_nodes\websocket_image_save.py
[2026-02-20 08:30:45.836]    0.0 seconds: D:\NEURO\FILES\custom_nodes\ComfyUI--Wan22FirstLastFrameToVideoLatent
[2026-02-20 08:30:45.836]    0.0 seconds: D:\NEURO\FILES\custom_nodes\Image-Captioning-in-ComfyUI
[2026-02-20 08:30:45.836]    0.0 seconds: D:\NEURO\ComfyUI\resources\ComfyUI\custom_nodes\ComfyUI--Wan22FirstLastFrameToVideoLatent
[2026-02-20 08:30:45.836]    0.0 seconds: D:\NEURO\FILES\custom_nodes\comfyui_imageprocessing
[2026-02-20 08:30:45.836]    0.0 seconds: D:\NEURO\ComfyUI\resources\ComfyUI\custom_nodes\a-person-mask-generator
[2026-02-20 08:30:45.836]    0.0 seconds: D:\NEURO\ComfyUI\resources\ComfyUI\custom_nodes\comfy-image-saver
[2026-02-20 08:30:45.836]    0.0 seconds: D:\NEURO\FILES\custom_nodes\ComfyUI-VAE-Utils
[2026-02-20 08:30:45.836]    0.0 seconds: D:\NEURO\FILES\custom_nodes\comfyui-basic-math
[2026-02-20 08:30:45.836]    0.0 seconds: D:\NEURO\FILES\custom_nodes\qwen3-tts-comfyui
[2026-02-20 08:30:45.836]    0.0 seconds: D:\NEURO\FILES\custom_nodes\comfyui-post-processing-nodes
[2026-02-20 08:30:45.836]    0.0 seconds: D:\NEURO\FILES\custom_nodes\comfyui-wd14-tagger
[2026-02-20 08:30:45.836]    0.0 seconds: D:\NEURO\FILES\custom_nodes\stable-diffusion-temperature-settings
[2026-02-20 08:30:45.836]    0.0 seconds: D:\NEURO\FILES\custom_nodes\ComfyUI_Custom_Switch
[2026-02-20 08:30:45.836]    0.0 seconds: D:\NEURO\ComfyUI\resources\ComfyUI\custom_nodes\comfyui_ipadapter_plus
[2026-02-20 08:30:45.836]    0.0 seconds: D:\NEURO\ComfyUI\resources\ComfyUI\custom_nodes\comfyui-propost
[2026-02-20 08:30:45.837]    0.0 seconds: D:\NEURO\FILES\custom_nodes\flowmatching-inverter
[2026-02-20 08:30:45.837]    0.0 seconds: D:\NEURO\FILES\custom_nodes\comfyui_tag_fillter
[2026-02-20 08:30:45.837]    0.0 seconds: D:\NEURO\FILES\custom_nodes\comfy-image-saver
[2026-02-20 08:30:45.837]    0.0 seconds: D:\NEURO\ComfyUI\resources\ComfyUI\custom_nodes\ComfyUI-Whisper
[2026-02-20 08:30:45.837]    0.0 seconds: D:\NEURO\FILES\custom_nodes\comfyui_ipadapter_plus_v2
[2026-02-20 08:30:45.837]    0.0 seconds: D:\NEURO\ComfyUI\resources\ComfyUI\custom_nodes\wavespeed
[2026-02-20 08:30:45.837]    0.0 seconds: D:\NEURO\FILES\custom_nodes\steerable-motion
[2026-02-20 08:30:45.837]    0.0 seconds: D:\NEURO\FILES\custom_nodes\wavespeed
[2026-02-20 08:30:45.837]    0.0 seconds: D:\NEURO\FILES\custom_nodes\comfyui-frame-interpolation
[2026-02-20 08:30:45.837]    0.0 seconds: D:\NEURO\FILES\custom_nodes\ComfyUI-Whisper
[2026-02-20 08:30:45.837]    0.0 seconds: D:\NEURO\FILES\custom_nodes\rgthree-comfy
[2026-02-20 08:30:45.837]    0.0 seconds: D:\NEURO\FILES\custom_nodes\comfyui-kjnodes
[2026-02-20 08:30:45.837]    0.0 seconds: D:\NEURO\FILES\custom_nodes\comfyui_ipadapter_plus
[2026-02-20 08:30:45.837]    0.0 seconds: D:\NEURO\ComfyUI\resources\ComfyUI\custom_nodes\comfyui_controlnet_aux
[2026-02-20 08:30:45.837]    0.1 seconds: D:\NEURO\FILES\custom_nodes\comfyui_controlnet_aux
[2026-02-20 08:30:45.837]    0.1 seconds: D:\NEURO\FILES\custom_nodes\comfyui-videohelpersuite
[2026-02-20 08:30:45.837]    0.1 seconds: D:\NEURO\FILES\custom_nodes\comfyui_ultimatesdupscale
[2026-02-20 08:30:45.837]    0.1 seconds: D:\NEURO\FILES\custom_nodes\gguf
[2026-02-20 08:30:45.837]    0.2 seconds: D:\NEURO\FILES\custom_nodes\neuroseparatism
[2026-02-20 08:30:45.838]    0.2 seconds: D:\NEURO\FILES\custom_nodes\comfyui-impact-pack
[2026-02-20 08:30:45.838]    0.3 seconds: D:\NEURO\FILES\custom_nodes\ComfyUI-lut
[2026-02-20 08:30:45.838]    0.3 seconds: D:\NEURO\FILES\custom_nodes\LTX-Side
[2026-02-20 08:30:45.838]    0.4 seconds: D:\NEURO\FILES\custom_nodes\ComfyUI-Crystools
[2026-02-20 08:30:45.838]    0.5 seconds: D:\NEURO\FILES\custom_nodes\audio-separation-nodes-comfyui
[2026-02-20 08:30:45.838]    0.6 seconds: D:\NEURO\FILES\custom_nodes\comfyui-propost
[2026-02-20 08:30:45.838]    0.7 seconds: D:\NEURO\FILES\custom_nodes\comfyui-matchering
[2026-02-20 08:30:45.838]    0.8 seconds: D:\NEURO\FILES\custom_nodes\a-person-mask-generator
[2026-02-20 08:30:45.838]    1.7 seconds: D:\NEURO\FILES\custom_nodes\qwen3-tts
[2026-02-20 08:30:45.838] 
[2026-02-20 08:30:45.846] Context impl SQLiteImpl.
[2026-02-20 08:30:45.846] Will assume non-transactional DDL.
[2026-02-20 08:30:46.867] Assets scan(roots=['models']) completed in 1.019s (created=0, skipped_existing=236, orphans_pruned=0, total_seen=238)
[2026-02-20 08:30:46.984] Starting server

[2026-02-20 08:30:46.985] To see the GUI go to: http://127.0.0.1:8000
[2026-02-20 08:30:48.235] comfyui-frontend-package not found in requirements.txt
[2026-02-20 08:30:48.652] [DEPRECATION WARNING] Detected import of deprecated legacy API: /scripts/ui/components/buttonGroup.js. This is likely caused by a custom node extension using outdated APIs. Please update your extensions or contact the extension author for an updated version.
[2026-02-20 08:30:48.655] [DEPRECATION WARNING] Detected import of deprecated legacy API: /scripts/ui.js. This is likely caused by a custom node extension using outdated APIs. Please update your extensions or contact the extension author for an updated version.
[2026-02-20 08:30:48.657] [DEPRECATION WARNING] Detected import of deprecated legacy API: /extensions/core/clipspace.js. This is likely caused by a custom node extension using outdated APIs. Please update your extensions or contact the extension author for an updated version.
[2026-02-20 08:30:48.659] [DEPRECATION WARNING] Detected import of deprecated legacy API: /extensions/core/widgetInputs.js. This is likely caused by a custom node extension using outdated APIs. Please update your extensions or contact the extension author for an updated version.

Other

Environment:

• OS: Windows 11
• GPU: RTX 5060 Ti (16GB VRAM)
• System RAM: 32GB
• ComfyUI Version: After Update 13 (regression from previous behavior) - 0.14.2 / 0.8.6

Observed Result:

• RAM usage steadily increases and does not decrease even after model inference is complete.
• Pagefile thrashing observed; disk activity high.
• System becomes unresponsive or extremely slow during/after generation.

Expected Result:

• RAM usage should stabilize after model offloading to VRAM.
• Pagefile usage should be minimal and not impact disk lifespan.
• Generation should complete within previously observed resource limits (~20GB RAM).

Impact:

• Severe degradation in usability for users with 32GB RAM and 16GB VRAM.
• Potential hardware wear due to excessive pagefile writes.
• Affects multiple models, not just the examples given.

Additional Notes:

• No hardware or software changes were made besides updating ComfyUI.
• Issue is consistent across different models and workflows.
• This appears to be a regression in memory management/offloading logic introduced in Update 13

[ArtemKo7v]

I can also confirm the issue.
It reproduces for me when using gguf models in versions 0.13.0, 0.14.0, 0.14.1, and 0.14.2.
RAM is not being cleared after offloading to VRAM, which leads to OOM errors in complex workflows.
I don’t observe the problem when using safetensors.
There is a suspicion that this may be related to PR #12368.

[strawberrymelonpanda]

Models should load into RAM first, then offload to VRAM for inference, and subsequently be unloaded from RAM (proper memory offloading).

I am not using GGUF, but even with 128GB RAM, using the native workflows with safetensor files on WSL will cause RAM to climb with every new checkpoint switch, until it eventually errors out. (I keep swap small, as I'd rather have it error on OOM than page thrash).

Only solution I've found is to periodically run a drop cache. Can't promise that it's related, but I don't have this problem elsewhere and it wasn't a problem in the past. The memory management in general has became more problematic than it used to be, IMO.

[intervisionlord]

1. Double copying in cast_to for quantized models (lines 742-789)

if hasattr(weight, "_v"):  # GGUF/quantized weights
    # Creates multiple copies:
    v_tensor = comfy.memory_management.interpret_gathered_like(...)
    r = torch.empty_like(weight, dtype=dtype, device=device)  # Copy 1
    r.copy_(v_tensor)  # Copy 2

Every cast operation on GGUF models creates two additional copies of the weights:

• One from the compressed _v representation to v_tensor
• Another from v_tensor to the destination tensor r

2. Persistent cast buffers (lines 704-739)

def get_cast_buffer(...):
    cast_buffer = STREAM_CAST_BUFFERS.get(offload_stream, None)
    if cast_buffer is None or cast_buffer.numel() < size:
        cast_buffer = torch.empty((size), dtype=torch.int8, device=device)
        STREAM_CAST_BUFFERS[offload_stream] = cast_buffer  # Never freed!

The STREAM_CAST_BUFFERS dictionary holds onto large buffers indefinitely.

3. Threading overhead (lines 555-557, 579)

if enables_dynamic_vram():
    t = threading.Thread(target=load_models_gpu_thread, args=(...))
    t.start()
    t.join()

Each thread creates its own memory context, potentially duplicating structures.
Why GGUF models are hit hardest:

GGUF/quantized models already use the _v attribute for compressed storage. The new code:

• Always unpacks them to full precision intermediates
• Creates destination tensors before knowing if they're needed
• Keeps buffers sized for the largest weights seen (LARGEST_CASTED_WEIGHT tracking)

This effectively doubles (or triples) memory usage for quantized models:

• Compressed weights (_v)
• Unpacked intermediate (v_tensor)
• Destination tensor (r)

Suggested fixes:

• Optimize GGUF path: Skip intermediate copies and cast directly from _v when possible
• Buffer cleanup: Properly release STREAM_CAST_BUFFERS after use or implement LRU eviction
• Lazy allocation: Only allocate destination tensors when actually needed
• Thread-local isolation: Ensure threading doesn't duplicate memory contexts

The current implementation trades memory for speed, but the memory cost is too high for large models, especially quantized ones.

🫣🫣🫣

[intervisionlord]

fast fix:

in comfy/model_management.py

def cast_to(weight, dtype=None, device=None, non_blocking=False, copy=False, stream=None, r=None):
    # ADD THIS
    if hasattr(weight, "_v"):
        result = weight.to(device=device, dtype=dtype, copy=copy)
        try:
            comfy_aimdo.model_vbar.vbar_unpin(weight._v)
        except:
            pass
        return result
    ####
    if hasattr(weight, "_v"):
        #Unexpected usage patterns. There is no reason these don't work but they
        #have no testing and no callers do this.
        assert r is None
        assert stream is None

        cast_geometry = comfy.memory_management.tensors_to_geometries([ weight ])

        if dtype is None:
            dtype = weight._model_dtype

        signature = comfy_aimdo.model_vbar.vbar_fault(weight._v)
        if signature is not None:
            if comfy_aimdo.model_vbar.vbar_signature_compare(signature, weight._v_signature):
                v_tensor = weight._v_tensor
            else:
                raw_tensor = comfy_aimdo.torch.aimdo_to_tensor(weight._v, device)
                v_tensor = comfy.memory_management.interpret_gathered_like(cast_geometry, raw_tensor)[0]
                weight._v_tensor = v_tensor
                weight._v_signature = signature
                #Send it over
                v_tensor.copy_(weight, non_blocking=non_blocking)
            return v_tensor.to(dtype=dtype)

        r = torch.empty_like(weight, dtype=dtype, device=device)

        if weight.dtype != r.dtype and weight.dtype != weight._model_dtype:
            #Offloaded casting could skip this, however it would make the quantizations
            #inconsistent between loaded and offloaded weights. So force the double casting
            #that would happen in regular flow to make offload deterministic.
            cast_buffer = torch.empty_like(weight, dtype=weight._model_dtype, device=device)
            cast_buffer.copy_(weight, non_blocking=non_blocking)
            weight = cast_buffer
        r.copy_(weight, non_blocking=non_blocking)

        return r

There is also suspicion that the new feature affects the generation results, especially when needing to perform latent space interpolation of multiple vectors - before the fix, interpolation didn't work at all. After the fix, it works as reliably as it did before the update 13. As for exactly what the new feature does to the weights - there was no desire to investigate further, but the fact remains.

P.S. I'm so tired of these broken implementations (((

[DNPMBHC]

I have the same problem as well.

[gambikules]

same. after update v10 ram is consumed at 98% with ltxv2 and TTS models

[intervisionlord]

After Update 17 cast_to was modified, but.... #13042
Fundamental problem still persists

[intervisionlord]

@comfyanonymous

Right, the classic 'dumb AI issue' dismissal. Cool.

Except the hotfix I suggested literally works, and I've got the proof right here. Since you're so confident about 'actually understanding how your code works,' maybe take a second to look at the attached memory usage screenshots.

Tested on Qwen Image Edit Rapid GGUF v23 Q4_K — you know, an actual real-world workload.

Without the fix: memory leak goes brrrr, ComfyUI becomes unusable after a couple of runs.
With the fix: stable, no leak, actually behaves like it should.

So maybe — just maybe — the issue isn't that I don't understand your code, but that your code after v13 is what's actually broken. You know, the part that makes basic usage impossible unless someone patches it manually.

But sure, blame the 'dumb AI' instead of admitting there's a regression. Great look.

Also, since you're so hung up on this being a 'dumb AI issue' — let me clarify something.
I didn't make a pull request because I don't have the time to properly fix the thing you broke. That's why I explicitly wrote in the issue that this is a hotfix, a workaround, a quick knee‑jerk solution.

If you looked at it and thought 'lol dumb AI' just because it looks like a hacky workaround — maybe, just maybe, you should've actually read what I wrote. You know, the part where I clearly said it's a temporary band‑aid, not an elegant solution.

The whole point was to highlight the problem so you — the person who actually maintains this code — would finally fix it properly. But I guess it's easier to mock the messenger than to admit you introduced a regression.

So let's summarize the actual facts here.
Before v13: everything worked perfectly.
After v13 up to v17: completely broken.

And you're standing here telling me I don't understand your code?

You don't need a PhD in ComfyUI architecture to figure out that if something worked before and stopped working after your changes — maybe, just maybe, the problem is on your side.

This isn't rocket science. It's literally the most basic logic: works BEFORE → doesn't work AFTER. That alone tells you everything you need to know about who actually doesn't understand the code here.

But sure, keep blaming the guy who brought you the bug report with screenshots and a working hotfix. Really productive.

[intervisionlord]

Update 18 - same thing

With 'Native' memory management

• 108-110 sec per generation with reference resolution 1904*2560 and same output resolution.

'Old' hotfix (for version 17) * 103.7-104.7 sec - stable (same resolutions) *103.2 - 104.47 sec hotfix with 'r' variable handling for optimization (prepared for version 18) New hotfix is not ready now (and yes, in v18 same memory leakage problems)

[intervisionlord]

Totally degraded unstable behavior with RAM-VRAM transfer/allocation with SWAP/Pagefile usage

[ailovertech]

Models should load into RAM first, then offload to VRAM for inference, and subsequently be unloaded from RAM (proper memory offloading).

I am not using GGUF, but even with 128GB RAM, using the native workflows with safetensor files on WSL will cause RAM to climb with every new checkpoint switch, until it eventually errors out. (I keep swap small, as I'd rather have it error on OOM than page thrash).

Only solution I've found is to periodically run a drop cache. Can't promise that it's related, but I don't have this problem elsewhere and it wasn't a problem in the past. The memory management in general has became more problematic than it used to be, IMO.